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 as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to:
21 * Free Software Foundation
22 * 51 Franklin Street, Fifth Floor
23 * Boston, MA 02111-1301 USA
27 #include <linux/module.h>
28 #include <linux/errno.h>
30 #include <linux/file.h>
31 #include <linux/stat.h>
32 #include <linux/string.h>
33 #include <linux/smp_lock.h>
34 #include <linux/inet.h>
35 #include <linux/version.h>
36 #include <linux/list.h>
37 #include <asm/uaccess.h>
38 #include <linux/idr.h>
47 * v9fs_file_open - open a file (or directory)
48 * @inode: inode to be opened
49 * @file: file being opened
53 int v9fs_file_open(struct inode
*inode
, struct file
*file
)
55 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(inode
);
56 struct v9fs_fid
*v9fid
, *fid
;
57 struct v9fs_fcall
*fcall
= NULL
;
59 unsigned int iounit
= 0;
63 dprintk(DEBUG_VFS
, "inode: %p file: %p \n", inode
, file
);
65 v9fid
= v9fs_fid_get_created(file
->f_dentry
);
67 v9fid
= v9fs_fid_lookup(file
->f_dentry
);
70 dprintk(DEBUG_ERROR
, "Couldn't resolve fid from dentry\n");
74 if (!v9fid
->fidcreate
) {
75 fid
= kmalloc(sizeof(struct v9fs_fid
), GFP_KERNEL
);
77 dprintk(DEBUG_ERROR
, "Out of Memory\n");
87 newfid
= v9fs_get_idpool(&v9ses
->fidpool
);
89 eprintk(KERN_WARNING
, "newfid fails!\n");
94 v9fs_t_walk(v9ses
, v9fid
->fid
, newfid
, NULL
, NULL
);
97 v9fs_put_idpool(newfid
, &v9ses
->fidpool
);
98 dprintk(DEBUG_ERROR
, "rewalk didn't work\n");
104 /* TODO: do special things for O_EXCL, O_NOFOLLOW, O_SYNC */
105 /* translate open mode appropriately */
106 open_mode
= file
->f_flags
& 0x3;
108 if (file
->f_flags
& O_EXCL
)
109 open_mode
|= V9FS_OEXCL
;
111 if (v9ses
->extended
) {
112 if (file
->f_flags
& O_TRUNC
)
113 open_mode
|= V9FS_OTRUNC
;
115 if (file
->f_flags
& O_APPEND
)
116 open_mode
|= V9FS_OAPPEND
;
119 result
= v9fs_t_open(v9ses
, newfid
, open_mode
, &fcall
);
122 "open failed, open_mode 0x%x: %s\n", open_mode
,
128 iounit
= fcall
->params
.ropen
.iounit
;
133 iounit
= v9fid
->iounit
;
134 v9fid
->fidcreate
= 0;
137 file
->private_data
= v9fid
;
140 v9fid
->rdir_fcall
= NULL
;
143 v9fid
->iounit
= iounit
;
149 * v9fs_file_lock - lock a file (or directory)
150 * @inode: inode to be opened
151 * @file: file being opened
153 * XXX - this looks like a local only lock, we should extend into 9P
154 * by using open exclusive
157 static int v9fs_file_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
160 struct inode
*inode
= filp
->f_dentry
->d_inode
;
162 dprintk(DEBUG_VFS
, "filp: %p lock: %p\n", filp
, fl
);
164 /* No mandatory locks */
165 if ((inode
->i_mode
& (S_ISGID
| S_IXGRP
)) == S_ISGID
)
168 if ((IS_SETLK(cmd
) || IS_SETLKW(cmd
)) && fl
->fl_type
!= F_UNLCK
) {
169 filemap_fdatawrite(inode
->i_mapping
);
170 filemap_fdatawait(inode
->i_mapping
);
171 invalidate_inode_pages(&inode
->i_data
);
178 * v9fs_file_read - read from a file
179 * @filep: file pointer to read
180 * @data: data buffer to read data into
181 * @count: size of buffer
182 * @offset: offset at which to read data
186 v9fs_file_read(struct file
*filp
, char __user
* data
, size_t count
,
189 struct inode
*inode
= filp
->f_dentry
->d_inode
;
190 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(inode
);
191 struct v9fs_fid
*v9f
= filp
->private_data
;
192 struct v9fs_fcall
*fcall
= NULL
;
199 dprintk(DEBUG_VFS
, "\n");
201 rsize
= v9ses
->maxdata
- V9FS_IOHDRSZ
;
202 if (v9f
->iounit
!= 0 && rsize
> v9f
->iounit
)
209 result
= v9fs_t_read(v9ses
, fid
, *offset
, rsize
, &fcall
);
212 printk(KERN_ERR
"9P2000: v9fs_t_read returned %d\n",
220 n
= copy_to_user(data
, fcall
->params
.rread
.data
, result
);
222 dprintk(DEBUG_ERROR
, "Problem copying to user %d\n", n
);
241 * v9fs_file_write - write to a file
242 * @filep: file pointer to write
243 * @data: data buffer to write data from
244 * @count: size of buffer
245 * @offset: offset at which to write data
250 v9fs_file_write(struct file
*filp
, const char __user
* data
,
251 size_t count
, loff_t
* offset
)
253 struct inode
*inode
= filp
->f_dentry
->d_inode
;
254 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(inode
);
255 struct v9fs_fid
*v9fid
= filp
->private_data
;
256 struct v9fs_fcall
*fcall
;
257 int fid
= v9fid
->fid
;
263 dprintk(DEBUG_VFS
, "data %p count %d offset %x\n", data
, (int)count
,
265 rsize
= v9ses
->maxdata
- V9FS_IOHDRSZ
;
266 if (v9fid
->iounit
!= 0 && rsize
> v9fid
->iounit
)
267 rsize
= v9fid
->iounit
;
269 buf
= kmalloc(v9ses
->maxdata
- V9FS_IOHDRSZ
, GFP_KERNEL
);
277 result
= copy_from_user(buf
, data
, rsize
);
279 dprintk(DEBUG_ERROR
, "Problem copying from user\n");
284 dump_data(buf
, rsize
);
285 result
= v9fs_t_write(v9ses
, fid
, *offset
, rsize
, buf
, &fcall
);
287 eprintk(KERN_ERR
, "error while writing: %s(%d)\n",
288 FCALL_ERROR(fcall
), result
);
298 if (result
!= rsize
) {
300 "short write: v9fs_t_write returned %d\n",
314 struct file_operations v9fs_file_operations
= {
315 .llseek
= generic_file_llseek
,
316 .read
= v9fs_file_read
,
317 .write
= v9fs_file_write
,
318 .open
= v9fs_file_open
,
319 .release
= v9fs_dir_release
,
320 .lock
= v9fs_file_lock
,