2 * linux/fs/9p/vfs_file.c
4 * This file contians vfs file ops for 9P2000.
6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
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.
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.
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
26 #include <linux/module.h>
27 #include <linux/errno.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>
47 static const struct vm_operations_struct v9fs_file_vm_ops
;
50 * v9fs_file_open - open a file (or directory)
51 * @inode: inode to be opened
52 * @file: file being opened
56 int v9fs_file_open(struct inode
*inode
, struct file
*file
)
59 struct v9fs_inode
*v9inode
;
60 struct v9fs_session_info
*v9ses
;
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
;
70 omode
= v9fs_uflags2omode(file
->f_flags
,
71 v9fs_proto_dotu(v9ses
));
72 fid
= file
->private_data
;
74 fid
= v9fs_fid_clone(file
->f_path
.dentry
);
78 err
= p9_client_open(fid
, omode
);
83 if (file
->f_flags
& O_TRUNC
) {
84 i_size_write(inode
, 0);
87 if ((file
->f_flags
& O_APPEND
) &&
88 (!v9fs_proto_dotu(v9ses
) && !v9fs_proto_dotl(v9ses
)))
89 generic_file_llseek(file
, 0, SEEK_END
);
92 file
->private_data
= fid
;
93 if (v9ses
->cache
&& !v9inode
->writeback_fid
) {
95 * clone a fid and add it to writeback_fid
96 * we do it during open time instead of
97 * page dirty time via write_begin/page_mkwrite
98 * because we want write after unlink usecase
101 fid
= v9fs_writeback_fid(file
->f_path
.dentry
);
106 v9inode
->writeback_fid
= (void *) fid
;
108 #ifdef CONFIG_9P_FSCACHE
110 v9fs_cache_inode_set_cookie(inode
, file
);
114 p9_client_clunk(file
->private_data
);
115 file
->private_data
= NULL
;
120 * v9fs_file_lock - lock a file (or directory)
121 * @filp: file to be locked
123 * @fl: file lock structure
125 * Bugs: this looks like a local only lock, we should extend into 9P
126 * by using open exclusive
129 static int v9fs_file_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
132 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
134 P9_DPRINTK(P9_DEBUG_VFS
, "filp: %p lock: %p\n", filp
, fl
);
136 /* No mandatory locks */
137 if (__mandatory_lock(inode
) && fl
->fl_type
!= F_UNLCK
)
140 if ((IS_SETLK(cmd
) || IS_SETLKW(cmd
)) && fl
->fl_type
!= F_UNLCK
) {
141 filemap_write_and_wait(inode
->i_mapping
);
142 invalidate_mapping_pages(&inode
->i_data
, 0, -1);
148 static int v9fs_file_do_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
150 struct p9_flock flock
;
154 unsigned char fl_type
;
156 fid
= filp
->private_data
;
159 if ((fl
->fl_flags
& FL_POSIX
) != FL_POSIX
)
162 res
= posix_lock_file_wait(filp
, fl
);
166 /* convert posix lock to p9 tlock args */
167 memset(&flock
, 0, sizeof(flock
));
168 flock
.type
= fl
->fl_type
;
169 flock
.start
= fl
->fl_start
;
170 if (fl
->fl_end
== OFFSET_MAX
)
173 flock
.length
= fl
->fl_end
- fl
->fl_start
+ 1;
174 flock
.proc_id
= fl
->fl_pid
;
175 flock
.client_id
= utsname()->nodename
;
177 flock
.flags
= P9_LOCK_FLAGS_BLOCK
;
180 * if its a blocked request and we get P9_LOCK_BLOCKED as the status
181 * for lock request, keep on trying
184 res
= p9_client_lock_dotl(fid
, &flock
, &status
);
188 if (status
!= P9_LOCK_BLOCKED
)
190 if (status
== P9_LOCK_BLOCKED
&& !IS_SETLKW(cmd
))
192 schedule_timeout_interruptible(P9_LOCK_TIMEOUT
);
195 /* map 9p status to VFS status */
197 case P9_LOCK_SUCCESS
:
200 case P9_LOCK_BLOCKED
:
212 * incase server returned error for lock request, revert
215 if (res
< 0 && fl
->fl_type
!= F_UNLCK
) {
216 fl_type
= fl
->fl_type
;
217 fl
->fl_type
= F_UNLCK
;
218 res
= posix_lock_file_wait(filp
, fl
);
219 fl
->fl_type
= fl_type
;
225 static int v9fs_file_getlock(struct file
*filp
, struct file_lock
*fl
)
227 struct p9_getlock glock
;
231 fid
= filp
->private_data
;
234 posix_test_lock(filp
, fl
);
236 * if we have a conflicting lock locally, no need to validate
239 if (fl
->fl_type
!= F_UNLCK
)
242 /* convert posix lock to p9 tgetlock args */
243 memset(&glock
, 0, sizeof(glock
));
244 glock
.type
= fl
->fl_type
;
245 glock
.start
= fl
->fl_start
;
246 if (fl
->fl_end
== OFFSET_MAX
)
249 glock
.length
= fl
->fl_end
- fl
->fl_start
+ 1;
250 glock
.proc_id
= fl
->fl_pid
;
251 glock
.client_id
= utsname()->nodename
;
253 res
= p9_client_getlock_dotl(fid
, &glock
);
256 if (glock
.type
!= F_UNLCK
) {
257 fl
->fl_type
= glock
.type
;
258 fl
->fl_start
= glock
.start
;
259 if (glock
.length
== 0)
260 fl
->fl_end
= OFFSET_MAX
;
262 fl
->fl_end
= glock
.start
+ glock
.length
- 1;
263 fl
->fl_pid
= glock
.proc_id
;
265 fl
->fl_type
= F_UNLCK
;
271 * v9fs_file_lock_dotl - lock a file (or directory)
272 * @filp: file to be locked
274 * @fl: file lock structure
278 static int v9fs_file_lock_dotl(struct file
*filp
, int cmd
, struct file_lock
*fl
)
280 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
283 P9_DPRINTK(P9_DEBUG_VFS
, "filp: %p cmd:%d lock: %p name: %s\n", filp
,
284 cmd
, fl
, filp
->f_path
.dentry
->d_name
.name
);
286 /* No mandatory locks */
287 if (__mandatory_lock(inode
) && fl
->fl_type
!= F_UNLCK
)
290 if ((IS_SETLK(cmd
) || IS_SETLKW(cmd
)) && fl
->fl_type
!= F_UNLCK
) {
291 filemap_write_and_wait(inode
->i_mapping
);
292 invalidate_mapping_pages(&inode
->i_data
, 0, -1);
295 if (IS_SETLK(cmd
) || IS_SETLKW(cmd
))
296 ret
= v9fs_file_do_lock(filp
, cmd
, fl
);
297 else if (IS_GETLK(cmd
))
298 ret
= v9fs_file_getlock(filp
, fl
);
306 * v9fs_file_flock_dotl - lock a file
307 * @filp: file to be locked
309 * @fl: file lock structure
313 static int v9fs_file_flock_dotl(struct file
*filp
, int cmd
,
314 struct file_lock
*fl
)
316 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
319 P9_DPRINTK(P9_DEBUG_VFS
, "filp: %p cmd:%d lock: %p name: %s\n", filp
,
320 cmd
, fl
, filp
->f_path
.dentry
->d_name
.name
);
322 /* No mandatory locks */
323 if (__mandatory_lock(inode
) && fl
->fl_type
!= F_UNLCK
)
326 if (!(fl
->fl_flags
& FL_FLOCK
))
329 if ((IS_SETLK(cmd
) || IS_SETLKW(cmd
)) && fl
->fl_type
!= F_UNLCK
) {
330 filemap_write_and_wait(inode
->i_mapping
);
331 invalidate_mapping_pages(&inode
->i_data
, 0, -1);
333 /* Convert flock to posix lock */
334 fl
->fl_owner
= (fl_owner_t
)filp
;
336 fl
->fl_end
= OFFSET_MAX
;
337 fl
->fl_flags
|= FL_POSIX
;
338 fl
->fl_flags
^= FL_FLOCK
;
340 if (IS_SETLK(cmd
) | IS_SETLKW(cmd
))
341 ret
= v9fs_file_do_lock(filp
, cmd
, fl
);
349 * v9fs_fid_readn - read from a fid
351 * @data: data buffer to read data into
352 * @udata: user data buffer to read data into
353 * @count: size of buffer
354 * @offset: offset at which to read data
358 v9fs_fid_readn(struct p9_fid
*fid
, char *data
, char __user
*udata
, u32 count
,
363 P9_DPRINTK(P9_DEBUG_VFS
, "fid %d offset %llu count %d\n", fid
->fid
,
364 (long long unsigned) offset
, count
);
367 size
= fid
->iounit
? fid
->iounit
: fid
->clnt
->msize
- P9_IOHDRSZ
;
369 n
= p9_client_read(fid
, data
, udata
, offset
, count
);
381 } while (count
> 0 && n
== size
);
390 * v9fs_file_readn - read from a file
391 * @filp: file pointer to read
392 * @data: data buffer to read data into
393 * @udata: user data buffer to read data into
394 * @count: size of buffer
395 * @offset: offset at which to read data
399 v9fs_file_readn(struct file
*filp
, char *data
, char __user
*udata
, u32 count
,
402 return v9fs_fid_readn(filp
->private_data
, data
, udata
, count
, offset
);
406 * v9fs_file_read - read from a file
407 * @filp: file pointer to read
408 * @udata: user data buffer to read data into
409 * @count: size of buffer
410 * @offset: offset at which to read data
415 v9fs_file_read(struct file
*filp
, char __user
*udata
, size_t count
,
422 P9_DPRINTK(P9_DEBUG_VFS
, "count %zu offset %lld\n", count
, *offset
);
423 fid
= filp
->private_data
;
425 size
= fid
->iounit
? fid
->iounit
: fid
->clnt
->msize
- P9_IOHDRSZ
;
427 ret
= v9fs_file_readn(filp
, NULL
, udata
, count
, *offset
);
429 ret
= p9_client_read(fid
, NULL
, udata
, *offset
, count
);
438 v9fs_file_write_internal(struct inode
*inode
, struct p9_fid
*fid
,
439 const char __user
*data
, size_t count
,
440 loff_t
*offset
, int invalidate
)
445 struct p9_client
*clnt
;
446 loff_t origin
= *offset
;
447 unsigned long pg_start
, pg_end
;
449 P9_DPRINTK(P9_DEBUG_VFS
, "data %p count %d offset %x\n", data
,
450 (int)count
, (int)*offset
);
454 n
= p9_client_write(fid
, NULL
, data
+total
, origin
+total
, count
);
461 if (invalidate
&& (total
> 0)) {
462 pg_start
= origin
>> PAGE_CACHE_SHIFT
;
463 pg_end
= (origin
+ total
- 1) >> PAGE_CACHE_SHIFT
;
464 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
)
465 invalidate_inode_pages2_range(inode
->i_mapping
,
468 i_size
= i_size_read(inode
);
469 if (*offset
> i_size
) {
470 inode_add_bytes(inode
, *offset
- i_size
);
471 i_size_write(inode
, *offset
);
481 * v9fs_file_write - write to a file
482 * @filp: file pointer to write
483 * @data: data buffer to write data from
484 * @count: size of buffer
485 * @offset: offset at which to write data
489 v9fs_file_write(struct file
*filp
, const char __user
* data
,
490 size_t count
, loff_t
*offset
)
493 loff_t origin
= *offset
;
496 retval
= generic_write_checks(filp
, &origin
, &count
, 0);
501 if ((ssize_t
) count
< 0)
507 return v9fs_file_write_internal(filp
->f_path
.dentry
->d_inode
,
509 data
, count
, offset
, 1);
515 static int v9fs_file_fsync(struct file
*filp
, int datasync
)
518 struct p9_wstat wstat
;
521 P9_DPRINTK(P9_DEBUG_VFS
, "filp %p datasync %x\n", filp
, datasync
);
523 fid
= filp
->private_data
;
524 v9fs_blank_wstat(&wstat
);
526 retval
= p9_client_wstat(fid
, &wstat
);
530 int v9fs_file_fsync_dotl(struct file
*filp
, int datasync
)
535 P9_DPRINTK(P9_DEBUG_VFS
, "v9fs_file_fsync_dotl: filp %p datasync %x\n",
538 fid
= filp
->private_data
;
540 retval
= p9_client_fsync(fid
, datasync
);
545 v9fs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
549 retval
= generic_file_mmap(file
, vma
);
551 vma
->vm_ops
= &v9fs_file_vm_ops
;
557 v9fs_vm_page_mkwrite(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
559 struct v9fs_inode
*v9inode
;
560 struct page
*page
= vmf
->page
;
561 struct file
*filp
= vma
->vm_file
;
562 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
565 P9_DPRINTK(P9_DEBUG_VFS
, "page %p fid %lx\n",
566 page
, (unsigned long)filp
->private_data
);
568 v9inode
= V9FS_I(inode
);
569 /* make sure the cache has finished storing the page */
570 v9fs_fscache_wait_on_page_write(inode
, page
);
571 BUG_ON(!v9inode
->writeback_fid
);
573 if (page
->mapping
!= inode
->i_mapping
)
576 return VM_FAULT_LOCKED
;
579 return VM_FAULT_NOPAGE
;
583 v9fs_direct_read(struct file
*filp
, char __user
*udata
, size_t count
,
588 struct address_space
*mapping
;
591 mapping
= filp
->f_mapping
;
592 inode
= mapping
->host
;
595 size
= i_size_read(inode
);
597 filemap_write_and_wait_range(mapping
, offset
,
600 return v9fs_file_read(filp
, udata
, count
, offsetp
);
604 * v9fs_cached_file_read - read from a file
605 * @filp: file pointer to read
606 * @udata: user data buffer to read data into
607 * @count: size of buffer
608 * @offset: offset at which to read data
612 v9fs_cached_file_read(struct file
*filp
, char __user
*data
, size_t count
,
615 if (filp
->f_flags
& O_DIRECT
)
616 return v9fs_direct_read(filp
, data
, count
, offset
);
617 return do_sync_read(filp
, data
, count
, offset
);
621 v9fs_direct_write(struct file
*filp
, const char __user
* data
,
622 size_t count
, loff_t
*offsetp
)
627 struct address_space
*mapping
;
630 mapping
= filp
->f_mapping
;
631 inode
= mapping
->host
;
635 mutex_lock(&inode
->i_mutex
);
636 retval
= filemap_write_and_wait_range(mapping
, offset
,
641 * After a write we want buffered reads to be sure to go to disk to get
642 * the new data. We invalidate clean cached page from the region we're
643 * about to write. We do this *before* the write so that if we fail
644 * here we fall back to buffered write
646 if (mapping
->nrpages
) {
647 pgoff_t pg_start
= offset
>> PAGE_CACHE_SHIFT
;
648 pgoff_t pg_end
= (offset
+ count
- 1) >> PAGE_CACHE_SHIFT
;
650 retval
= invalidate_inode_pages2_range(mapping
,
653 * If a page can not be invalidated, fall back
657 if (retval
== -EBUSY
)
662 retval
= v9fs_file_write(filp
, data
, count
, offsetp
);
664 mutex_unlock(&inode
->i_mutex
);
668 mutex_unlock(&inode
->i_mutex
);
669 return do_sync_write(filp
, data
, count
, offsetp
);
673 * v9fs_cached_file_write - write to a file
674 * @filp: file pointer to write
675 * @data: data buffer to write data from
676 * @count: size of buffer
677 * @offset: offset at which to write data
681 v9fs_cached_file_write(struct file
*filp
, const char __user
* data
,
682 size_t count
, loff_t
*offset
)
685 if (filp
->f_flags
& O_DIRECT
)
686 return v9fs_direct_write(filp
, data
, count
, offset
);
687 return do_sync_write(filp
, data
, count
, offset
);
690 static const struct vm_operations_struct v9fs_file_vm_ops
= {
691 .fault
= filemap_fault
,
692 .page_mkwrite
= v9fs_vm_page_mkwrite
,
696 const struct file_operations v9fs_cached_file_operations
= {
697 .llseek
= generic_file_llseek
,
698 .read
= v9fs_cached_file_read
,
699 .write
= v9fs_cached_file_write
,
700 .aio_read
= generic_file_aio_read
,
701 .aio_write
= generic_file_aio_write
,
702 .open
= v9fs_file_open
,
703 .release
= v9fs_dir_release
,
704 .lock
= v9fs_file_lock
,
705 .mmap
= v9fs_file_mmap
,
706 .fsync
= v9fs_file_fsync
,
709 const struct file_operations v9fs_cached_file_operations_dotl
= {
710 .llseek
= generic_file_llseek
,
711 .read
= v9fs_cached_file_read
,
712 .write
= v9fs_cached_file_write
,
713 .aio_read
= generic_file_aio_read
,
714 .aio_write
= generic_file_aio_write
,
715 .open
= v9fs_file_open
,
716 .release
= v9fs_dir_release
,
717 .lock
= v9fs_file_lock_dotl
,
718 .flock
= v9fs_file_flock_dotl
,
719 .mmap
= v9fs_file_mmap
,
720 .fsync
= v9fs_file_fsync_dotl
,
723 const struct file_operations v9fs_file_operations
= {
724 .llseek
= generic_file_llseek
,
725 .read
= v9fs_file_read
,
726 .write
= v9fs_file_write
,
727 .open
= v9fs_file_open
,
728 .release
= v9fs_dir_release
,
729 .lock
= v9fs_file_lock
,
730 .mmap
= generic_file_readonly_mmap
,
731 .fsync
= v9fs_file_fsync
,
734 const struct file_operations v9fs_file_operations_dotl
= {
735 .llseek
= generic_file_llseek
,
736 .read
= v9fs_file_read
,
737 .write
= v9fs_file_write
,
738 .open
= v9fs_file_open
,
739 .release
= v9fs_dir_release
,
740 .lock
= v9fs_file_lock_dotl
,
741 .flock
= v9fs_file_flock_dotl
,
742 .mmap
= generic_file_readonly_mmap
,
743 .fsync
= v9fs_file_fsync_dotl
,