root/fs/9p/vfs_file.c

DEFINITIONS

1. v9fs_file_open
2. v9fs_file_lock
3. v9fs_file_do_lock
4. v9fs_file_getlock
5. v9fs_file_lock_dotl
6. v9fs_file_flock_dotl
7. v9fs_file_read_iter
8. v9fs_file_write_iter
9. v9fs_file_fsync
10. v9fs_file_fsync_dotl
11. v9fs_file_mmap
12. v9fs_mmap_file_mmap
13. v9fs_vm_page_mkwrite
14. v9fs_mmap_file_read_iter
15. v9fs_mmap_file_write_iter
16. v9fs_mmap_vm_close

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