xref: /openbmc/linux/fs/9p/vfs_file.c (revision 22246614)
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 <asm/uaccess.h>
36 #include <linux/idr.h>
37 #include <net/9p/9p.h>
38 #include <net/9p/client.h>
39 
40 #include "v9fs.h"
41 #include "v9fs_vfs.h"
42 #include "fid.h"
43 
44 static const struct file_operations v9fs_cached_file_operations;
45 
46 /**
47  * v9fs_file_open - open a file (or directory)
48  * @inode: inode to be opened
49  * @file: file being opened
50  *
51  */
52 
53 int v9fs_file_open(struct inode *inode, struct file *file)
54 {
55 	int err;
56 	struct v9fs_session_info *v9ses;
57 	struct p9_fid *fid;
58 	int omode;
59 
60 	P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p \n", inode, file);
61 	v9ses = v9fs_inode2v9ses(inode);
62 	omode = v9fs_uflags2omode(file->f_flags);
63 	fid = file->private_data;
64 	if (!fid) {
65 		fid = v9fs_fid_clone(file->f_path.dentry);
66 		if (IS_ERR(fid))
67 			return PTR_ERR(fid);
68 
69 		err = p9_client_open(fid, omode);
70 		if (err < 0) {
71 			p9_client_clunk(fid);
72 			return err;
73 		}
74 		if (omode & P9_OTRUNC) {
75 			inode->i_size = 0;
76 			inode->i_blocks = 0;
77 		}
78 	}
79 
80 	file->private_data = fid;
81 	if ((fid->qid.version) && (v9ses->cache)) {
82 		P9_DPRINTK(P9_DEBUG_VFS, "cached");
83 		/* enable cached file options */
84 		if(file->f_op == &v9fs_file_operations)
85 			file->f_op = &v9fs_cached_file_operations;
86 	}
87 
88 	return 0;
89 }
90 
91 /**
92  * v9fs_file_lock - lock a file (or directory)
93  * @inode: inode to be opened
94  * @file: file being opened
95  *
96  * XXX - this looks like a local only lock, we should extend into 9P
97  *       by using open exclusive
98  */
99 
100 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
101 {
102 	int res = 0;
103 	struct inode *inode = filp->f_path.dentry->d_inode;
104 
105 	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
106 
107 	/* No mandatory locks */
108 	if (__mandatory_lock(inode))
109 		return -ENOLCK;
110 
111 	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
112 		filemap_write_and_wait(inode->i_mapping);
113 		invalidate_mapping_pages(&inode->i_data, 0, -1);
114 	}
115 
116 	return res;
117 }
118 
119 /**
120  * v9fs_file_read - read from a file
121  * @filep: file pointer to read
122  * @data: data buffer to read data into
123  * @count: size of buffer
124  * @offset: offset at which to read data
125  *
126  */
127 static ssize_t
128 v9fs_file_read(struct file *filp, char __user * data, size_t count,
129 	       loff_t * offset)
130 {
131 	int ret;
132 	struct p9_fid *fid;
133 
134 	P9_DPRINTK(P9_DEBUG_VFS, "\n");
135 	fid = filp->private_data;
136 	ret = p9_client_uread(fid, data, *offset, count);
137 	if (ret > 0)
138 		*offset += ret;
139 
140 	return ret;
141 }
142 
143 /**
144  * v9fs_file_write - write to a file
145  * @filep: file pointer to write
146  * @data: data buffer to write data from
147  * @count: size of buffer
148  * @offset: offset at which to write data
149  *
150  */
151 
152 static ssize_t
153 v9fs_file_write(struct file *filp, const char __user * data,
154 		size_t count, loff_t * offset)
155 {
156 	int ret;
157 	struct p9_fid *fid;
158 	struct inode *inode = filp->f_path.dentry->d_inode;
159 
160 	P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
161 		(int)count, (int)*offset);
162 
163 	fid = filp->private_data;
164 	ret = p9_client_uwrite(fid, data, *offset, count);
165 	if (ret > 0) {
166 		invalidate_inode_pages2_range(inode->i_mapping, *offset,
167 								*offset+ret);
168 		*offset += ret;
169 	}
170 
171 	if (*offset > inode->i_size) {
172 		inode->i_size = *offset;
173 		inode->i_blocks = (inode->i_size + 512 - 1) >> 9;
174 	}
175 
176 	return ret;
177 }
178 
179 static const struct file_operations v9fs_cached_file_operations = {
180 	.llseek = generic_file_llseek,
181 	.read = do_sync_read,
182 	.aio_read = generic_file_aio_read,
183 	.write = v9fs_file_write,
184 	.open = v9fs_file_open,
185 	.release = v9fs_dir_release,
186 	.lock = v9fs_file_lock,
187 	.mmap = generic_file_readonly_mmap,
188 };
189 
190 const struct file_operations v9fs_file_operations = {
191 	.llseek = generic_file_llseek,
192 	.read = v9fs_file_read,
193 	.write = v9fs_file_write,
194 	.open = v9fs_file_open,
195 	.release = v9fs_dir_release,
196 	.lock = v9fs_file_lock,
197 	.mmap = generic_file_readonly_mmap,
198 };
199