[PATCH] ocfs2: fix mount option parsing
[linux-2.6] / fs / gfs2 / ops_file.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/pagemap.h>
15 #include <linux/uio.h>
16 #include <linux/blkdev.h>
17 #include <linux/mm.h>
18 #include <linux/fs.h>
19 #include <linux/gfs2_ondisk.h>
20 #include <linux/ext2_fs.h>
21 #include <linux/crc32.h>
22 #include <linux/lm_interface.h>
23 #include <linux/writeback.h>
24 #include <asm/uaccess.h>
25
26 #include "gfs2.h"
27 #include "incore.h"
28 #include "bmap.h"
29 #include "dir.h"
30 #include "glock.h"
31 #include "glops.h"
32 #include "inode.h"
33 #include "lm.h"
34 #include "log.h"
35 #include "meta_io.h"
36 #include "ops_file.h"
37 #include "ops_vm.h"
38 #include "quota.h"
39 #include "rgrp.h"
40 #include "trans.h"
41 #include "util.h"
42 #include "eaops.h"
43
44 /*
45  * Most fields left uninitialised to catch anybody who tries to
46  * use them. f_flags set to prevent file_accessed() from touching
47  * any other part of this. Its use is purely as a flag so that we
48  * know (in readpage()) whether or not do to locking.
49  */
50 struct file gfs2_internal_file_sentinel = {
51         .f_flags = O_NOATIME|O_RDONLY,
52 };
53
54 static int gfs2_read_actor(read_descriptor_t *desc, struct page *page,
55                            unsigned long offset, unsigned long size)
56 {
57         char *kaddr;
58         unsigned long count = desc->count;
59
60         if (size > count)
61                 size = count;
62
63         kaddr = kmap(page);
64         memcpy(desc->arg.data, kaddr + offset, size);
65         kunmap(page);
66
67         desc->count = count - size;
68         desc->written += size;
69         desc->arg.buf += size;
70         return size;
71 }
72
73 int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
74                        char *buf, loff_t *pos, unsigned size)
75 {
76         struct inode *inode = &ip->i_inode;
77         read_descriptor_t desc;
78         desc.written = 0;
79         desc.arg.data = buf;
80         desc.count = size;
81         desc.error = 0;
82         do_generic_mapping_read(inode->i_mapping, ra_state,
83                                 &gfs2_internal_file_sentinel, pos, &desc,
84                                 gfs2_read_actor);
85         return desc.written ? desc.written : desc.error;
86 }
87
88 /**
89  * gfs2_llseek - seek to a location in a file
90  * @file: the file
91  * @offset: the offset
92  * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
93  *
94  * SEEK_END requires the glock for the file because it references the
95  * file's size.
96  *
97  * Returns: The new offset, or errno
98  */
99
100 static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
101 {
102         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
103         struct gfs2_holder i_gh;
104         loff_t error;
105
106         if (origin == 2) {
107                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
108                                            &i_gh);
109                 if (!error) {
110                         error = remote_llseek(file, offset, origin);
111                         gfs2_glock_dq_uninit(&i_gh);
112                 }
113         } else
114                 error = remote_llseek(file, offset, origin);
115
116         return error;
117 }
118
119 /**
120  * gfs2_readdir - Read directory entries from a directory
121  * @file: The directory to read from
122  * @dirent: Buffer for dirents
123  * @filldir: Function used to do the copying
124  *
125  * Returns: errno
126  */
127
128 static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
129 {
130         struct inode *dir = file->f_mapping->host;
131         struct gfs2_inode *dip = GFS2_I(dir);
132         struct gfs2_holder d_gh;
133         u64 offset = file->f_pos;
134         int error;
135
136         gfs2_holder_init(dip->i_gl, LM_ST_SHARED, GL_ATIME, &d_gh);
137         error = gfs2_glock_nq_atime(&d_gh);
138         if (error) {
139                 gfs2_holder_uninit(&d_gh);
140                 return error;
141         }
142
143         error = gfs2_dir_read(dir, &offset, dirent, filldir);
144
145         gfs2_glock_dq_uninit(&d_gh);
146
147         file->f_pos = offset;
148
149         return error;
150 }
151
152 /**
153  * fsflags_cvt
154  * @table: A table of 32 u32 flags
155  * @val: a 32 bit value to convert
156  *
157  * This function can be used to convert between fsflags values and
158  * GFS2's own flags values.
159  *
160  * Returns: the converted flags
161  */
162 static u32 fsflags_cvt(const u32 *table, u32 val)
163 {
164         u32 res = 0;
165         while(val) {
166                 if (val & 1)
167                         res |= *table;
168                 table++;
169                 val >>= 1;
170         }
171         return res;
172 }
173
174 static const u32 fsflags_to_gfs2[32] = {
175         [3] = GFS2_DIF_SYNC,
176         [4] = GFS2_DIF_IMMUTABLE,
177         [5] = GFS2_DIF_APPENDONLY,
178         [7] = GFS2_DIF_NOATIME,
179         [12] = GFS2_DIF_EXHASH,
180         [14] = GFS2_DIF_INHERIT_JDATA,
181         [20] = GFS2_DIF_INHERIT_DIRECTIO,
182 };
183
184 static const u32 gfs2_to_fsflags[32] = {
185         [gfs2fl_Sync] = FS_SYNC_FL,
186         [gfs2fl_Immutable] = FS_IMMUTABLE_FL,
187         [gfs2fl_AppendOnly] = FS_APPEND_FL,
188         [gfs2fl_NoAtime] = FS_NOATIME_FL,
189         [gfs2fl_ExHash] = FS_INDEX_FL,
190         [gfs2fl_InheritDirectio] = FS_DIRECTIO_FL,
191         [gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
192 };
193
194 static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
195 {
196         struct inode *inode = filp->f_path.dentry->d_inode;
197         struct gfs2_inode *ip = GFS2_I(inode);
198         struct gfs2_holder gh;
199         int error;
200         u32 fsflags;
201
202         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
203         error = gfs2_glock_nq_atime(&gh);
204         if (error)
205                 return error;
206
207         fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_di.di_flags);
208         if (!S_ISDIR(inode->i_mode)) {
209                 if (ip->i_di.di_flags & GFS2_DIF_JDATA)
210                         fsflags |= FS_JOURNAL_DATA_FL;
211                 if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
212                         fsflags |= FS_DIRECTIO_FL;
213         }
214         if (put_user(fsflags, ptr))
215                 error = -EFAULT;
216
217         gfs2_glock_dq_m(1, &gh);
218         gfs2_holder_uninit(&gh);
219         return error;
220 }
221
222 void gfs2_set_inode_flags(struct inode *inode)
223 {
224         struct gfs2_inode *ip = GFS2_I(inode);
225         struct gfs2_dinode_host *di = &ip->i_di;
226         unsigned int flags = inode->i_flags;
227
228         flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
229         if (di->di_flags & GFS2_DIF_IMMUTABLE)
230                 flags |= S_IMMUTABLE;
231         if (di->di_flags & GFS2_DIF_APPENDONLY)
232                 flags |= S_APPEND;
233         if (di->di_flags & GFS2_DIF_NOATIME)
234                 flags |= S_NOATIME;
235         if (di->di_flags & GFS2_DIF_SYNC)
236                 flags |= S_SYNC;
237         inode->i_flags = flags;
238 }
239
240 /* Flags that can be set by user space */
241 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|                    \
242                              GFS2_DIF_DIRECTIO|                 \
243                              GFS2_DIF_IMMUTABLE|                \
244                              GFS2_DIF_APPENDONLY|               \
245                              GFS2_DIF_NOATIME|                  \
246                              GFS2_DIF_SYNC|                     \
247                              GFS2_DIF_SYSTEM|                   \
248                              GFS2_DIF_INHERIT_DIRECTIO|         \
249                              GFS2_DIF_INHERIT_JDATA)
250
251 /**
252  * gfs2_set_flags - set flags on an inode
253  * @inode: The inode
254  * @flags: The flags to set
255  * @mask: Indicates which flags are valid
256  *
257  */
258 static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
259 {
260         struct inode *inode = filp->f_path.dentry->d_inode;
261         struct gfs2_inode *ip = GFS2_I(inode);
262         struct gfs2_sbd *sdp = GFS2_SB(inode);
263         struct buffer_head *bh;
264         struct gfs2_holder gh;
265         int error;
266         u32 new_flags, flags;
267
268         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
269         if (error)
270                 return error;
271
272         flags = ip->i_di.di_flags;
273         new_flags = (flags & ~mask) | (reqflags & mask);
274         if ((new_flags ^ flags) == 0)
275                 goto out;
276
277         error = -EINVAL;
278         if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
279                 goto out;
280
281         error = -EPERM;
282         if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
283                 goto out;
284         if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
285                 goto out;
286         if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
287             !capable(CAP_LINUX_IMMUTABLE))
288                 goto out;
289         if (!IS_IMMUTABLE(inode)) {
290                 error = permission(inode, MAY_WRITE, NULL);
291                 if (error)
292                         goto out;
293         }
294
295         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
296         if (error)
297                 goto out;
298         error = gfs2_meta_inode_buffer(ip, &bh);
299         if (error)
300                 goto out_trans_end;
301         gfs2_trans_add_bh(ip->i_gl, bh, 1);
302         ip->i_di.di_flags = new_flags;
303         gfs2_dinode_out(ip, bh->b_data);
304         brelse(bh);
305         gfs2_set_inode_flags(inode);
306 out_trans_end:
307         gfs2_trans_end(sdp);
308 out:
309         gfs2_glock_dq_uninit(&gh);
310         return error;
311 }
312
313 static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
314 {
315         struct inode *inode = filp->f_path.dentry->d_inode;
316         u32 fsflags, gfsflags;
317         if (get_user(fsflags, ptr))
318                 return -EFAULT;
319         gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
320         if (!S_ISDIR(inode->i_mode)) {
321                 if (gfsflags & GFS2_DIF_INHERIT_JDATA)
322                         gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
323                 if (gfsflags & GFS2_DIF_INHERIT_DIRECTIO)
324                         gfsflags ^= (GFS2_DIF_DIRECTIO | GFS2_DIF_INHERIT_DIRECTIO);
325                 return do_gfs2_set_flags(filp, gfsflags, ~0);
326         }
327         return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
328 }
329
330 static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
331 {
332         switch(cmd) {
333         case FS_IOC_GETFLAGS:
334                 return gfs2_get_flags(filp, (u32 __user *)arg);
335         case FS_IOC_SETFLAGS:
336                 return gfs2_set_flags(filp, (u32 __user *)arg);
337         }
338         return -ENOTTY;
339 }
340
341
342 /**
343  * gfs2_mmap -
344  * @file: The file to map
345  * @vma: The VMA which described the mapping
346  *
347  * Returns: 0 or error code
348  */
349
350 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
351 {
352         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
353         struct gfs2_holder i_gh;
354         int error;
355
356         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
357         error = gfs2_glock_nq_atime(&i_gh);
358         if (error) {
359                 gfs2_holder_uninit(&i_gh);
360                 return error;
361         }
362
363         /* This is VM_MAYWRITE instead of VM_WRITE because a call
364            to mprotect() can turn on VM_WRITE later. */
365
366         if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
367             (VM_MAYSHARE | VM_MAYWRITE))
368                 vma->vm_ops = &gfs2_vm_ops_sharewrite;
369         else
370                 vma->vm_ops = &gfs2_vm_ops_private;
371
372         gfs2_glock_dq_uninit(&i_gh);
373
374         return error;
375 }
376
377 /**
378  * gfs2_open - open a file
379  * @inode: the inode to open
380  * @file: the struct file for this opening
381  *
382  * Returns: errno
383  */
384
385 static int gfs2_open(struct inode *inode, struct file *file)
386 {
387         struct gfs2_inode *ip = GFS2_I(inode);
388         struct gfs2_holder i_gh;
389         struct gfs2_file *fp;
390         int error;
391
392         fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
393         if (!fp)
394                 return -ENOMEM;
395
396         mutex_init(&fp->f_fl_mutex);
397
398         gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
399         file->private_data = fp;
400
401         if (S_ISREG(ip->i_inode.i_mode)) {
402                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
403                                            &i_gh);
404                 if (error)
405                         goto fail;
406
407                 if (!(file->f_flags & O_LARGEFILE) &&
408                     ip->i_di.di_size > MAX_NON_LFS) {
409                         error = -EFBIG;
410                         goto fail_gunlock;
411                 }
412
413                 /* Listen to the Direct I/O flag */
414
415                 if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
416                         file->f_flags |= O_DIRECT;
417
418                 gfs2_glock_dq_uninit(&i_gh);
419         }
420
421         return 0;
422
423 fail_gunlock:
424         gfs2_glock_dq_uninit(&i_gh);
425 fail:
426         file->private_data = NULL;
427         kfree(fp);
428         return error;
429 }
430
431 /**
432  * gfs2_close - called to close a struct file
433  * @inode: the inode the struct file belongs to
434  * @file: the struct file being closed
435  *
436  * Returns: errno
437  */
438
439 static int gfs2_close(struct inode *inode, struct file *file)
440 {
441         struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
442         struct gfs2_file *fp;
443
444         fp = file->private_data;
445         file->private_data = NULL;
446
447         if (gfs2_assert_warn(sdp, fp))
448                 return -EIO;
449
450         kfree(fp);
451
452         return 0;
453 }
454
455 /**
456  * gfs2_fsync - sync the dirty data for a file (across the cluster)
457  * @file: the file that points to the dentry (we ignore this)
458  * @dentry: the dentry that points to the inode to sync
459  *
460  * The VFS will flush "normal" data for us. We only need to worry
461  * about metadata here. For journaled data, we just do a log flush
462  * as we can't avoid it. Otherwise we can just bale out if datasync
463  * is set. For stuffed inodes we must flush the log in order to
464  * ensure that all data is on disk.
465  *
466  * The call to write_inode_now() is there to write back metadata and
467  * the inode itself. It does also try and write the data, but thats
468  * (hopefully) a no-op due to the VFS having already called filemap_fdatawrite()
469  * for us.
470  *
471  * Returns: errno
472  */
473
474 static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
475 {
476         struct inode *inode = dentry->d_inode;
477         int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
478         int ret = 0;
479
480         if (gfs2_is_jdata(GFS2_I(inode))) {
481                 gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
482                 return 0;
483         }
484
485         if (sync_state != 0) {
486                 if (!datasync)
487                         ret = write_inode_now(inode, 0);
488
489                 if (gfs2_is_stuffed(GFS2_I(inode)))
490                         gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
491         }
492
493         return ret;
494 }
495
496 /**
497  * gfs2_setlease - acquire/release a file lease
498  * @file: the file pointer
499  * @arg: lease type
500  * @fl: file lock
501  *
502  * Returns: errno
503  */
504
505 static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
506 {
507         struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
508
509         /*
510          * We don't currently have a way to enforce a lease across the whole
511          * cluster; until we do, disable leases (by just returning -EINVAL),
512          * unless the administrator has requested purely local locking.
513          */
514         if (!sdp->sd_args.ar_localflocks)
515                 return -EINVAL;
516         return generic_setlease(file, arg, fl);
517 }
518
519 /**
520  * gfs2_lock - acquire/release a posix lock on a file
521  * @file: the file pointer
522  * @cmd: either modify or retrieve lock state, possibly wait
523  * @fl: type and range of lock
524  *
525  * Returns: errno
526  */
527
528 static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
529 {
530         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
531         struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
532         struct lm_lockname name =
533                 { .ln_number = ip->i_no_addr,
534                   .ln_type = LM_TYPE_PLOCK };
535
536         if (!(fl->fl_flags & FL_POSIX))
537                 return -ENOLCK;
538         if ((ip->i_inode.i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
539                 return -ENOLCK;
540
541         if (sdp->sd_args.ar_localflocks) {
542                 if (IS_GETLK(cmd)) {
543                         posix_test_lock(file, fl);
544                         return 0;
545                 } else {
546                         return posix_lock_file_wait(file, fl);
547                 }
548         }
549
550         if (cmd == F_CANCELLK) {
551                 /* Hack: */
552                 cmd = F_SETLK;
553                 fl->fl_type = F_UNLCK;
554         }
555         if (IS_GETLK(cmd))
556                 return gfs2_lm_plock_get(sdp, &name, file, fl);
557         else if (fl->fl_type == F_UNLCK)
558                 return gfs2_lm_punlock(sdp, &name, file, fl);
559         else
560                 return gfs2_lm_plock(sdp, &name, file, cmd, fl);
561 }
562
563 static int do_flock(struct file *file, int cmd, struct file_lock *fl)
564 {
565         struct gfs2_file *fp = file->private_data;
566         struct gfs2_holder *fl_gh = &fp->f_fl_gh;
567         struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
568         struct gfs2_glock *gl;
569         unsigned int state;
570         int flags;
571         int error = 0;
572
573         state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
574         flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
575
576         mutex_lock(&fp->f_fl_mutex);
577
578         gl = fl_gh->gh_gl;
579         if (gl) {
580                 if (fl_gh->gh_state == state)
581                         goto out;
582                 gfs2_glock_hold(gl);
583                 flock_lock_file_wait(file,
584                                      &(struct file_lock){.fl_type = F_UNLCK});
585                 gfs2_glock_dq_uninit(fl_gh);
586         } else {
587                 error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
588                                       ip->i_no_addr, &gfs2_flock_glops,
589                                       CREATE, &gl);
590                 if (error)
591                         goto out;
592         }
593
594         gfs2_holder_init(gl, state, flags, fl_gh);
595         gfs2_glock_put(gl);
596
597         error = gfs2_glock_nq(fl_gh);
598         if (error) {
599                 gfs2_holder_uninit(fl_gh);
600                 if (error == GLR_TRYFAILED)
601                         error = -EAGAIN;
602         } else {
603                 error = flock_lock_file_wait(file, fl);
604                 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
605         }
606
607 out:
608         mutex_unlock(&fp->f_fl_mutex);
609         return error;
610 }
611
612 static void do_unflock(struct file *file, struct file_lock *fl)
613 {
614         struct gfs2_file *fp = file->private_data;
615         struct gfs2_holder *fl_gh = &fp->f_fl_gh;
616
617         mutex_lock(&fp->f_fl_mutex);
618         flock_lock_file_wait(file, fl);
619         if (fl_gh->gh_gl)
620                 gfs2_glock_dq_uninit(fl_gh);
621         mutex_unlock(&fp->f_fl_mutex);
622 }
623
624 /**
625  * gfs2_flock - acquire/release a flock lock on a file
626  * @file: the file pointer
627  * @cmd: either modify or retrieve lock state, possibly wait
628  * @fl: type and range of lock
629  *
630  * Returns: errno
631  */
632
633 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
634 {
635         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
636         struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
637
638         if (!(fl->fl_flags & FL_FLOCK))
639                 return -ENOLCK;
640         if ((ip->i_inode.i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
641                 return -ENOLCK;
642
643         if (sdp->sd_args.ar_localflocks)
644                 return flock_lock_file_wait(file, fl);
645
646         if (fl->fl_type == F_UNLCK) {
647                 do_unflock(file, fl);
648                 return 0;
649         } else {
650                 return do_flock(file, cmd, fl);
651         }
652 }
653
654 const struct file_operations gfs2_file_fops = {
655         .llseek         = gfs2_llseek,
656         .read           = do_sync_read,
657         .aio_read       = generic_file_aio_read,
658         .write          = do_sync_write,
659         .aio_write      = generic_file_aio_write,
660         .unlocked_ioctl = gfs2_ioctl,
661         .mmap           = gfs2_mmap,
662         .open           = gfs2_open,
663         .release        = gfs2_close,
664         .fsync          = gfs2_fsync,
665         .lock           = gfs2_lock,
666         .flock          = gfs2_flock,
667         .splice_read    = generic_file_splice_read,
668         .splice_write   = generic_file_splice_write,
669         .setlease       = gfs2_setlease,
670 };
671
672 const struct file_operations gfs2_dir_fops = {
673         .readdir        = gfs2_readdir,
674         .unlocked_ioctl = gfs2_ioctl,
675         .open           = gfs2_open,
676         .release        = gfs2_close,
677         .fsync          = gfs2_fsync,
678         .lock           = gfs2_lock,
679         .flock          = gfs2_flock,
680 };
681