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