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