Pileus Git - ~andy/linux/blob - fs/9p/vfs_file.c

   1 /*
   2  *  linux/fs/9p/vfs_file.c
   3  *
   4  * This file contians vfs file ops for 9P2000.
   5  *
   6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   7  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License version 2
  11  *  as published by the Free Software Foundation.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to:
  20  *  Free Software Foundation
  21  *  51 Franklin Street, Fifth Floor
  22  *  Boston, MA  02111-1301  USA
  23  *
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/errno.h>
  28 #include <linux/fs.h>
  29 #include <linux/sched.h>
  30 #include <linux/file.h>
  31 #include <linux/stat.h>
  32 #include <linux/string.h>
  33 #include <linux/inet.h>
  34 #include <linux/list.h>
  35 #include <linux/pagemap.h>
  36 #include <linux/utsname.h>
  37 #include <asm/uaccess.h>
  38 #include <linux/idr.h>
  39 #include <net/9p/9p.h>
  40 #include <net/9p/client.h>
  41
  42 #include "v9fs.h"
  43 #include "v9fs_vfs.h"
  44 #include "fid.h"
  45 #include "cache.h"
  46
  47 static const struct vm_operations_struct v9fs_file_vm_ops;
  48
  49 /**
  50  * v9fs_file_open - open a file (or directory)
  51  * @inode: inode to be opened
  52  * @file: file being opened
  53  *
  54  */
  55
  56 int v9fs_file_open(struct inode *inode, struct file *file)
  57 {
  58         int err;
  59         struct v9fs_inode *v9inode;
  60         struct v9fs_session_info *v9ses;
  61         struct p9_fid *fid;
  62         int omode;
  63
  64         P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
  65         v9inode = V9FS_I(inode);
  66         v9ses = v9fs_inode2v9ses(inode);
  67         if (v9fs_proto_dotl(v9ses))
  68                 omode = file->f_flags;
  69         else
  70                 omode = v9fs_uflags2omode(file->f_flags,
  71                                         v9fs_proto_dotu(v9ses));
  72         fid = file->private_data;
  73         if (!fid) {
  74                 fid = v9fs_fid_clone(file->f_path.dentry);
  75                 if (IS_ERR(fid))
  76                         return PTR_ERR(fid);
  77
  78                 err = p9_client_open(fid, omode);
  79                 if (err < 0) {
  80                         p9_client_clunk(fid);
  81                         return err;
  82                 }
  83                 if (file->f_flags & O_TRUNC) {
  84                         i_size_write(inode, 0);
  85                         inode->i_blocks = 0;
  86                 }
  87                 if ((file->f_flags & O_APPEND) &&
  88                         (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)))
  89                         generic_file_llseek(file, 0, SEEK_END);
  90         }
  91
  92         file->private_data = fid;
  93         mutex_lock(&v9inode->v_mutex);
  94         if (v9ses->cache && !v9inode->writeback_fid) {
  95                 /*
  96                  * clone a fid and add it to writeback_fid
  97                  * we do it during open time instead of
  98                  * page dirty time via write_begin/page_mkwrite
  99                  * because we want write after unlink usecase
 100                  * to work.
 101                  */
 102                 fid = v9fs_writeback_fid(file->f_path.dentry);
 103                 if (IS_ERR(fid)) {
 104                         err = PTR_ERR(fid);
 105                         mutex_unlock(&v9inode->v_mutex);
 106                         goto out_error;
 107                 }
 108                 v9inode->writeback_fid = (void *) fid;
 109         }
 110         mutex_unlock(&v9inode->v_mutex);
 111 #ifdef CONFIG_9P_FSCACHE
 112         if (v9ses->cache)
 113                 v9fs_cache_inode_set_cookie(inode, file);
 114 #endif
 115         return 0;
 116 out_error:
 117         p9_client_clunk(file->private_data);
 118         file->private_data = NULL;
 119         return err;
 120 }
 121
 122 /**
 123  * v9fs_file_lock - lock a file (or directory)
 124  * @filp: file to be locked
 125  * @cmd: lock command
 126  * @fl: file lock structure
 127  *
 128  * Bugs: this looks like a local only lock, we should extend into 9P
 129  *       by using open exclusive
 130  */
 131
 132 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 133 {
 134         int res = 0;
 135         struct inode *inode = filp->f_path.dentry->d_inode;
 136
 137         P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 138
 139         /* No mandatory locks */
 140         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 141                 return -ENOLCK;
 142
 143         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 144                 filemap_write_and_wait(inode->i_mapping);
 145                 invalidate_mapping_pages(&inode->i_data, 0, -1);
 146         }
 147
 148         return res;
 149 }
 150
 151 static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
 152 {
 153         struct p9_flock flock;
 154         struct p9_fid *fid;
 155         uint8_t status;
 156         int res = 0;
 157         unsigned char fl_type;
 158
 159         fid = filp->private_data;
 160         BUG_ON(fid == NULL);
 161
 162         if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
 163                 BUG();
 164
 165         res = posix_lock_file_wait(filp, fl);
 166         if (res < 0)
 167                 goto out;
 168
 169         /* convert posix lock to p9 tlock args */
 170         memset(&flock, 0, sizeof(flock));
 171         flock.type = fl->fl_type;
 172         flock.start = fl->fl_start;
 173         if (fl->fl_end == OFFSET_MAX)
 174                 flock.length = 0;
 175         else
 176                 flock.length = fl->fl_end - fl->fl_start + 1;
 177         flock.proc_id = fl->fl_pid;
 178         flock.client_id = utsname()->nodename;
 179         if (IS_SETLKW(cmd))
 180                 flock.flags = P9_LOCK_FLAGS_BLOCK;
 181
 182         /*
 183          * if its a blocked request and we get P9_LOCK_BLOCKED as the status
 184          * for lock request, keep on trying
 185          */
 186         for (;;) {
 187                 res = p9_client_lock_dotl(fid, &flock, &status);
 188                 if (res < 0)
 189                         break;
 190
 191                 if (status != P9_LOCK_BLOCKED)
 192                         break;
 193                 if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd))
 194                         break;
 195                 schedule_timeout_interruptible(P9_LOCK_TIMEOUT);
 196         }
 197
 198         /* map 9p status to VFS status */
 199         switch (status) {
 200         case P9_LOCK_SUCCESS:
 201                 res = 0;
 202                 break;
 203         case P9_LOCK_BLOCKED:
 204                 res = -EAGAIN;
 205                 break;
 206         case P9_LOCK_ERROR:
 207         case P9_LOCK_GRACE:
 208                 res = -ENOLCK;
 209                 break;
 210         default:
 211                 BUG();
 212         }
 213
 214         /*
 215          * incase server returned error for lock request, revert
 216          * it locally
 217          */
 218         if (res < 0 && fl->fl_type != F_UNLCK) {
 219                 fl_type = fl->fl_type;
 220                 fl->fl_type = F_UNLCK;
 221                 res = posix_lock_file_wait(filp, fl);
 222                 fl->fl_type = fl_type;
 223         }
 224 out:
 225         return res;
 226 }
 227
 228 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
 229 {
 230         struct p9_getlock glock;
 231         struct p9_fid *fid;
 232         int res = 0;
 233
 234         fid = filp->private_data;
 235         BUG_ON(fid == NULL);
 236
 237         posix_test_lock(filp, fl);
 238         /*
 239          * if we have a conflicting lock locally, no need to validate
 240          * with server
 241          */
 242         if (fl->fl_type != F_UNLCK)
 243                 return res;
 244
 245         /* convert posix lock to p9 tgetlock args */
 246         memset(&glock, 0, sizeof(glock));
 247         glock.type = fl->fl_type;
 248         glock.start = fl->fl_start;
 249         if (fl->fl_end == OFFSET_MAX)
 250                 glock.length = 0;
 251         else
 252                 glock.length = fl->fl_end - fl->fl_start + 1;
 253         glock.proc_id = fl->fl_pid;
 254         glock.client_id = utsname()->nodename;
 255
 256         res = p9_client_getlock_dotl(fid, &glock);
 257         if (res < 0)
 258                 return res;
 259         if (glock.type != F_UNLCK) {
 260                 fl->fl_type = glock.type;
 261                 fl->fl_start = glock.start;
 262                 if (glock.length == 0)
 263                         fl->fl_end = OFFSET_MAX;
 264                 else
 265                         fl->fl_end = glock.start + glock.length - 1;
 266                 fl->fl_pid = glock.proc_id;
 267         } else
 268                 fl->fl_type = F_UNLCK;
 269
 270         return res;
 271 }
 272
 273 /**
 274  * v9fs_file_lock_dotl - lock a file (or directory)
 275  * @filp: file to be locked
 276  * @cmd: lock command
 277  * @fl: file lock structure
 278  *
 279  */
 280
 281 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
 282 {
 283         struct inode *inode = filp->f_path.dentry->d_inode;
 284         int ret = -ENOLCK;
 285
 286         P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
 287                                 cmd, fl, filp->f_path.dentry->d_name.name);
 288
 289         /* No mandatory locks */
 290         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 291                 goto out_err;
 292
 293         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 294                 filemap_write_and_wait(inode->i_mapping);
 295                 invalidate_mapping_pages(&inode->i_data, 0, -1);
 296         }
 297
 298         if (IS_SETLK(cmd) || IS_SETLKW(cmd))
 299                 ret = v9fs_file_do_lock(filp, cmd, fl);
 300         else if (IS_GETLK(cmd))
 301                 ret = v9fs_file_getlock(filp, fl);
 302         else
 303                 ret = -EINVAL;
 304 out_err:
 305         return ret;
 306 }
 307
 308 /**
 309  * v9fs_file_flock_dotl - lock a file
 310  * @filp: file to be locked
 311  * @cmd: lock command
 312  * @fl: file lock structure
 313  *
 314  */
 315
 316 static int v9fs_file_flock_dotl(struct file *filp, int cmd,
 317         struct file_lock *fl)
 318 {
 319         struct inode *inode = filp->f_path.dentry->d_inode;
 320         int ret = -ENOLCK;
 321
 322         P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
 323                                 cmd, fl, filp->f_path.dentry->d_name.name);
 324
 325         /* No mandatory locks */
 326         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 327                 goto out_err;
 328
 329         if (!(fl->fl_flags & FL_FLOCK))
 330                 goto out_err;
 331
 332         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 333                 filemap_write_and_wait(inode->i_mapping);
 334                 invalidate_mapping_pages(&inode->i_data, 0, -1);
 335         }
 336         /* Convert flock to posix lock */
 337         fl->fl_owner = (fl_owner_t)filp;
 338         fl->fl_start = 0;
 339         fl->fl_end = OFFSET_MAX;
 340         fl->fl_flags |= FL_POSIX;
 341         fl->fl_flags ^= FL_FLOCK;
 342
 343         if (IS_SETLK(cmd) | IS_SETLKW(cmd))
 344                 ret = v9fs_file_do_lock(filp, cmd, fl);
 345         else
 346                 ret = -EINVAL;
 347 out_err:
 348         return ret;
 349 }
 350
 351 /**
 352  * v9fs_fid_readn - read from a fid
 353  * @fid: fid to read
 354  * @data: data buffer to read data into
 355  * @udata: user data buffer to read data into
 356  * @count: size of buffer
 357  * @offset: offset at which to read data
 358  *
 359  */
 360 ssize_t
 361 v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count,
 362                u64 offset)
 363 {
 364         int n, total, size;
 365
 366         P9_DPRINTK(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", fid->fid,
 367                    (long long unsigned) offset, count);
 368         n = 0;
 369         total = 0;
 370         size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
 371         do {
 372                 n = p9_client_read(fid, data, udata, offset, count);
 373                 if (n <= 0)
 374                         break;
 375
 376                 if (data)
 377                         data += n;
 378                 if (udata)
 379                         udata += n;
 380
 381                 offset += n;
 382                 count -= n;
 383                 total += n;
 384         } while (count > 0 && n == size);
 385
 386         if (n < 0)
 387                 total = n;
 388
 389         return total;
 390 }
 391
 392 /**
 393  * v9fs_file_readn - read from a file
 394  * @filp: file pointer to read
 395  * @data: data buffer to read data into
 396  * @udata: user data buffer to read data into
 397  * @count: size of buffer
 398  * @offset: offset at which to read data
 399  *
 400  */
 401 ssize_t
 402 v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count,
 403                u64 offset)
 404 {
 405         return v9fs_fid_readn(filp->private_data, data, udata, count, offset);
 406 }
 407
 408 /**
 409  * v9fs_file_read - read from a file
 410  * @filp: file pointer to read
 411  * @udata: user data buffer to read data into
 412  * @count: size of buffer
 413  * @offset: offset at which to read data
 414  *
 415  */
 416
 417 static ssize_t
 418 v9fs_file_read(struct file *filp, char __user *udata, size_t count,
 419                loff_t * offset)
 420 {
 421         int ret;
 422         struct p9_fid *fid;
 423         size_t size;
 424
 425         P9_DPRINTK(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset);
 426         fid = filp->private_data;
 427
 428         size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
 429         if (count > size)
 430                 ret = v9fs_file_readn(filp, NULL, udata, count, *offset);
 431         else
 432                 ret = p9_client_read(fid, NULL, udata, *offset, count);
 433
 434         if (ret > 0)
 435                 *offset += ret;
 436
 437         return ret;
 438 }
 439
 440 ssize_t
 441 v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
 442                          const char __user *data, size_t count,
 443                          loff_t *offset, int invalidate)
 444 {
 445         int n;
 446         loff_t i_size;
 447         size_t total = 0;
 448         struct p9_client *clnt;
 449         loff_t origin = *offset;
 450         unsigned long pg_start, pg_end;
 451
 452         P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
 453                 (int)count, (int)*offset);
 454
 455         clnt = fid->clnt;
 456         do {
 457                 n = p9_client_write(fid, NULL, data+total, origin+total, count);
 458                 if (n <= 0)
 459                         break;
 460                 count -= n;
 461                 total += n;
 462         } while (count > 0);
 463
 464         if (invalidate && (total > 0)) {
 465                 pg_start = origin >> PAGE_CACHE_SHIFT;
 466                 pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT;
 467                 if (inode->i_mapping && inode->i_mapping->nrpages)
 468                         invalidate_inode_pages2_range(inode->i_mapping,
 469                                                       pg_start, pg_end);
 470                 *offset += total;
 471                 i_size = i_size_read(inode);
 472                 if (*offset > i_size) {
 473                         inode_add_bytes(inode, *offset - i_size);
 474                         i_size_write(inode, *offset);
 475                 }
 476         }
 477         if (n < 0)
 478                 return n;
 479
 480         return total;
 481 }
 482
 483 /**
 484  * v9fs_file_write - write to a file
 485  * @filp: file pointer to write
 486  * @data: data buffer to write data from
 487  * @count: size of buffer
 488  * @offset: offset at which to write data
 489  *
 490  */
 491 static ssize_t
 492 v9fs_file_write(struct file *filp, const char __user * data,
 493                 size_t count, loff_t *offset)
 494 {
 495         ssize_t retval = 0;
 496         loff_t origin = *offset;
 497
 498
 499         retval = generic_write_checks(filp, &origin, &count, 0);
 500         if (retval)
 501                 goto out;
 502
 503         retval = -EINVAL;
 504         if ((ssize_t) count < 0)
 505                 goto out;
 506         retval = 0;
 507         if (!count)
 508                 goto out;
 509
 510         return v9fs_file_write_internal(filp->f_path.dentry->d_inode,
 511                                         filp->private_data,
 512                                         data, count, offset, 1);
 513 out:
 514         return retval;
 515 }
 516
 517
 518 static int v9fs_file_fsync(struct file *filp, int datasync)
 519 {
 520         struct p9_fid *fid;
 521         struct p9_wstat wstat;
 522         int retval;
 523
 524         P9_DPRINTK(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
 525
 526         fid = filp->private_data;
 527         v9fs_blank_wstat(&wstat);
 528
 529         retval = p9_client_wstat(fid, &wstat);
 530         return retval;
 531 }
 532
 533 int v9fs_file_fsync_dotl(struct file *filp, int datasync)
 534 {
 535         struct p9_fid *fid;
 536         int retval;
 537
 538         P9_DPRINTK(P9_DEBUG_VFS, "v9fs_file_fsync_dotl: filp %p datasync %x\n",
 539                         filp, datasync);
 540
 541         fid = filp->private_data;
 542
 543         retval = p9_client_fsync(fid, datasync);
 544         return retval;
 545 }
 546
 547 static int
 548 v9fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 549 {
 550         int retval;
 551
 552         retval = generic_file_mmap(file, vma);
 553         if (!retval)
 554                 vma->vm_ops = &v9fs_file_vm_ops;
 555
 556         return retval;
 557 }
 558
 559 static int
 560 v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 561 {
 562         struct v9fs_inode *v9inode;
 563         struct page *page = vmf->page;
 564         struct file *filp = vma->vm_file;
 565         struct inode *inode = filp->f_path.dentry->d_inode;
 566
 567
 568         P9_DPRINTK(P9_DEBUG_VFS, "page %p fid %lx\n",
 569                    page, (unsigned long)filp->private_data);
 570
 571         v9inode = V9FS_I(inode);
 572         /* make sure the cache has finished storing the page */
 573         v9fs_fscache_wait_on_page_write(inode, page);
 574         BUG_ON(!v9inode->writeback_fid);
 575         lock_page(page);
 576         if (page->mapping != inode->i_mapping)
 577                 goto out_unlock;
 578
 579         return VM_FAULT_LOCKED;
 580 out_unlock:
 581         unlock_page(page);
 582         return VM_FAULT_NOPAGE;
 583 }
 584
 585 static ssize_t
 586 v9fs_direct_read(struct file *filp, char __user *udata, size_t count,
 587                  loff_t *offsetp)
 588 {
 589         loff_t size, offset;
 590         struct inode *inode;
 591         struct address_space *mapping;
 592
 593         offset = *offsetp;
 594         mapping = filp->f_mapping;
 595         inode = mapping->host;
 596         if (!count)
 597                 return 0;
 598         size = i_size_read(inode);
 599         if (offset < size)
 600                 filemap_write_and_wait_range(mapping, offset,
 601                                              offset + count - 1);
 602
 603         return v9fs_file_read(filp, udata, count, offsetp);
 604 }
 605
 606 /**
 607  * v9fs_cached_file_read - read from a file
 608  * @filp: file pointer to read
 609  * @udata: user data buffer to read data into
 610  * @count: size of buffer
 611  * @offset: offset at which to read data
 612  *
 613  */
 614 static ssize_t
 615 v9fs_cached_file_read(struct file *filp, char __user *data, size_t count,
 616                       loff_t *offset)
 617 {
 618         if (filp->f_flags & O_DIRECT)
 619                 return v9fs_direct_read(filp, data, count, offset);
 620         return do_sync_read(filp, data, count, offset);
 621 }
 622
 623 static ssize_t
 624 v9fs_direct_write(struct file *filp, const char __user * data,
 625                   size_t count, loff_t *offsetp)
 626 {
 627         loff_t offset;
 628         ssize_t retval;
 629         struct inode *inode;
 630         struct address_space *mapping;
 631
 632         offset = *offsetp;
 633         mapping = filp->f_mapping;
 634         inode = mapping->host;
 635         if (!count)
 636                 return 0;
 637
 638         mutex_lock(&inode->i_mutex);
 639         retval = filemap_write_and_wait_range(mapping, offset,
 640                                               offset + count - 1);
 641         if (retval)
 642                 goto err_out;
 643         /*
 644          * After a write we want buffered reads to be sure to go to disk to get
 645          * the new data.  We invalidate clean cached page from the region we're
 646          * about to write.  We do this *before* the write so that if we fail
 647          * here we fall back to buffered write
 648          */
 649         if (mapping->nrpages) {
 650                 pgoff_t pg_start = offset >> PAGE_CACHE_SHIFT;
 651                 pgoff_t pg_end   = (offset + count - 1) >> PAGE_CACHE_SHIFT;
 652
 653                 retval = invalidate_inode_pages2_range(mapping,
 654                                                         pg_start, pg_end);
 655                 /*
 656                  * If a page can not be invalidated, fall back
 657                  * to buffered write.
 658                  */
 659                 if (retval) {
 660                         if (retval == -EBUSY)
 661                                 goto buff_write;
 662                         goto err_out;
 663                 }
 664         }
 665         retval = v9fs_file_write(filp, data, count, offsetp);
 666 err_out:
 667         mutex_unlock(&inode->i_mutex);
 668         return retval;
 669
 670 buff_write:
 671         mutex_unlock(&inode->i_mutex);
 672         return do_sync_write(filp, data, count, offsetp);
 673 }
 674
 675 /**
 676  * v9fs_cached_file_write - write to a file
 677  * @filp: file pointer to write
 678  * @data: data buffer to write data from
 679  * @count: size of buffer
 680  * @offset: offset at which to write data
 681  *
 682  */
 683 static ssize_t
 684 v9fs_cached_file_write(struct file *filp, const char __user * data,
 685                        size_t count, loff_t *offset)
 686 {
 687
 688         if (filp->f_flags & O_DIRECT)
 689                 return v9fs_direct_write(filp, data, count, offset);
 690         return do_sync_write(filp, data, count, offset);
 691 }
 692
 693 static const struct vm_operations_struct v9fs_file_vm_ops = {
 694         .fault = filemap_fault,
 695         .page_mkwrite = v9fs_vm_page_mkwrite,
 696 };
 697
 698
 699 const struct file_operations v9fs_cached_file_operations = {
 700         .llseek = generic_file_llseek,
 701         .read = v9fs_cached_file_read,
 702         .write = v9fs_cached_file_write,
 703         .aio_read = generic_file_aio_read,
 704         .aio_write = generic_file_aio_write,
 705         .open = v9fs_file_open,
 706         .release = v9fs_dir_release,
 707         .lock = v9fs_file_lock,
 708         .mmap = v9fs_file_mmap,
 709         .fsync = v9fs_file_fsync,
 710 };
 711
 712 const struct file_operations v9fs_cached_file_operations_dotl = {
 713         .llseek = generic_file_llseek,
 714         .read = v9fs_cached_file_read,
 715         .write = v9fs_cached_file_write,
 716         .aio_read = generic_file_aio_read,
 717         .aio_write = generic_file_aio_write,
 718         .open = v9fs_file_open,
 719         .release = v9fs_dir_release,
 720         .lock = v9fs_file_lock_dotl,
 721         .flock = v9fs_file_flock_dotl,
 722         .mmap = v9fs_file_mmap,
 723         .fsync = v9fs_file_fsync_dotl,
 724 };
 725
 726 const struct file_operations v9fs_file_operations = {
 727         .llseek = generic_file_llseek,
 728         .read = v9fs_file_read,
 729         .write = v9fs_file_write,
 730         .open = v9fs_file_open,
 731         .release = v9fs_dir_release,
 732         .lock = v9fs_file_lock,
 733         .mmap = generic_file_readonly_mmap,
 734         .fsync = v9fs_file_fsync,
 735 };
 736
 737 const struct file_operations v9fs_file_operations_dotl = {
 738         .llseek = generic_file_llseek,
 739         .read = v9fs_file_read,
 740         .write = v9fs_file_write,
 741         .open = v9fs_file_open,
 742         .release = v9fs_dir_release,
 743         .lock = v9fs_file_lock_dotl,
 744         .flock = v9fs_file_flock_dotl,
 745         .mmap = generic_file_readonly_mmap,
 746         .fsync = v9fs_file_fsync_dotl,
 747 };