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 <asm/uaccess.h>
37 #include <linux/idr.h>
38 #include <net/9p/9p.h>
39 #include <net/9p/client.h>
46 static const struct file_operations v9fs_cached_file_operations
;
49 * v9fs_file_open - open a file (or directory)
50 * @inode: inode to be opened
51 * @file: file being opened
55 int v9fs_file_open(struct inode
*inode
, struct file
*file
)
58 struct v9fs_session_info
*v9ses
;
62 P9_DPRINTK(P9_DEBUG_VFS
, "inode: %p file: %p\n", inode
, file
);
63 v9ses
= v9fs_inode2v9ses(inode
);
64 if (v9fs_proto_dotl(v9ses
))
65 omode
= file
->f_flags
;
67 omode
= v9fs_uflags2omode(file
->f_flags
,
68 v9fs_proto_dotu(v9ses
));
69 fid
= file
->private_data
;
71 fid
= v9fs_fid_clone(file
->f_path
.dentry
);
75 err
= p9_client_open(fid
, omode
);
80 if (file
->f_flags
& O_TRUNC
) {
81 i_size_write(inode
, 0);
84 if ((file
->f_flags
& O_APPEND
) &&
85 (!v9fs_proto_dotu(v9ses
) && !v9fs_proto_dotl(v9ses
)))
86 generic_file_llseek(file
, 0, SEEK_END
);
89 file
->private_data
= fid
;
90 if ((fid
->qid
.version
) && (v9ses
->cache
)) {
91 P9_DPRINTK(P9_DEBUG_VFS
, "cached");
92 /* enable cached file options */
93 if(file
->f_op
== &v9fs_file_operations
)
94 file
->f_op
= &v9fs_cached_file_operations
;
96 #ifdef CONFIG_9P_FSCACHE
97 v9fs_cache_inode_set_cookie(inode
, file
);
105 * v9fs_file_lock - lock a file (or directory)
106 * @filp: file to be locked
108 * @fl: file lock structure
110 * Bugs: this looks like a local only lock, we should extend into 9P
111 * by using open exclusive
114 static int v9fs_file_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
117 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
119 P9_DPRINTK(P9_DEBUG_VFS
, "filp: %p lock: %p\n", filp
, fl
);
121 /* No mandatory locks */
122 if (__mandatory_lock(inode
) && fl
->fl_type
!= F_UNLCK
)
125 if ((IS_SETLK(cmd
) || IS_SETLKW(cmd
)) && fl
->fl_type
!= F_UNLCK
) {
126 filemap_write_and_wait(inode
->i_mapping
);
127 invalidate_mapping_pages(&inode
->i_data
, 0, -1);
134 * v9fs_file_readn - read from a file
135 * @filp: file pointer to read
136 * @data: data buffer to read data into
137 * @udata: user data buffer to read data into
138 * @count: size of buffer
139 * @offset: offset at which to read data
144 v9fs_file_readn(struct file
*filp
, char *data
, char __user
*udata
, u32 count
,
148 struct p9_fid
*fid
= filp
->private_data
;
150 P9_DPRINTK(P9_DEBUG_VFS
, "fid %d offset %llu count %d\n", fid
->fid
,
151 (long long unsigned) offset
, count
);
155 size
= fid
->iounit
? fid
->iounit
: fid
->clnt
->msize
- P9_IOHDRSZ
;
157 n
= p9_client_read(fid
, data
, udata
, offset
, count
);
169 } while (count
> 0 && n
== size
);
178 * v9fs_file_read - read from a file
179 * @filp: file pointer to read
180 * @udata: user data buffer to read data into
181 * @count: size of buffer
182 * @offset: offset at which to read data
187 v9fs_file_read(struct file
*filp
, char __user
*udata
, size_t count
,
194 P9_DPRINTK(P9_DEBUG_VFS
, "count %zu offset %lld\n", count
, *offset
);
195 fid
= filp
->private_data
;
197 size
= fid
->iounit
? fid
->iounit
: fid
->clnt
->msize
- P9_IOHDRSZ
;
199 ret
= v9fs_file_readn(filp
, NULL
, udata
, count
, *offset
);
201 ret
= p9_client_read(fid
, NULL
, udata
, *offset
, count
);
210 * v9fs_file_write - write to a file
211 * @filp: file pointer to write
212 * @data: data buffer to write data from
213 * @count: size of buffer
214 * @offset: offset at which to write data
219 v9fs_file_write(struct file
*filp
, const char __user
* data
,
220 size_t count
, loff_t
* offset
)
222 int n
, rsize
, total
= 0;
224 struct p9_client
*clnt
;
225 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
226 loff_t origin
= *offset
;
227 unsigned long pg_start
, pg_end
;
229 P9_DPRINTK(P9_DEBUG_VFS
, "data %p count %d offset %x\n", data
,
230 (int)count
, (int)*offset
);
232 fid
= filp
->private_data
;
235 rsize
= fid
->iounit
? fid
->iounit
: clnt
->msize
- P9_IOHDRSZ
;
241 n
= p9_client_write(fid
, NULL
, data
+total
, origin
+total
,
250 pg_start
= origin
>> PAGE_CACHE_SHIFT
;
251 pg_end
= (origin
+ total
- 1) >> PAGE_CACHE_SHIFT
;
252 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
)
253 invalidate_inode_pages2_range(inode
->i_mapping
,
256 i_size_write(inode
, i_size_read(inode
) + total
);
257 inode
->i_blocks
= (i_size_read(inode
) + 512 - 1) >> 9;
266 static int v9fs_file_fsync(struct file
*filp
, int datasync
)
269 struct p9_wstat wstat
;
272 P9_DPRINTK(P9_DEBUG_VFS
, "filp %p datasync %x\n", filp
, datasync
);
274 fid
= filp
->private_data
;
275 v9fs_blank_wstat(&wstat
);
277 retval
= p9_client_wstat(fid
, &wstat
);
281 static const struct file_operations v9fs_cached_file_operations
= {
282 .llseek
= generic_file_llseek
,
283 .read
= do_sync_read
,
284 .aio_read
= generic_file_aio_read
,
285 .write
= v9fs_file_write
,
286 .open
= v9fs_file_open
,
287 .release
= v9fs_dir_release
,
288 .lock
= v9fs_file_lock
,
289 .mmap
= generic_file_readonly_mmap
,
290 .fsync
= v9fs_file_fsync
,
293 const struct file_operations v9fs_file_operations
= {
294 .llseek
= generic_file_llseek
,
295 .read
= v9fs_file_read
,
296 .write
= v9fs_file_write
,
297 .open
= v9fs_file_open
,
298 .release
= v9fs_dir_release
,
299 .lock
= v9fs_file_lock
,
300 .mmap
= generic_file_readonly_mmap
,
301 .fsync
= v9fs_file_fsync
,
304 const struct file_operations v9fs_file_operations_dotl
= {
305 .llseek
= generic_file_llseek
,
306 .read
= v9fs_file_read
,
307 .write
= v9fs_file_write
,
308 .open
= v9fs_file_open
,
309 .release
= v9fs_dir_release
,
310 .lock
= v9fs_file_lock
,
311 .mmap
= generic_file_readonly_mmap
,
312 .fsync
= v9fs_file_fsync
,