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