xref: /openbmc/linux/fs/9p/vfs_file.c (revision 565d76cb)
1 /*
2  *  linux/fs/9p/vfs_file.c
3  *
4  * This file contians vfs file ops for 9P2000.
5  *
6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License version 2
11  *  as published by the Free Software Foundation.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to:
20  *  Free Software Foundation
21  *  51 Franklin Street, Fifth Floor
22  *  Boston, MA  02111-1301  USA
23  *
24  */
25 
26 #include <linux/module.h>
27 #include <linux/errno.h>
28 #include <linux/fs.h>
29 #include <linux/sched.h>
30 #include <linux/file.h>
31 #include <linux/stat.h>
32 #include <linux/string.h>
33 #include <linux/inet.h>
34 #include <linux/list.h>
35 #include <linux/pagemap.h>
36 #include <linux/utsname.h>
37 #include <asm/uaccess.h>
38 #include <linux/idr.h>
39 #include <net/9p/9p.h>
40 #include <net/9p/client.h>
41 
42 #include "v9fs.h"
43 #include "v9fs_vfs.h"
44 #include "fid.h"
45 #include "cache.h"
46 
47 static const struct vm_operations_struct v9fs_file_vm_ops;
48 
49 /**
50  * v9fs_file_open - open a file (or directory)
51  * @inode: inode to be opened
52  * @file: file being opened
53  *
54  */
55 
56 int v9fs_file_open(struct inode *inode, struct file *file)
57 {
58 	int err;
59 	struct v9fs_inode *v9inode;
60 	struct v9fs_session_info *v9ses;
61 	struct p9_fid *fid;
62 	int omode;
63 
64 	P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
65 	v9inode = V9FS_I(inode);
66 	v9ses = v9fs_inode2v9ses(inode);
67 	if (v9fs_proto_dotl(v9ses))
68 		omode = file->f_flags;
69 	else
70 		omode = v9fs_uflags2omode(file->f_flags,
71 					v9fs_proto_dotu(v9ses));
72 	fid = file->private_data;
73 	if (!fid) {
74 		fid = v9fs_fid_clone(file->f_path.dentry);
75 		if (IS_ERR(fid))
76 			return PTR_ERR(fid);
77 
78 		err = p9_client_open(fid, omode);
79 		if (err < 0) {
80 			p9_client_clunk(fid);
81 			return err;
82 		}
83 		if (file->f_flags & O_TRUNC) {
84 			i_size_write(inode, 0);
85 			inode->i_blocks = 0;
86 		}
87 		if ((file->f_flags & O_APPEND) &&
88 			(!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)))
89 			generic_file_llseek(file, 0, SEEK_END);
90 	}
91 
92 	file->private_data = fid;
93 	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 	flock.type = fl->fl_type;
173 	flock.start = fl->fl_start;
174 	if (fl->fl_end == OFFSET_MAX)
175 		flock.length = 0;
176 	else
177 		flock.length = fl->fl_end - fl->fl_start + 1;
178 	flock.proc_id = fl->fl_pid;
179 	flock.client_id = utsname()->nodename;
180 	if (IS_SETLKW(cmd))
181 		flock.flags = P9_LOCK_FLAGS_BLOCK;
182 
183 	/*
184 	 * if its a blocked request and we get P9_LOCK_BLOCKED as the status
185 	 * for lock request, keep on trying
186 	 */
187 	for (;;) {
188 		res = p9_client_lock_dotl(fid, &flock, &status);
189 		if (res < 0)
190 			break;
191 
192 		if (status != P9_LOCK_BLOCKED)
193 			break;
194 		if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd))
195 			break;
196 		schedule_timeout_interruptible(P9_LOCK_TIMEOUT);
197 	}
198 
199 	/* map 9p status to VFS status */
200 	switch (status) {
201 	case P9_LOCK_SUCCESS:
202 		res = 0;
203 		break;
204 	case P9_LOCK_BLOCKED:
205 		res = -EAGAIN;
206 		break;
207 	case P9_LOCK_ERROR:
208 	case P9_LOCK_GRACE:
209 		res = -ENOLCK;
210 		break;
211 	default:
212 		BUG();
213 	}
214 
215 	/*
216 	 * incase server returned error for lock request, revert
217 	 * it locally
218 	 */
219 	if (res < 0 && fl->fl_type != F_UNLCK) {
220 		fl_type = fl->fl_type;
221 		fl->fl_type = F_UNLCK;
222 		res = posix_lock_file_wait(filp, fl);
223 		fl->fl_type = fl_type;
224 	}
225 out:
226 	return res;
227 }
228 
229 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
230 {
231 	struct p9_getlock glock;
232 	struct p9_fid *fid;
233 	int res = 0;
234 
235 	fid = filp->private_data;
236 	BUG_ON(fid == NULL);
237 
238 	posix_test_lock(filp, fl);
239 	/*
240 	 * if we have a conflicting lock locally, no need to validate
241 	 * with server
242 	 */
243 	if (fl->fl_type != F_UNLCK)
244 		return res;
245 
246 	/* convert posix lock to p9 tgetlock args */
247 	memset(&glock, 0, sizeof(glock));
248 	glock.type = fl->fl_type;
249 	glock.start = fl->fl_start;
250 	if (fl->fl_end == OFFSET_MAX)
251 		glock.length = 0;
252 	else
253 		glock.length = fl->fl_end - fl->fl_start + 1;
254 	glock.proc_id = fl->fl_pid;
255 	glock.client_id = utsname()->nodename;
256 
257 	res = p9_client_getlock_dotl(fid, &glock);
258 	if (res < 0)
259 		return res;
260 	if (glock.type != F_UNLCK) {
261 		fl->fl_type = glock.type;
262 		fl->fl_start = glock.start;
263 		if (glock.length == 0)
264 			fl->fl_end = OFFSET_MAX;
265 		else
266 			fl->fl_end = glock.start + glock.length - 1;
267 		fl->fl_pid = glock.proc_id;
268 	} else
269 		fl->fl_type = F_UNLCK;
270 
271 	return res;
272 }
273 
274 /**
275  * v9fs_file_lock_dotl - lock a file (or directory)
276  * @filp: file to be locked
277  * @cmd: lock command
278  * @fl: file lock structure
279  *
280  */
281 
282 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
283 {
284 	struct inode *inode = filp->f_path.dentry->d_inode;
285 	int ret = -ENOLCK;
286 
287 	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
288 				cmd, fl, filp->f_path.dentry->d_name.name);
289 
290 	/* No mandatory locks */
291 	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
292 		goto out_err;
293 
294 	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
295 		filemap_write_and_wait(inode->i_mapping);
296 		invalidate_mapping_pages(&inode->i_data, 0, -1);
297 	}
298 
299 	if (IS_SETLK(cmd) || IS_SETLKW(cmd))
300 		ret = v9fs_file_do_lock(filp, cmd, fl);
301 	else if (IS_GETLK(cmd))
302 		ret = v9fs_file_getlock(filp, fl);
303 	else
304 		ret = -EINVAL;
305 out_err:
306 	return ret;
307 }
308 
309 /**
310  * v9fs_file_flock_dotl - lock a file
311  * @filp: file to be locked
312  * @cmd: lock command
313  * @fl: file lock structure
314  *
315  */
316 
317 static int v9fs_file_flock_dotl(struct file *filp, int cmd,
318 	struct file_lock *fl)
319 {
320 	struct inode *inode = filp->f_path.dentry->d_inode;
321 	int ret = -ENOLCK;
322 
323 	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
324 				cmd, fl, filp->f_path.dentry->d_name.name);
325 
326 	/* No mandatory locks */
327 	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
328 		goto out_err;
329 
330 	if (!(fl->fl_flags & FL_FLOCK))
331 		goto out_err;
332 
333 	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
334 		filemap_write_and_wait(inode->i_mapping);
335 		invalidate_mapping_pages(&inode->i_data, 0, -1);
336 	}
337 	/* Convert flock to posix lock */
338 	fl->fl_owner = (fl_owner_t)filp;
339 	fl->fl_start = 0;
340 	fl->fl_end = OFFSET_MAX;
341 	fl->fl_flags |= FL_POSIX;
342 	fl->fl_flags ^= FL_FLOCK;
343 
344 	if (IS_SETLK(cmd) | IS_SETLKW(cmd))
345 		ret = v9fs_file_do_lock(filp, cmd, fl);
346 	else
347 		ret = -EINVAL;
348 out_err:
349 	return ret;
350 }
351 
352 /**
353  * v9fs_fid_readn - read from a fid
354  * @fid: fid to read
355  * @data: data buffer to read data into
356  * @udata: user data buffer to read data into
357  * @count: size of buffer
358  * @offset: offset at which to read data
359  *
360  */
361 ssize_t
362 v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count,
363 	       u64 offset)
364 {
365 	int n, total, size;
366 
367 	P9_DPRINTK(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", fid->fid,
368 		   (long long unsigned) offset, count);
369 	n = 0;
370 	total = 0;
371 	size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
372 	do {
373 		n = p9_client_read(fid, data, udata, offset, count);
374 		if (n <= 0)
375 			break;
376 
377 		if (data)
378 			data += n;
379 		if (udata)
380 			udata += n;
381 
382 		offset += n;
383 		count -= n;
384 		total += n;
385 	} while (count > 0 && n == size);
386 
387 	if (n < 0)
388 		total = n;
389 
390 	return total;
391 }
392 
393 /**
394  * v9fs_file_readn - read from a file
395  * @filp: file pointer to read
396  * @data: data buffer to read data into
397  * @udata: user data buffer to read data into
398  * @count: size of buffer
399  * @offset: offset at which to read data
400  *
401  */
402 ssize_t
403 v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count,
404 	       u64 offset)
405 {
406 	return v9fs_fid_readn(filp->private_data, data, udata, count, offset);
407 }
408 
409 /**
410  * v9fs_file_read - read from a file
411  * @filp: file pointer to read
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 
418 static ssize_t
419 v9fs_file_read(struct file *filp, char __user *udata, size_t count,
420 	       loff_t * offset)
421 {
422 	int ret;
423 	struct p9_fid *fid;
424 	size_t size;
425 
426 	P9_DPRINTK(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset);
427 	fid = filp->private_data;
428 
429 	size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
430 	if (count > size)
431 		ret = v9fs_file_readn(filp, NULL, udata, count, *offset);
432 	else
433 		ret = p9_client_read(fid, NULL, udata, *offset, count);
434 
435 	if (ret > 0)
436 		*offset += ret;
437 
438 	return ret;
439 }
440 
441 ssize_t
442 v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
443 			 const char __user *data, size_t count,
444 			 loff_t *offset, int invalidate)
445 {
446 	int n;
447 	loff_t i_size;
448 	size_t total = 0;
449 	struct p9_client *clnt;
450 	loff_t origin = *offset;
451 	unsigned long pg_start, pg_end;
452 
453 	P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
454 		(int)count, (int)*offset);
455 
456 	clnt = fid->clnt;
457 	do {
458 		n = p9_client_write(fid, NULL, data+total, origin+total, count);
459 		if (n <= 0)
460 			break;
461 		count -= n;
462 		total += n;
463 	} while (count > 0);
464 
465 	if (invalidate && (total > 0)) {
466 		pg_start = origin >> PAGE_CACHE_SHIFT;
467 		pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT;
468 		if (inode->i_mapping && inode->i_mapping->nrpages)
469 			invalidate_inode_pages2_range(inode->i_mapping,
470 						      pg_start, pg_end);
471 		*offset += total;
472 		i_size = i_size_read(inode);
473 		if (*offset > i_size) {
474 			inode_add_bytes(inode, *offset - i_size);
475 			i_size_write(inode, *offset);
476 		}
477 	}
478 	if (n < 0)
479 		return n;
480 
481 	return total;
482 }
483 
484 /**
485  * v9fs_file_write - write to a file
486  * @filp: file pointer to write
487  * @data: data buffer to write data from
488  * @count: size of buffer
489  * @offset: offset at which to write data
490  *
491  */
492 static ssize_t
493 v9fs_file_write(struct file *filp, const char __user * data,
494 		size_t count, loff_t *offset)
495 {
496 	ssize_t retval = 0;
497 	loff_t origin = *offset;
498 
499 
500 	retval = generic_write_checks(filp, &origin, &count, 0);
501 	if (retval)
502 		goto out;
503 
504 	retval = -EINVAL;
505 	if ((ssize_t) count < 0)
506 		goto out;
507 	retval = 0;
508 	if (!count)
509 		goto out;
510 
511 	retval = v9fs_file_write_internal(filp->f_path.dentry->d_inode,
512 					filp->private_data,
513 					data, count, &origin, 1);
514 	/* update offset on successful write */
515 	if (retval > 0)
516 		*offset = origin;
517 out:
518 	return retval;
519 }
520 
521 
522 static int v9fs_file_fsync(struct file *filp, int datasync)
523 {
524 	struct p9_fid *fid;
525 	struct p9_wstat wstat;
526 	int retval;
527 
528 	P9_DPRINTK(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
529 
530 	fid = filp->private_data;
531 	v9fs_blank_wstat(&wstat);
532 
533 	retval = p9_client_wstat(fid, &wstat);
534 	return retval;
535 }
536 
537 int v9fs_file_fsync_dotl(struct file *filp, int datasync)
538 {
539 	struct p9_fid *fid;
540 	int retval;
541 
542 	P9_DPRINTK(P9_DEBUG_VFS, "v9fs_file_fsync_dotl: filp %p datasync %x\n",
543 			filp, datasync);
544 
545 	fid = filp->private_data;
546 
547 	retval = p9_client_fsync(fid, datasync);
548 	return retval;
549 }
550 
551 static int
552 v9fs_file_mmap(struct file *file, struct vm_area_struct *vma)
553 {
554 	int retval;
555 
556 	retval = generic_file_mmap(file, vma);
557 	if (!retval)
558 		vma->vm_ops = &v9fs_file_vm_ops;
559 
560 	return retval;
561 }
562 
563 static int
564 v9fs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
565 {
566 	struct v9fs_inode *v9inode;
567 	struct page *page = vmf->page;
568 	struct file *filp = vma->vm_file;
569 	struct inode *inode = filp->f_path.dentry->d_inode;
570 
571 
572 	P9_DPRINTK(P9_DEBUG_VFS, "page %p fid %lx\n",
573 		   page, (unsigned long)filp->private_data);
574 
575 	v9inode = V9FS_I(inode);
576 	/* make sure the cache has finished storing the page */
577 	v9fs_fscache_wait_on_page_write(inode, page);
578 	BUG_ON(!v9inode->writeback_fid);
579 	lock_page(page);
580 	if (page->mapping != inode->i_mapping)
581 		goto out_unlock;
582 
583 	return VM_FAULT_LOCKED;
584 out_unlock:
585 	unlock_page(page);
586 	return VM_FAULT_NOPAGE;
587 }
588 
589 static ssize_t
590 v9fs_direct_read(struct file *filp, char __user *udata, size_t count,
591 		 loff_t *offsetp)
592 {
593 	loff_t size, offset;
594 	struct inode *inode;
595 	struct address_space *mapping;
596 
597 	offset = *offsetp;
598 	mapping = filp->f_mapping;
599 	inode = mapping->host;
600 	if (!count)
601 		return 0;
602 	size = i_size_read(inode);
603 	if (offset < size)
604 		filemap_write_and_wait_range(mapping, offset,
605 					     offset + count - 1);
606 
607 	return v9fs_file_read(filp, udata, count, offsetp);
608 }
609 
610 /**
611  * v9fs_cached_file_read - read from a file
612  * @filp: file pointer to read
613  * @udata: user data buffer to read data into
614  * @count: size of buffer
615  * @offset: offset at which to read data
616  *
617  */
618 static ssize_t
619 v9fs_cached_file_read(struct file *filp, char __user *data, size_t count,
620 		      loff_t *offset)
621 {
622 	if (filp->f_flags & O_DIRECT)
623 		return v9fs_direct_read(filp, data, count, offset);
624 	return do_sync_read(filp, data, count, offset);
625 }
626 
627 static ssize_t
628 v9fs_direct_write(struct file *filp, const char __user * data,
629 		  size_t count, loff_t *offsetp)
630 {
631 	loff_t offset;
632 	ssize_t retval;
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 
642 	mutex_lock(&inode->i_mutex);
643 	retval = filemap_write_and_wait_range(mapping, offset,
644 					      offset + count - 1);
645 	if (retval)
646 		goto err_out;
647 	/*
648 	 * After a write we want buffered reads to be sure to go to disk to get
649 	 * the new data.  We invalidate clean cached page from the region we're
650 	 * about to write.  We do this *before* the write so that if we fail
651 	 * here we fall back to buffered write
652 	 */
653 	if (mapping->nrpages) {
654 		pgoff_t pg_start = offset >> PAGE_CACHE_SHIFT;
655 		pgoff_t pg_end   = (offset + count - 1) >> PAGE_CACHE_SHIFT;
656 
657 		retval = invalidate_inode_pages2_range(mapping,
658 							pg_start, pg_end);
659 		/*
660 		 * If a page can not be invalidated, fall back
661 		 * to buffered write.
662 		 */
663 		if (retval) {
664 			if (retval == -EBUSY)
665 				goto buff_write;
666 			goto err_out;
667 		}
668 	}
669 	retval = v9fs_file_write(filp, data, count, offsetp);
670 err_out:
671 	mutex_unlock(&inode->i_mutex);
672 	return retval;
673 
674 buff_write:
675 	mutex_unlock(&inode->i_mutex);
676 	return do_sync_write(filp, data, count, offsetp);
677 }
678 
679 /**
680  * v9fs_cached_file_write - write to a file
681  * @filp: file pointer to write
682  * @data: data buffer to write data from
683  * @count: size of buffer
684  * @offset: offset at which to write data
685  *
686  */
687 static ssize_t
688 v9fs_cached_file_write(struct file *filp, const char __user * data,
689 		       size_t count, loff_t *offset)
690 {
691 
692 	if (filp->f_flags & O_DIRECT)
693 		return v9fs_direct_write(filp, data, count, offset);
694 	return do_sync_write(filp, data, count, offset);
695 }
696 
697 static const struct vm_operations_struct v9fs_file_vm_ops = {
698 	.fault = filemap_fault,
699 	.page_mkwrite = v9fs_vm_page_mkwrite,
700 };
701 
702 
703 const struct file_operations v9fs_cached_file_operations = {
704 	.llseek = generic_file_llseek,
705 	.read = v9fs_cached_file_read,
706 	.write = v9fs_cached_file_write,
707 	.aio_read = generic_file_aio_read,
708 	.aio_write = generic_file_aio_write,
709 	.open = v9fs_file_open,
710 	.release = v9fs_dir_release,
711 	.lock = v9fs_file_lock,
712 	.mmap = v9fs_file_mmap,
713 	.fsync = v9fs_file_fsync,
714 };
715 
716 const struct file_operations v9fs_cached_file_operations_dotl = {
717 	.llseek = generic_file_llseek,
718 	.read = v9fs_cached_file_read,
719 	.write = v9fs_cached_file_write,
720 	.aio_read = generic_file_aio_read,
721 	.aio_write = generic_file_aio_write,
722 	.open = v9fs_file_open,
723 	.release = v9fs_dir_release,
724 	.lock = v9fs_file_lock_dotl,
725 	.flock = v9fs_file_flock_dotl,
726 	.mmap = v9fs_file_mmap,
727 	.fsync = v9fs_file_fsync_dotl,
728 };
729 
730 const struct file_operations v9fs_file_operations = {
731 	.llseek = generic_file_llseek,
732 	.read = v9fs_file_read,
733 	.write = v9fs_file_write,
734 	.open = v9fs_file_open,
735 	.release = v9fs_dir_release,
736 	.lock = v9fs_file_lock,
737 	.mmap = generic_file_readonly_mmap,
738 	.fsync = v9fs_file_fsync,
739 };
740 
741 const struct file_operations v9fs_file_operations_dotl = {
742 	.llseek = generic_file_llseek,
743 	.read = v9fs_file_read,
744 	.write = v9fs_file_write,
745 	.open = v9fs_file_open,
746 	.release = v9fs_dir_release,
747 	.lock = v9fs_file_lock_dotl,
748 	.flock = v9fs_file_flock_dotl,
749 	.mmap = generic_file_readonly_mmap,
750 	.fsync = v9fs_file_fsync_dotl,
751 };
752