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