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