blob: 67ff2c6a8f6309bc09746a65d29b8d55f0a90bb5 [file] [log] [blame]
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001/*
2 FUSE: Filesystem in Userspace
Miklos Szeredi56cf34f2006-04-11 21:16:51 +02003 Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
Miklos Szeredib6aeade2005-09-09 13:10:30 -07004
5 This program can be distributed under the terms of the GNU GPL.
6 See the file COPYING.
7*/
8
9#include "fuse_i.h"
10
11#include <linux/pagemap.h>
12#include <linux/slab.h>
13#include <linux/kernel.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040014#include <linux/sched.h>
Miklos Szeredib6aeade2005-09-09 13:10:30 -070015
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080016static const struct file_operations fuse_direct_io_file_operations;
Miklos Szeredi45323fb2005-09-09 13:10:37 -070017
Miklos Szeredifd72faa2005-11-07 00:59:51 -080018static int fuse_send_open(struct inode *inode, struct file *file, int isdir,
19 struct fuse_open_out *outargp)
Miklos Szeredib6aeade2005-09-09 13:10:30 -070020{
21 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredib6aeade2005-09-09 13:10:30 -070022 struct fuse_open_in inarg;
Miklos Szeredifd72faa2005-11-07 00:59:51 -080023 struct fuse_req *req;
24 int err;
25
Miklos Szeredice1d5a42006-04-10 22:54:58 -070026 req = fuse_get_req(fc);
27 if (IS_ERR(req))
28 return PTR_ERR(req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -080029
30 memset(&inarg, 0, sizeof(inarg));
Miklos Szeredi6ff958e2007-10-18 03:07:02 -070031 inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY);
32 if (!fc->atomic_o_trunc)
33 inarg.flags &= ~O_TRUNC;
Miklos Szeredifd72faa2005-11-07 00:59:51 -080034 req->in.h.opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
35 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredifd72faa2005-11-07 00:59:51 -080036 req->in.numargs = 1;
37 req->in.args[0].size = sizeof(inarg);
38 req->in.args[0].value = &inarg;
39 req->out.numargs = 1;
40 req->out.args[0].size = sizeof(*outargp);
41 req->out.args[0].value = outargp;
42 request_send(fc, req);
43 err = req->out.h.error;
44 fuse_put_request(fc, req);
45
46 return err;
47}
48
49struct fuse_file *fuse_file_alloc(void)
50{
51 struct fuse_file *ff;
52 ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL);
53 if (ff) {
Miklos Szeredi33649c92006-06-25 05:48:52 -070054 ff->reserved_req = fuse_request_alloc();
55 if (!ff->reserved_req) {
Miklos Szeredifd72faa2005-11-07 00:59:51 -080056 kfree(ff);
57 ff = NULL;
Adrian Bunk87449692007-11-14 17:00:02 -080058 } else {
59 INIT_LIST_HEAD(&ff->write_entry);
60 atomic_set(&ff->count, 0);
Miklos Szeredifd72faa2005-11-07 00:59:51 -080061 }
62 }
63 return ff;
64}
65
66void fuse_file_free(struct fuse_file *ff)
67{
Miklos Szeredi33649c92006-06-25 05:48:52 -070068 fuse_request_free(ff->reserved_req);
Miklos Szeredifd72faa2005-11-07 00:59:51 -080069 kfree(ff);
70}
71
Miklos Szeredic756e0a2007-10-16 23:31:00 -070072static struct fuse_file *fuse_file_get(struct fuse_file *ff)
73{
74 atomic_inc(&ff->count);
75 return ff;
76}
77
Miklos Szeredi819c4b32007-10-16 23:31:04 -070078static void fuse_release_end(struct fuse_conn *fc, struct fuse_req *req)
79{
Miklos Szeredib57d4262008-02-06 01:38:39 -080080 dput(req->misc.release.dentry);
81 mntput(req->misc.release.vfsmount);
Miklos Szeredi819c4b32007-10-16 23:31:04 -070082 fuse_put_request(fc, req);
83}
84
Miklos Szeredic756e0a2007-10-16 23:31:00 -070085static void fuse_file_put(struct fuse_file *ff)
86{
87 if (atomic_dec_and_test(&ff->count)) {
88 struct fuse_req *req = ff->reserved_req;
Miklos Szeredib57d4262008-02-06 01:38:39 -080089 struct inode *inode = req->misc.release.dentry->d_inode;
90 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi819c4b32007-10-16 23:31:04 -070091 req->end = fuse_release_end;
Miklos Szeredic756e0a2007-10-16 23:31:00 -070092 request_send_background(fc, req);
93 kfree(ff);
94 }
95}
96
Miklos Szeredifd72faa2005-11-07 00:59:51 -080097void fuse_finish_open(struct inode *inode, struct file *file,
98 struct fuse_file *ff, struct fuse_open_out *outarg)
99{
100 if (outarg->open_flags & FOPEN_DIRECT_IO)
101 file->f_op = &fuse_direct_io_file_operations;
102 if (!(outarg->open_flags & FOPEN_KEEP_CACHE))
Miklos Szeredib1009972007-10-16 23:31:01 -0700103 invalidate_inode_pages2(inode->i_mapping);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800104 ff->fh = outarg->fh;
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700105 file->private_data = fuse_file_get(ff);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800106}
107
108int fuse_open_common(struct inode *inode, struct file *file, int isdir)
109{
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700110 struct fuse_open_out outarg;
111 struct fuse_file *ff;
112 int err;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700113
Miklos Szeredidd190d02005-09-30 11:59:02 -0700114 /* VFS checks this, but only _after_ ->open() */
115 if (file->f_flags & O_DIRECT)
116 return -EINVAL;
117
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700118 err = generic_file_open(inode, file);
119 if (err)
120 return err;
121
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800122 ff = fuse_file_alloc();
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700123 if (!ff)
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800124 return -ENOMEM;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700125
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800126 err = fuse_send_open(inode, file, isdir, &outarg);
127 if (err)
128 fuse_file_free(ff);
129 else {
130 if (isdir)
131 outarg.open_flags &= ~FOPEN_DIRECT_IO;
132 fuse_finish_open(inode, file, ff, &outarg);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700133 }
134
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700135 return err;
136}
137
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700138void fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags, int opcode)
Miklos Szeredi64c6d8e2006-01-16 22:14:42 -0800139{
Miklos Szeredi33649c92006-06-25 05:48:52 -0700140 struct fuse_req *req = ff->reserved_req;
Miklos Szeredib57d4262008-02-06 01:38:39 -0800141 struct fuse_release_in *inarg = &req->misc.release.in;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700142
143 inarg->fh = ff->fh;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800144 inarg->flags = flags;
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700145 req->in.h.opcode = opcode;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800146 req->in.h.nodeid = nodeid;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700147 req->in.numargs = 1;
148 req->in.args[0].size = sizeof(struct fuse_release_in);
149 req->in.args[0].value = inarg;
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800150}
151
152int fuse_release_common(struct inode *inode, struct file *file, int isdir)
153{
154 struct fuse_file *ff = file->private_data;
155 if (ff) {
Miklos Szeredi93a8c3c2007-10-18 03:07:03 -0700156 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredib57d4262008-02-06 01:38:39 -0800157 struct fuse_req *req = ff->reserved_req;
Miklos Szeredi93a8c3c2007-10-18 03:07:03 -0700158
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700159 fuse_release_fill(ff, get_node_id(inode), file->f_flags,
160 isdir ? FUSE_RELEASEDIR : FUSE_RELEASE);
Miklos Szeredi51eb01e2006-06-25 05:48:50 -0700161
162 /* Hold vfsmount and dentry until release is finished */
Miklos Szeredib57d4262008-02-06 01:38:39 -0800163 req->misc.release.vfsmount = mntget(file->f_path.mnt);
164 req->misc.release.dentry = dget(file->f_path.dentry);
Miklos Szeredi93a8c3c2007-10-18 03:07:03 -0700165
166 spin_lock(&fc->lock);
167 list_del(&ff->write_entry);
168 spin_unlock(&fc->lock);
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700169 /*
170 * Normally this will send the RELEASE request,
171 * however if some asynchronous READ or WRITE requests
172 * are outstanding, the sending will be delayed
173 */
174 fuse_file_put(ff);
Miklos Szeredifd72faa2005-11-07 00:59:51 -0800175 }
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700176
177 /* Return value is ignored by VFS */
178 return 0;
179}
180
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700181static int fuse_open(struct inode *inode, struct file *file)
182{
183 return fuse_open_common(inode, file, 0);
184}
185
186static int fuse_release(struct inode *inode, struct file *file)
187{
188 return fuse_release_common(inode, file, 0);
189}
190
Miklos Szeredi71421252006-06-25 05:48:52 -0700191/*
Miklos Szeredi9c8ef562006-06-25 05:48:55 -0700192 * Scramble the ID space with XTEA, so that the value of the files_struct
193 * pointer is not exposed to userspace.
Miklos Szeredi71421252006-06-25 05:48:52 -0700194 */
Miklos Szeredif3332112007-10-18 03:07:04 -0700195u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id)
Miklos Szeredi71421252006-06-25 05:48:52 -0700196{
Miklos Szeredi9c8ef562006-06-25 05:48:55 -0700197 u32 *k = fc->scramble_key;
198 u64 v = (unsigned long) id;
199 u32 v0 = v;
200 u32 v1 = v >> 32;
201 u32 sum = 0;
202 int i;
203
204 for (i = 0; i < 32; i++) {
205 v0 += ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
206 sum += 0x9E3779B9;
207 v1 += ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]);
208 }
209
210 return (u64) v0 + ((u64) v1 << 32);
Miklos Szeredi71421252006-06-25 05:48:52 -0700211}
212
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700213/*
214 * Check if page is under writeback
215 *
216 * This is currently done by walking the list of writepage requests
217 * for the inode, which can be pretty inefficient.
218 */
219static bool fuse_page_is_writeback(struct inode *inode, pgoff_t index)
220{
221 struct fuse_conn *fc = get_fuse_conn(inode);
222 struct fuse_inode *fi = get_fuse_inode(inode);
223 struct fuse_req *req;
224 bool found = false;
225
226 spin_lock(&fc->lock);
227 list_for_each_entry(req, &fi->writepages, writepages_entry) {
228 pgoff_t curr_index;
229
230 BUG_ON(req->inode != inode);
231 curr_index = req->misc.write.in.offset >> PAGE_CACHE_SHIFT;
232 if (curr_index == index) {
233 found = true;
234 break;
235 }
236 }
237 spin_unlock(&fc->lock);
238
239 return found;
240}
241
242/*
243 * Wait for page writeback to be completed.
244 *
245 * Since fuse doesn't rely on the VM writeback tracking, this has to
246 * use some other means.
247 */
248static int fuse_wait_on_page_writeback(struct inode *inode, pgoff_t index)
249{
250 struct fuse_inode *fi = get_fuse_inode(inode);
251
252 wait_event(fi->page_waitq, !fuse_page_is_writeback(inode, index));
253 return 0;
254}
255
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -0700256static int fuse_flush(struct file *file, fl_owner_t id)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700257{
Josef Sipek7706a9d2006-12-08 02:37:02 -0800258 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700259 struct fuse_conn *fc = get_fuse_conn(inode);
260 struct fuse_file *ff = file->private_data;
261 struct fuse_req *req;
262 struct fuse_flush_in inarg;
263 int err;
264
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800265 if (is_bad_inode(inode))
266 return -EIO;
267
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700268 if (fc->no_flush)
269 return 0;
270
Miklos Szeredi33649c92006-06-25 05:48:52 -0700271 req = fuse_get_req_nofail(fc, file);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700272 memset(&inarg, 0, sizeof(inarg));
273 inarg.fh = ff->fh;
Miklos Szeredi9c8ef562006-06-25 05:48:55 -0700274 inarg.lock_owner = fuse_lock_owner_id(fc, id);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700275 req->in.h.opcode = FUSE_FLUSH;
276 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700277 req->in.numargs = 1;
278 req->in.args[0].size = sizeof(inarg);
279 req->in.args[0].value = &inarg;
Miklos Szeredi71421252006-06-25 05:48:52 -0700280 req->force = 1;
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700281 request_send(fc, req);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700282 err = req->out.h.error;
283 fuse_put_request(fc, req);
284 if (err == -ENOSYS) {
285 fc->no_flush = 1;
286 err = 0;
287 }
288 return err;
289}
290
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700291/*
292 * Wait for all pending writepages on the inode to finish.
293 *
294 * This is currently done by blocking further writes with FUSE_NOWRITE
295 * and waiting for all sent writes to complete.
296 *
297 * This must be called under i_mutex, otherwise the FUSE_NOWRITE usage
298 * could conflict with truncation.
299 */
300static void fuse_sync_writes(struct inode *inode)
301{
302 fuse_set_nowrite(inode);
303 fuse_release_nowrite(inode);
304}
305
Miklos Szeredi82547982005-09-09 13:10:38 -0700306int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
307 int isdir)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700308{
309 struct inode *inode = de->d_inode;
310 struct fuse_conn *fc = get_fuse_conn(inode);
311 struct fuse_file *ff = file->private_data;
312 struct fuse_req *req;
313 struct fuse_fsync_in inarg;
314 int err;
315
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800316 if (is_bad_inode(inode))
317 return -EIO;
318
Miklos Szeredi82547982005-09-09 13:10:38 -0700319 if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir))
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700320 return 0;
321
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700322 /*
323 * Start writeback against all dirty pages of the inode, then
324 * wait for all outstanding writes, before sending the FSYNC
325 * request.
326 */
327 err = write_inode_now(inode, 0);
328 if (err)
329 return err;
330
331 fuse_sync_writes(inode);
332
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700333 req = fuse_get_req(fc);
334 if (IS_ERR(req))
335 return PTR_ERR(req);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700336
337 memset(&inarg, 0, sizeof(inarg));
338 inarg.fh = ff->fh;
339 inarg.fsync_flags = datasync ? 1 : 0;
Miklos Szeredi82547982005-09-09 13:10:38 -0700340 req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700341 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700342 req->in.numargs = 1;
343 req->in.args[0].size = sizeof(inarg);
344 req->in.args[0].value = &inarg;
345 request_send(fc, req);
346 err = req->out.h.error;
347 fuse_put_request(fc, req);
348 if (err == -ENOSYS) {
Miklos Szeredi82547982005-09-09 13:10:38 -0700349 if (isdir)
350 fc->no_fsyncdir = 1;
351 else
352 fc->no_fsync = 1;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700353 err = 0;
354 }
355 return err;
356}
357
Miklos Szeredi82547982005-09-09 13:10:38 -0700358static int fuse_fsync(struct file *file, struct dentry *de, int datasync)
359{
360 return fuse_fsync_common(file, de, datasync, 0);
361}
362
Miklos Szeredia6643092007-11-28 16:22:00 -0800363void fuse_read_fill(struct fuse_req *req, struct file *file,
Miklos Szeredi361b1eb52006-01-16 22:14:45 -0800364 struct inode *inode, loff_t pos, size_t count, int opcode)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700365{
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700366 struct fuse_read_in *inarg = &req->misc.read.in;
Miklos Szeredia6643092007-11-28 16:22:00 -0800367 struct fuse_file *ff = file->private_data;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700368
Miklos Szeredi361b1eb52006-01-16 22:14:45 -0800369 inarg->fh = ff->fh;
370 inarg->offset = pos;
371 inarg->size = count;
Miklos Szeredia6643092007-11-28 16:22:00 -0800372 inarg->flags = file->f_flags;
Miklos Szeredi361b1eb52006-01-16 22:14:45 -0800373 req->in.h.opcode = opcode;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700374 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700375 req->in.numargs = 1;
376 req->in.args[0].size = sizeof(struct fuse_read_in);
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800377 req->in.args[0].value = inarg;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700378 req->out.argpages = 1;
379 req->out.argvar = 1;
380 req->out.numargs = 1;
381 req->out.args[0].size = count;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700382}
383
Miklos Szeredi8bfc0162006-01-16 22:14:28 -0800384static size_t fuse_send_read(struct fuse_req *req, struct file *file,
Miklos Szeredif3332112007-10-18 03:07:04 -0700385 struct inode *inode, loff_t pos, size_t count,
386 fl_owner_t owner)
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700387{
Miklos Szeredi361b1eb52006-01-16 22:14:45 -0800388 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredif3332112007-10-18 03:07:04 -0700389
Miklos Szeredia6643092007-11-28 16:22:00 -0800390 fuse_read_fill(req, file, inode, pos, count, FUSE_READ);
Miklos Szeredif3332112007-10-18 03:07:04 -0700391 if (owner != NULL) {
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700392 struct fuse_read_in *inarg = &req->misc.read.in;
Miklos Szeredif3332112007-10-18 03:07:04 -0700393
394 inarg->read_flags |= FUSE_READ_LOCKOWNER;
395 inarg->lock_owner = fuse_lock_owner_id(fc, owner);
396 }
Miklos Szeredi361b1eb52006-01-16 22:14:45 -0800397 request_send(fc, req);
398 return req->out.args[0].size;
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700399}
400
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700401static void fuse_read_update_size(struct inode *inode, loff_t size,
402 u64 attr_ver)
403{
404 struct fuse_conn *fc = get_fuse_conn(inode);
405 struct fuse_inode *fi = get_fuse_inode(inode);
406
407 spin_lock(&fc->lock);
408 if (attr_ver == fi->attr_version && size < inode->i_size) {
409 fi->attr_version = ++fc->attr_version;
410 i_size_write(inode, size);
411 }
412 spin_unlock(&fc->lock);
413}
414
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700415static int fuse_readpage(struct file *file, struct page *page)
416{
417 struct inode *inode = page->mapping->host;
418 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800419 struct fuse_req *req;
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700420 size_t num_read;
421 loff_t pos = page_offset(page);
422 size_t count = PAGE_CACHE_SIZE;
423 u64 attr_ver;
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800424 int err;
425
426 err = -EIO;
427 if (is_bad_inode(inode))
428 goto out;
429
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700430 /*
431 * Page writeback can extend beyond the liftime of the
432 * page-cache page, so make sure we read a properly synced
433 * page.
434 */
435 fuse_wait_on_page_writeback(inode, page->index);
436
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700437 req = fuse_get_req(fc);
438 err = PTR_ERR(req);
439 if (IS_ERR(req))
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700440 goto out;
441
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700442 attr_ver = fuse_get_attr_version(fc);
443
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700444 req->out.page_zeroing = 1;
445 req->num_pages = 1;
446 req->pages[0] = page;
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700447 num_read = fuse_send_read(req, file, inode, pos, count, NULL);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700448 err = req->out.h.error;
449 fuse_put_request(fc, req);
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700450
451 if (!err) {
452 /*
453 * Short read means EOF. If file size is larger, truncate it
454 */
455 if (num_read < count)
456 fuse_read_update_size(inode, pos + num_read, attr_ver);
457
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700458 SetPageUptodate(page);
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700459 }
460
Miklos Szeredib36c31b2005-09-09 13:10:38 -0700461 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700462 out:
463 unlock_page(page);
464 return err;
465}
466
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800467static void fuse_readpages_end(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredidb50b962005-09-09 13:10:33 -0700468{
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800469 int i;
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700470 size_t count = req->misc.read.in.size;
471 size_t num_read = req->out.args[0].size;
472 struct inode *inode = req->pages[0]->mapping->host;
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800473
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700474 /*
475 * Short read means EOF. If file size is larger, truncate it
476 */
477 if (!req->out.h.error && num_read < count) {
478 loff_t pos = page_offset(req->pages[0]) + num_read;
479 fuse_read_update_size(inode, pos, req->misc.read.attr_ver);
480 }
481
482 fuse_invalidate_attr(inode); /* atime changed */
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800483
Miklos Szeredidb50b962005-09-09 13:10:33 -0700484 for (i = 0; i < req->num_pages; i++) {
485 struct page *page = req->pages[i];
486 if (!req->out.h.error)
487 SetPageUptodate(page);
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800488 else
489 SetPageError(page);
Miklos Szeredidb50b962005-09-09 13:10:33 -0700490 unlock_page(page);
491 }
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700492 if (req->ff)
493 fuse_file_put(req->ff);
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800494 fuse_put_request(fc, req);
495}
496
Miklos Szeredia6643092007-11-28 16:22:00 -0800497static void fuse_send_readpages(struct fuse_req *req, struct file *file,
Miklos Szeredic1aa96a2006-01-16 22:14:46 -0800498 struct inode *inode)
499{
500 struct fuse_conn *fc = get_fuse_conn(inode);
501 loff_t pos = page_offset(req->pages[0]);
502 size_t count = req->num_pages << PAGE_CACHE_SHIFT;
503 req->out.page_zeroing = 1;
Miklos Szeredia6643092007-11-28 16:22:00 -0800504 fuse_read_fill(req, file, inode, pos, count, FUSE_READ);
Miklos Szeredi5c5c5e52008-04-30 00:54:43 -0700505 req->misc.read.attr_ver = fuse_get_attr_version(fc);
Miklos Szeredi9cd68452006-02-01 03:04:40 -0800506 if (fc->async_read) {
Miklos Szeredia6643092007-11-28 16:22:00 -0800507 struct fuse_file *ff = file->private_data;
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700508 req->ff = fuse_file_get(ff);
Miklos Szeredi9cd68452006-02-01 03:04:40 -0800509 req->end = fuse_readpages_end;
510 request_send_background(fc, req);
511 } else {
512 request_send(fc, req);
513 fuse_readpages_end(fc, req);
514 }
Miklos Szeredidb50b962005-09-09 13:10:33 -0700515}
516
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700517struct fuse_fill_data {
Miklos Szeredidb50b962005-09-09 13:10:33 -0700518 struct fuse_req *req;
Miklos Szeredia6643092007-11-28 16:22:00 -0800519 struct file *file;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700520 struct inode *inode;
521};
522
523static int fuse_readpages_fill(void *_data, struct page *page)
524{
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700525 struct fuse_fill_data *data = _data;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700526 struct fuse_req *req = data->req;
527 struct inode *inode = data->inode;
528 struct fuse_conn *fc = get_fuse_conn(inode);
529
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700530 fuse_wait_on_page_writeback(inode, page->index);
531
Miklos Szeredidb50b962005-09-09 13:10:33 -0700532 if (req->num_pages &&
533 (req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
534 (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read ||
535 req->pages[req->num_pages - 1]->index + 1 != page->index)) {
Miklos Szeredia6643092007-11-28 16:22:00 -0800536 fuse_send_readpages(req, data->file, inode);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700537 data->req = req = fuse_get_req(fc);
538 if (IS_ERR(req)) {
Miklos Szeredidb50b962005-09-09 13:10:33 -0700539 unlock_page(page);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700540 return PTR_ERR(req);
Miklos Szeredidb50b962005-09-09 13:10:33 -0700541 }
Miklos Szeredidb50b962005-09-09 13:10:33 -0700542 }
543 req->pages[req->num_pages] = page;
544 req->num_pages ++;
545 return 0;
546}
547
548static int fuse_readpages(struct file *file, struct address_space *mapping,
549 struct list_head *pages, unsigned nr_pages)
550{
551 struct inode *inode = mapping->host;
552 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredic756e0a2007-10-16 23:31:00 -0700553 struct fuse_fill_data data;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700554 int err;
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800555
Alexander Zarochentsev1d7ea732006-08-13 23:24:27 -0700556 err = -EIO;
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800557 if (is_bad_inode(inode))
OGAWA Hirofumi2e990022006-11-02 22:07:09 -0800558 goto out;
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800559
Miklos Szeredia6643092007-11-28 16:22:00 -0800560 data.file = file;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700561 data.inode = inode;
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700562 data.req = fuse_get_req(fc);
Alexander Zarochentsev1d7ea732006-08-13 23:24:27 -0700563 err = PTR_ERR(data.req);
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700564 if (IS_ERR(data.req))
OGAWA Hirofumi2e990022006-11-02 22:07:09 -0800565 goto out;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700566
567 err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data);
Miklos Szeredid3406ff2006-04-10 22:54:49 -0700568 if (!err) {
569 if (data.req->num_pages)
Miklos Szeredia6643092007-11-28 16:22:00 -0800570 fuse_send_readpages(data.req, file, inode);
Miklos Szeredid3406ff2006-04-10 22:54:49 -0700571 else
572 fuse_put_request(fc, data.req);
573 }
OGAWA Hirofumi2e990022006-11-02 22:07:09 -0800574out:
Alexander Zarochentsev1d7ea732006-08-13 23:24:27 -0700575 return err;
Miklos Szeredidb50b962005-09-09 13:10:33 -0700576}
577
Miklos Szeredibcb4be82007-11-28 16:21:59 -0800578static ssize_t fuse_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
579 unsigned long nr_segs, loff_t pos)
580{
581 struct inode *inode = iocb->ki_filp->f_mapping->host;
582
583 if (pos + iov_length(iov, nr_segs) > i_size_read(inode)) {
584 int err;
585 /*
586 * If trying to read past EOF, make sure the i_size
587 * attribute is up-to-date.
588 */
589 err = fuse_update_attributes(inode, NULL, iocb->ki_filp, NULL);
590 if (err)
591 return err;
592 }
593
594 return generic_file_aio_read(iocb, iov, nr_segs, pos);
595}
596
Miklos Szeredia6643092007-11-28 16:22:00 -0800597static void fuse_write_fill(struct fuse_req *req, struct file *file,
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700598 struct fuse_file *ff, struct inode *inode,
599 loff_t pos, size_t count, int writepage)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700600{
Miklos Szeredif3332112007-10-18 03:07:04 -0700601 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredib25e82e2007-10-18 03:07:03 -0700602 struct fuse_write_in *inarg = &req->misc.write.in;
603 struct fuse_write_out *outarg = &req->misc.write.out;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700604
Miklos Szeredib25e82e2007-10-18 03:07:03 -0700605 memset(inarg, 0, sizeof(struct fuse_write_in));
606 inarg->fh = ff->fh;
607 inarg->offset = pos;
608 inarg->size = count;
609 inarg->write_flags = writepage ? FUSE_WRITE_CACHE : 0;
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700610 inarg->flags = file ? file->f_flags : 0;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700611 req->in.h.opcode = FUSE_WRITE;
612 req->in.h.nodeid = get_node_id(inode);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700613 req->in.argpages = 1;
614 req->in.numargs = 2;
Miklos Szeredif3332112007-10-18 03:07:04 -0700615 if (fc->minor < 9)
616 req->in.args[0].size = FUSE_COMPAT_WRITE_IN_SIZE;
617 else
618 req->in.args[0].size = sizeof(struct fuse_write_in);
Miklos Szeredib25e82e2007-10-18 03:07:03 -0700619 req->in.args[0].value = inarg;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700620 req->in.args[1].size = count;
621 req->out.numargs = 1;
622 req->out.args[0].size = sizeof(struct fuse_write_out);
Miklos Szeredib25e82e2007-10-18 03:07:03 -0700623 req->out.args[0].value = outarg;
624}
625
626static size_t fuse_send_write(struct fuse_req *req, struct file *file,
Miklos Szeredif3332112007-10-18 03:07:04 -0700627 struct inode *inode, loff_t pos, size_t count,
628 fl_owner_t owner)
Miklos Szeredib25e82e2007-10-18 03:07:03 -0700629{
630 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700631 fuse_write_fill(req, file, file->private_data, inode, pos, count, 0);
Miklos Szeredif3332112007-10-18 03:07:04 -0700632 if (owner != NULL) {
633 struct fuse_write_in *inarg = &req->misc.write.in;
634 inarg->write_flags |= FUSE_WRITE_LOCKOWNER;
635 inarg->lock_owner = fuse_lock_owner_id(fc, owner);
636 }
Miklos Szeredi7c352bd2005-09-09 13:10:39 -0700637 request_send(fc, req);
Miklos Szeredib25e82e2007-10-18 03:07:03 -0700638 return req->misc.write.out.size;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700639}
640
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700641static int fuse_write_begin(struct file *file, struct address_space *mapping,
642 loff_t pos, unsigned len, unsigned flags,
643 struct page **pagep, void **fsdata)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700644{
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700645 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
646
647 *pagep = __grab_cache_page(mapping, index);
648 if (!*pagep)
649 return -ENOMEM;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700650 return 0;
651}
652
Miklos Szeredi854512e2008-04-30 00:54:41 -0700653static void fuse_write_update_size(struct inode *inode, loff_t pos)
654{
655 struct fuse_conn *fc = get_fuse_conn(inode);
656 struct fuse_inode *fi = get_fuse_inode(inode);
657
658 spin_lock(&fc->lock);
659 fi->attr_version = ++fc->attr_version;
660 if (pos > inode->i_size)
661 i_size_write(inode, pos);
662 spin_unlock(&fc->lock);
663}
664
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700665static int fuse_buffered_write(struct file *file, struct inode *inode,
666 loff_t pos, unsigned count, struct page *page)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700667{
668 int err;
Miklos Szeredi04730fe2005-09-09 13:10:36 -0700669 size_t nres;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700670 struct fuse_conn *fc = get_fuse_conn(inode);
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700671 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800672 struct fuse_req *req;
673
674 if (is_bad_inode(inode))
675 return -EIO;
676
Miklos Szeredi3be5a522008-04-30 00:54:41 -0700677 /*
678 * Make sure writepages on the same page are not mixed up with
679 * plain writes.
680 */
681 fuse_wait_on_page_writeback(inode, page->index);
682
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700683 req = fuse_get_req(fc);
684 if (IS_ERR(req))
685 return PTR_ERR(req);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700686
687 req->num_pages = 1;
688 req->pages[0] = page;
689 req->page_offset = offset;
Miklos Szeredif3332112007-10-18 03:07:04 -0700690 nres = fuse_send_write(req, file, inode, pos, count, NULL);
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700691 err = req->out.h.error;
692 fuse_put_request(fc, req);
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700693 if (!err && !nres)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700694 err = -EIO;
695 if (!err) {
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700696 pos += nres;
Miklos Szeredi854512e2008-04-30 00:54:41 -0700697 fuse_write_update_size(inode, pos);
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700698 if (count == PAGE_CACHE_SIZE)
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700699 SetPageUptodate(page);
Miklos Szeredib36c31b2005-09-09 13:10:38 -0700700 }
701 fuse_invalidate_attr(inode);
Nick Piggin5e6f58a2007-10-16 01:25:17 -0700702 return err ? err : nres;
703}
704
705static int fuse_write_end(struct file *file, struct address_space *mapping,
706 loff_t pos, unsigned len, unsigned copied,
707 struct page *page, void *fsdata)
708{
709 struct inode *inode = mapping->host;
710 int res = 0;
711
712 if (copied)
713 res = fuse_buffered_write(file, inode, pos, copied, page);
714
715 unlock_page(page);
716 page_cache_release(page);
717 return res;
Miklos Szeredib6aeade2005-09-09 13:10:30 -0700718}
719
Nick Pigginea9b9902008-04-30 00:54:42 -0700720static size_t fuse_send_write_pages(struct fuse_req *req, struct file *file,
721 struct inode *inode, loff_t pos,
722 size_t count)
723{
724 size_t res;
725 unsigned offset;
726 unsigned i;
727
728 for (i = 0; i < req->num_pages; i++)
729 fuse_wait_on_page_writeback(inode, req->pages[i]->index);
730
731 res = fuse_send_write(req, file, inode, pos, count, NULL);
732
733 offset = req->page_offset;
734 count = res;
735 for (i = 0; i < req->num_pages; i++) {
736 struct page *page = req->pages[i];
737
738 if (!req->out.h.error && !offset && count >= PAGE_CACHE_SIZE)
739 SetPageUptodate(page);
740
741 if (count > PAGE_CACHE_SIZE - offset)
742 count -= PAGE_CACHE_SIZE - offset;
743 else
744 count = 0;
745 offset = 0;
746
747 unlock_page(page);
748 page_cache_release(page);
749 }
750
751 return res;
752}
753
754static ssize_t fuse_fill_write_pages(struct fuse_req *req,
755 struct address_space *mapping,
756 struct iov_iter *ii, loff_t pos)
757{
758 struct fuse_conn *fc = get_fuse_conn(mapping->host);
759 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
760 size_t count = 0;
761 int err;
762
763 req->page_offset = offset;
764
765 do {
766 size_t tmp;
767 struct page *page;
768 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
769 size_t bytes = min_t(size_t, PAGE_CACHE_SIZE - offset,
770 iov_iter_count(ii));
771
772 bytes = min_t(size_t, bytes, fc->max_write - count);
773
774 again:
775 err = -EFAULT;
776 if (iov_iter_fault_in_readable(ii, bytes))
777 break;
778
779 err = -ENOMEM;
780 page = __grab_cache_page(mapping, index);
781 if (!page)
782 break;
783
784 pagefault_disable();
785 tmp = iov_iter_copy_from_user_atomic(page, ii, offset, bytes);
786 pagefault_enable();
787 flush_dcache_page(page);
788
789 if (!tmp) {
790 unlock_page(page);
791 page_cache_release(page);
792 bytes = min(bytes, iov_iter_single_seg_count(ii));
793 goto again;
794 }
795
796 err = 0;
797 req->pages[req->num_pages] = page;
798 req->num_pages++;
799
800 iov_iter_advance(ii, tmp);
801 count += tmp;
802 pos += tmp;
803 offset += tmp;
804 if (offset == PAGE_CACHE_SIZE)
805 offset = 0;
806
Miklos Szeredi78bb6cb2008-05-12 14:02:32 -0700807 if (!fc->big_writes)
808 break;
Nick Pigginea9b9902008-04-30 00:54:42 -0700809 } while (iov_iter_count(ii) && count < fc->max_write &&
810 req->num_pages < FUSE_MAX_PAGES_PER_REQ && offset == 0);
811
812 return count > 0 ? count : err;
813}
814
815static ssize_t fuse_perform_write(struct file *file,
816 struct address_space *mapping,
817 struct iov_iter *ii, loff_t pos)
818{
819 struct inode *inode = mapping->host;
820 struct fuse_conn *fc = get_fuse_conn(inode);
821 int err = 0;
822 ssize_t res = 0;
823
824 if (is_bad_inode(inode))
825 return -EIO;
826
827 do {
828 struct fuse_req *req;
829 ssize_t count;
830
831 req = fuse_get_req(fc);
832 if (IS_ERR(req)) {
833 err = PTR_ERR(req);
834 break;
835 }
836
837 count = fuse_fill_write_pages(req, mapping, ii, pos);
838 if (count <= 0) {
839 err = count;
840 } else {
841 size_t num_written;
842
843 num_written = fuse_send_write_pages(req, file, inode,
844 pos, count);
845 err = req->out.h.error;
846 if (!err) {
847 res += num_written;
848 pos += num_written;
849
850 /* break out of the loop on short write */
851 if (num_written != count)
852 err = -EIO;
853 }
854 }
855 fuse_put_request(fc, req);
856 } while (!err && iov_iter_count(ii));
857
858 if (res > 0)
859 fuse_write_update_size(inode, pos);
860
861 fuse_invalidate_attr(inode);
862
863 return res > 0 ? res : err;
864}
865
866static ssize_t fuse_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
867 unsigned long nr_segs, loff_t pos)
868{
869 struct file *file = iocb->ki_filp;
870 struct address_space *mapping = file->f_mapping;
871 size_t count = 0;
872 ssize_t written = 0;
873 struct inode *inode = mapping->host;
874 ssize_t err;
875 struct iov_iter i;
876
877 WARN_ON(iocb->ki_pos != pos);
878
879 err = generic_segment_checks(iov, &nr_segs, &count, VERIFY_READ);
880 if (err)
881 return err;
882
883 mutex_lock(&inode->i_mutex);
884 vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
885
886 /* We can write back this queue in page reclaim */
887 current->backing_dev_info = mapping->backing_dev_info;
888
889 err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
890 if (err)
891 goto out;
892
893 if (count == 0)
894 goto out;
895
896 err = remove_suid(file->f_path.dentry);
897 if (err)
898 goto out;
899
900 file_update_time(file);
901
902 iov_iter_init(&i, iov, nr_segs, count, 0);
903 written = fuse_perform_write(file, mapping, &i, pos);
904 if (written >= 0)
905 iocb->ki_pos = pos + written;
906
907out:
908 current->backing_dev_info = NULL;
909 mutex_unlock(&inode->i_mutex);
910
911 return written ? written : err;
912}
913
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700914static void fuse_release_user_pages(struct fuse_req *req, int write)
915{
916 unsigned i;
917
918 for (i = 0; i < req->num_pages; i++) {
919 struct page *page = req->pages[i];
920 if (write)
921 set_page_dirty_lock(page);
922 put_page(page);
923 }
924}
925
926static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf,
927 unsigned nbytes, int write)
928{
929 unsigned long user_addr = (unsigned long) buf;
930 unsigned offset = user_addr & ~PAGE_MASK;
931 int npages;
932
933 /* This doesn't work with nfsd */
934 if (!current->mm)
935 return -EPERM;
936
937 nbytes = min(nbytes, (unsigned) FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
938 npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
Harvey Harrisonbd730962008-05-01 04:35:15 -0700939 npages = clamp(npages, 1, FUSE_MAX_PAGES_PER_REQ);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700940 down_read(&current->mm->mmap_sem);
941 npages = get_user_pages(current, current->mm, user_addr, npages, write,
942 0, req->pages, NULL);
943 up_read(&current->mm->mmap_sem);
944 if (npages < 0)
945 return npages;
946
947 req->num_pages = npages;
948 req->page_offset = offset;
949 return 0;
950}
951
952static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
953 size_t count, loff_t *ppos, int write)
954{
Josef Sipek7706a9d2006-12-08 02:37:02 -0800955 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700956 struct fuse_conn *fc = get_fuse_conn(inode);
957 size_t nmax = write ? fc->max_write : fc->max_read;
958 loff_t pos = *ppos;
959 ssize_t res = 0;
Miklos Szeredi248d86e2006-01-06 00:19:39 -0800960 struct fuse_req *req;
961
962 if (is_bad_inode(inode))
963 return -EIO;
964
Miklos Szeredice1d5a42006-04-10 22:54:58 -0700965 req = fuse_get_req(fc);
966 if (IS_ERR(req))
967 return PTR_ERR(req);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700968
969 while (count) {
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700970 size_t nres;
Miklos Szeredie5d9a0d2008-04-30 00:54:44 -0700971 size_t nbytes_limit = min(count, nmax);
972 size_t nbytes;
973 int err = fuse_get_user_pages(req, buf, nbytes_limit, !write);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700974 if (err) {
975 res = err;
976 break;
977 }
Miklos Szeredi6ad84ac2006-01-06 00:19:42 -0800978 nbytes = (req->num_pages << PAGE_SHIFT) - req->page_offset;
Miklos Szeredie5d9a0d2008-04-30 00:54:44 -0700979 nbytes = min(nbytes_limit, nbytes);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700980 if (write)
Miklos Szeredif3332112007-10-18 03:07:04 -0700981 nres = fuse_send_write(req, file, inode, pos, nbytes,
982 current->files);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700983 else
Miklos Szeredif3332112007-10-18 03:07:04 -0700984 nres = fuse_send_read(req, file, inode, pos, nbytes,
985 current->files);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -0700986 fuse_release_user_pages(req, !write);
987 if (req->out.h.error) {
988 if (!res)
989 res = req->out.h.error;
990 break;
991 } else if (nres > nbytes) {
992 res = -EIO;
993 break;
994 }
995 count -= nres;
996 res += nres;
997 pos += nres;
998 buf += nres;
999 if (nres != nbytes)
1000 break;
Miklos Szeredi56cf34f2006-04-11 21:16:51 +02001001 if (count) {
1002 fuse_put_request(fc, req);
1003 req = fuse_get_req(fc);
1004 if (IS_ERR(req))
1005 break;
1006 }
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001007 }
1008 fuse_put_request(fc, req);
1009 if (res > 0) {
Miklos Szeredi854512e2008-04-30 00:54:41 -07001010 if (write)
1011 fuse_write_update_size(inode, pos);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001012 *ppos = pos;
Miklos Szeredib36c31b2005-09-09 13:10:38 -07001013 }
1014 fuse_invalidate_attr(inode);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001015
1016 return res;
1017}
1018
1019static ssize_t fuse_direct_read(struct file *file, char __user *buf,
1020 size_t count, loff_t *ppos)
1021{
1022 return fuse_direct_io(file, buf, count, ppos, 0);
1023}
1024
1025static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
1026 size_t count, loff_t *ppos)
1027{
Josef Sipek7706a9d2006-12-08 02:37:02 -08001028 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001029 ssize_t res;
1030 /* Don't allow parallel writes to the same file */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001031 mutex_lock(&inode->i_mutex);
Miklos Szeredi889f7842007-05-23 13:57:54 -07001032 res = generic_write_checks(file, ppos, &count, 0);
1033 if (!res)
1034 res = fuse_direct_io(file, buf, count, ppos, 1);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001035 mutex_unlock(&inode->i_mutex);
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001036 return res;
1037}
1038
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001039static void fuse_writepage_free(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001040{
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001041 __free_page(req->pages[0]);
1042 fuse_file_put(req->ff);
1043 fuse_put_request(fc, req);
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001044}
1045
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001046static void fuse_writepage_finish(struct fuse_conn *fc, struct fuse_req *req)
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001047{
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001048 struct inode *inode = req->inode;
1049 struct fuse_inode *fi = get_fuse_inode(inode);
1050 struct backing_dev_info *bdi = inode->i_mapping->backing_dev_info;
1051
1052 list_del(&req->writepages_entry);
1053 dec_bdi_stat(bdi, BDI_WRITEBACK);
1054 dec_zone_page_state(req->pages[0], NR_WRITEBACK_TEMP);
1055 bdi_writeout_inc(bdi);
1056 wake_up(&fi->page_waitq);
1057}
1058
1059/* Called under fc->lock, may release and reacquire it */
1060static void fuse_send_writepage(struct fuse_conn *fc, struct fuse_req *req)
1061{
1062 struct fuse_inode *fi = get_fuse_inode(req->inode);
1063 loff_t size = i_size_read(req->inode);
1064 struct fuse_write_in *inarg = &req->misc.write.in;
1065
1066 if (!fc->connected)
1067 goto out_free;
1068
1069 if (inarg->offset + PAGE_CACHE_SIZE <= size) {
1070 inarg->size = PAGE_CACHE_SIZE;
1071 } else if (inarg->offset < size) {
1072 inarg->size = size & (PAGE_CACHE_SIZE - 1);
1073 } else {
1074 /* Got truncated off completely */
1075 goto out_free;
1076 }
1077
1078 req->in.args[1].size = inarg->size;
1079 fi->writectr++;
1080 request_send_background_locked(fc, req);
1081 return;
1082
1083 out_free:
1084 fuse_writepage_finish(fc, req);
1085 spin_unlock(&fc->lock);
1086 fuse_writepage_free(fc, req);
1087 spin_lock(&fc->lock);
1088}
1089
1090/*
1091 * If fi->writectr is positive (no truncate or fsync going on) send
1092 * all queued writepage requests.
1093 *
1094 * Called with fc->lock
1095 */
1096void fuse_flush_writepages(struct inode *inode)
1097{
1098 struct fuse_conn *fc = get_fuse_conn(inode);
1099 struct fuse_inode *fi = get_fuse_inode(inode);
1100 struct fuse_req *req;
1101
1102 while (fi->writectr >= 0 && !list_empty(&fi->queued_writes)) {
1103 req = list_entry(fi->queued_writes.next, struct fuse_req, list);
1104 list_del_init(&req->list);
1105 fuse_send_writepage(fc, req);
1106 }
1107}
1108
1109static void fuse_writepage_end(struct fuse_conn *fc, struct fuse_req *req)
1110{
1111 struct inode *inode = req->inode;
1112 struct fuse_inode *fi = get_fuse_inode(inode);
1113
1114 mapping_set_error(inode->i_mapping, req->out.h.error);
1115 spin_lock(&fc->lock);
1116 fi->writectr--;
1117 fuse_writepage_finish(fc, req);
1118 spin_unlock(&fc->lock);
1119 fuse_writepage_free(fc, req);
1120}
1121
1122static int fuse_writepage_locked(struct page *page)
1123{
1124 struct address_space *mapping = page->mapping;
1125 struct inode *inode = mapping->host;
1126 struct fuse_conn *fc = get_fuse_conn(inode);
1127 struct fuse_inode *fi = get_fuse_inode(inode);
1128 struct fuse_req *req;
1129 struct fuse_file *ff;
1130 struct page *tmp_page;
1131
1132 set_page_writeback(page);
1133
1134 req = fuse_request_alloc_nofs();
1135 if (!req)
1136 goto err;
1137
1138 tmp_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
1139 if (!tmp_page)
1140 goto err_free;
1141
1142 spin_lock(&fc->lock);
1143 BUG_ON(list_empty(&fi->write_files));
1144 ff = list_entry(fi->write_files.next, struct fuse_file, write_entry);
1145 req->ff = fuse_file_get(ff);
1146 spin_unlock(&fc->lock);
1147
1148 fuse_write_fill(req, NULL, ff, inode, page_offset(page), 0, 1);
1149
1150 copy_highpage(tmp_page, page);
1151 req->num_pages = 1;
1152 req->pages[0] = tmp_page;
1153 req->page_offset = 0;
1154 req->end = fuse_writepage_end;
1155 req->inode = inode;
1156
1157 inc_bdi_stat(mapping->backing_dev_info, BDI_WRITEBACK);
1158 inc_zone_page_state(tmp_page, NR_WRITEBACK_TEMP);
1159 end_page_writeback(page);
1160
1161 spin_lock(&fc->lock);
1162 list_add(&req->writepages_entry, &fi->writepages);
1163 list_add_tail(&req->list, &fi->queued_writes);
1164 fuse_flush_writepages(inode);
1165 spin_unlock(&fc->lock);
1166
1167 return 0;
1168
1169err_free:
1170 fuse_request_free(req);
1171err:
1172 end_page_writeback(page);
1173 return -ENOMEM;
1174}
1175
1176static int fuse_writepage(struct page *page, struct writeback_control *wbc)
1177{
1178 int err;
1179
1180 err = fuse_writepage_locked(page);
1181 unlock_page(page);
1182
1183 return err;
1184}
1185
1186static int fuse_launder_page(struct page *page)
1187{
1188 int err = 0;
1189 if (clear_page_dirty_for_io(page)) {
1190 struct inode *inode = page->mapping->host;
1191 err = fuse_writepage_locked(page);
1192 if (!err)
1193 fuse_wait_on_page_writeback(inode, page->index);
1194 }
1195 return err;
1196}
1197
1198/*
1199 * Write back dirty pages now, because there may not be any suitable
1200 * open files later
1201 */
1202static void fuse_vma_close(struct vm_area_struct *vma)
1203{
1204 filemap_write_and_wait(vma->vm_file->f_mapping);
1205}
1206
1207/*
1208 * Wait for writeback against this page to complete before allowing it
1209 * to be marked dirty again, and hence written back again, possibly
1210 * before the previous writepage completed.
1211 *
1212 * Block here, instead of in ->writepage(), so that the userspace fs
1213 * can only block processes actually operating on the filesystem.
1214 *
1215 * Otherwise unprivileged userspace fs would be able to block
1216 * unrelated:
1217 *
1218 * - page migration
1219 * - sync(2)
1220 * - try_to_free_pages() with order > PAGE_ALLOC_COSTLY_ORDER
1221 */
1222static int fuse_page_mkwrite(struct vm_area_struct *vma, struct page *page)
1223{
1224 /*
1225 * Don't use page->mapping as it may become NULL from a
1226 * concurrent truncate.
1227 */
1228 struct inode *inode = vma->vm_file->f_mapping->host;
1229
1230 fuse_wait_on_page_writeback(inode, page->index);
1231 return 0;
1232}
1233
1234static struct vm_operations_struct fuse_file_vm_ops = {
1235 .close = fuse_vma_close,
1236 .fault = filemap_fault,
1237 .page_mkwrite = fuse_page_mkwrite,
1238};
1239
1240static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
1241{
1242 if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) {
1243 struct inode *inode = file->f_dentry->d_inode;
1244 struct fuse_conn *fc = get_fuse_conn(inode);
1245 struct fuse_inode *fi = get_fuse_inode(inode);
1246 struct fuse_file *ff = file->private_data;
1247 /*
1248 * file may be written through mmap, so chain it onto the
1249 * inodes's write_file list
1250 */
1251 spin_lock(&fc->lock);
1252 if (list_empty(&ff->write_entry))
1253 list_add(&ff->write_entry, &fi->write_files);
1254 spin_unlock(&fc->lock);
1255 }
1256 file_accessed(file);
1257 vma->vm_ops = &fuse_file_vm_ops;
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001258 return 0;
1259}
1260
Miklos Szeredi71421252006-06-25 05:48:52 -07001261static int convert_fuse_file_lock(const struct fuse_file_lock *ffl,
1262 struct file_lock *fl)
1263{
1264 switch (ffl->type) {
1265 case F_UNLCK:
1266 break;
1267
1268 case F_RDLCK:
1269 case F_WRLCK:
1270 if (ffl->start > OFFSET_MAX || ffl->end > OFFSET_MAX ||
1271 ffl->end < ffl->start)
1272 return -EIO;
1273
1274 fl->fl_start = ffl->start;
1275 fl->fl_end = ffl->end;
1276 fl->fl_pid = ffl->pid;
1277 break;
1278
1279 default:
1280 return -EIO;
1281 }
1282 fl->fl_type = ffl->type;
1283 return 0;
1284}
1285
1286static void fuse_lk_fill(struct fuse_req *req, struct file *file,
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001287 const struct file_lock *fl, int opcode, pid_t pid,
1288 int flock)
Miklos Szeredi71421252006-06-25 05:48:52 -07001289{
Josef Sipek7706a9d2006-12-08 02:37:02 -08001290 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi9c8ef562006-06-25 05:48:55 -07001291 struct fuse_conn *fc = get_fuse_conn(inode);
Miklos Szeredi71421252006-06-25 05:48:52 -07001292 struct fuse_file *ff = file->private_data;
1293 struct fuse_lk_in *arg = &req->misc.lk_in;
1294
1295 arg->fh = ff->fh;
Miklos Szeredi9c8ef562006-06-25 05:48:55 -07001296 arg->owner = fuse_lock_owner_id(fc, fl->fl_owner);
Miklos Szeredi71421252006-06-25 05:48:52 -07001297 arg->lk.start = fl->fl_start;
1298 arg->lk.end = fl->fl_end;
1299 arg->lk.type = fl->fl_type;
1300 arg->lk.pid = pid;
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001301 if (flock)
1302 arg->lk_flags |= FUSE_LK_FLOCK;
Miklos Szeredi71421252006-06-25 05:48:52 -07001303 req->in.h.opcode = opcode;
1304 req->in.h.nodeid = get_node_id(inode);
1305 req->in.numargs = 1;
1306 req->in.args[0].size = sizeof(*arg);
1307 req->in.args[0].value = arg;
1308}
1309
1310static int fuse_getlk(struct file *file, struct file_lock *fl)
1311{
Josef Sipek7706a9d2006-12-08 02:37:02 -08001312 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi71421252006-06-25 05:48:52 -07001313 struct fuse_conn *fc = get_fuse_conn(inode);
1314 struct fuse_req *req;
1315 struct fuse_lk_out outarg;
1316 int err;
1317
1318 req = fuse_get_req(fc);
1319 if (IS_ERR(req))
1320 return PTR_ERR(req);
1321
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001322 fuse_lk_fill(req, file, fl, FUSE_GETLK, 0, 0);
Miklos Szeredi71421252006-06-25 05:48:52 -07001323 req->out.numargs = 1;
1324 req->out.args[0].size = sizeof(outarg);
1325 req->out.args[0].value = &outarg;
1326 request_send(fc, req);
1327 err = req->out.h.error;
1328 fuse_put_request(fc, req);
1329 if (!err)
1330 err = convert_fuse_file_lock(&outarg.lk, fl);
1331
1332 return err;
1333}
1334
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001335static int fuse_setlk(struct file *file, struct file_lock *fl, int flock)
Miklos Szeredi71421252006-06-25 05:48:52 -07001336{
Josef Sipek7706a9d2006-12-08 02:37:02 -08001337 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi71421252006-06-25 05:48:52 -07001338 struct fuse_conn *fc = get_fuse_conn(inode);
1339 struct fuse_req *req;
1340 int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
1341 pid_t pid = fl->fl_type != F_UNLCK ? current->tgid : 0;
1342 int err;
1343
Miklos Szeredi48e90762008-07-25 01:49:02 -07001344 if (fl->fl_lmops && fl->fl_lmops->fl_grant) {
1345 /* NLM needs asynchronous locks, which we don't support yet */
1346 return -ENOLCK;
1347 }
1348
Miklos Szeredi71421252006-06-25 05:48:52 -07001349 /* Unlock on close is handled by the flush method */
1350 if (fl->fl_flags & FL_CLOSE)
1351 return 0;
1352
1353 req = fuse_get_req(fc);
1354 if (IS_ERR(req))
1355 return PTR_ERR(req);
1356
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001357 fuse_lk_fill(req, file, fl, opcode, pid, flock);
Miklos Szeredi71421252006-06-25 05:48:52 -07001358 request_send(fc, req);
1359 err = req->out.h.error;
Miklos Szeredia4d27e72006-06-25 05:48:54 -07001360 /* locking is restartable */
1361 if (err == -EINTR)
1362 err = -ERESTARTSYS;
Miklos Szeredi71421252006-06-25 05:48:52 -07001363 fuse_put_request(fc, req);
1364 return err;
1365}
1366
1367static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
1368{
Josef Sipek7706a9d2006-12-08 02:37:02 -08001369 struct inode *inode = file->f_path.dentry->d_inode;
Miklos Szeredi71421252006-06-25 05:48:52 -07001370 struct fuse_conn *fc = get_fuse_conn(inode);
1371 int err;
1372
Miklos Szeredi48e90762008-07-25 01:49:02 -07001373 if (cmd == F_CANCELLK) {
1374 err = 0;
1375 } else if (cmd == F_GETLK) {
Miklos Szeredi71421252006-06-25 05:48:52 -07001376 if (fc->no_lock) {
Marc Eshel9d6a8c52007-02-21 00:55:18 -05001377 posix_test_lock(file, fl);
Miklos Szeredi71421252006-06-25 05:48:52 -07001378 err = 0;
1379 } else
1380 err = fuse_getlk(file, fl);
1381 } else {
1382 if (fc->no_lock)
Miklos Szeredi48e90762008-07-25 01:49:02 -07001383 err = posix_lock_file(file, fl, NULL);
Miklos Szeredi71421252006-06-25 05:48:52 -07001384 else
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001385 err = fuse_setlk(file, fl, 0);
Miklos Szeredi71421252006-06-25 05:48:52 -07001386 }
1387 return err;
1388}
1389
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001390static int fuse_file_flock(struct file *file, int cmd, struct file_lock *fl)
1391{
1392 struct inode *inode = file->f_path.dentry->d_inode;
1393 struct fuse_conn *fc = get_fuse_conn(inode);
1394 int err;
1395
1396 if (fc->no_lock) {
1397 err = flock_lock_file_wait(file, fl);
1398 } else {
1399 /* emulate flock with POSIX locks */
1400 fl->fl_owner = (fl_owner_t) file;
1401 err = fuse_setlk(file, fl, 1);
1402 }
1403
1404 return err;
1405}
1406
Miklos Szeredib2d22722006-12-06 20:35:51 -08001407static sector_t fuse_bmap(struct address_space *mapping, sector_t block)
1408{
1409 struct inode *inode = mapping->host;
1410 struct fuse_conn *fc = get_fuse_conn(inode);
1411 struct fuse_req *req;
1412 struct fuse_bmap_in inarg;
1413 struct fuse_bmap_out outarg;
1414 int err;
1415
1416 if (!inode->i_sb->s_bdev || fc->no_bmap)
1417 return 0;
1418
1419 req = fuse_get_req(fc);
1420 if (IS_ERR(req))
1421 return 0;
1422
1423 memset(&inarg, 0, sizeof(inarg));
1424 inarg.block = block;
1425 inarg.blocksize = inode->i_sb->s_blocksize;
1426 req->in.h.opcode = FUSE_BMAP;
1427 req->in.h.nodeid = get_node_id(inode);
1428 req->in.numargs = 1;
1429 req->in.args[0].size = sizeof(inarg);
1430 req->in.args[0].value = &inarg;
1431 req->out.numargs = 1;
1432 req->out.args[0].size = sizeof(outarg);
1433 req->out.args[0].value = &outarg;
1434 request_send(fc, req);
1435 err = req->out.h.error;
1436 fuse_put_request(fc, req);
1437 if (err == -ENOSYS)
1438 fc->no_bmap = 1;
1439
1440 return err ? 0 : outarg.block;
1441}
1442
Miklos Szeredi5559b8f2008-04-30 00:54:45 -07001443static loff_t fuse_file_llseek(struct file *file, loff_t offset, int origin)
1444{
1445 loff_t retval;
1446 struct inode *inode = file->f_path.dentry->d_inode;
1447
1448 mutex_lock(&inode->i_mutex);
1449 switch (origin) {
1450 case SEEK_END:
1451 offset += i_size_read(inode);
1452 break;
1453 case SEEK_CUR:
1454 offset += file->f_pos;
1455 }
1456 retval = -EINVAL;
1457 if (offset >= 0 && offset <= inode->i_sb->s_maxbytes) {
1458 if (offset != file->f_pos) {
1459 file->f_pos = offset;
1460 file->f_version = 0;
1461 }
1462 retval = offset;
1463 }
1464 mutex_unlock(&inode->i_mutex);
1465 return retval;
1466}
1467
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001468static const struct file_operations fuse_file_operations = {
Miklos Szeredi5559b8f2008-04-30 00:54:45 -07001469 .llseek = fuse_file_llseek,
Badari Pulavarty543ade12006-09-30 23:28:48 -07001470 .read = do_sync_read,
Miklos Szeredibcb4be82007-11-28 16:21:59 -08001471 .aio_read = fuse_file_aio_read,
Badari Pulavarty543ade12006-09-30 23:28:48 -07001472 .write = do_sync_write,
Nick Pigginea9b9902008-04-30 00:54:42 -07001473 .aio_write = fuse_file_aio_write,
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001474 .mmap = fuse_file_mmap,
1475 .open = fuse_open,
1476 .flush = fuse_flush,
1477 .release = fuse_release,
1478 .fsync = fuse_fsync,
Miklos Szeredi71421252006-06-25 05:48:52 -07001479 .lock = fuse_file_lock,
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001480 .flock = fuse_file_flock,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +02001481 .splice_read = generic_file_splice_read,
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001482};
1483
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001484static const struct file_operations fuse_direct_io_file_operations = {
Miklos Szeredi5559b8f2008-04-30 00:54:45 -07001485 .llseek = fuse_file_llseek,
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001486 .read = fuse_direct_read,
1487 .write = fuse_direct_write,
1488 .open = fuse_open,
1489 .flush = fuse_flush,
1490 .release = fuse_release,
1491 .fsync = fuse_fsync,
Miklos Szeredi71421252006-06-25 05:48:52 -07001492 .lock = fuse_file_lock,
Miklos Szeredia9ff4f82007-10-18 03:07:02 -07001493 .flock = fuse_file_flock,
Jens Axboe5ffc4ef2007-06-01 11:49:19 +02001494 /* no mmap and splice_read */
Miklos Szeredi413ef8c2005-09-09 13:10:35 -07001495};
1496
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07001497static const struct address_space_operations fuse_file_aops = {
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001498 .readpage = fuse_readpage,
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001499 .writepage = fuse_writepage,
1500 .launder_page = fuse_launder_page,
Nick Piggin5e6f58a2007-10-16 01:25:17 -07001501 .write_begin = fuse_write_begin,
1502 .write_end = fuse_write_end,
Miklos Szeredidb50b962005-09-09 13:10:33 -07001503 .readpages = fuse_readpages,
Miklos Szeredi3be5a522008-04-30 00:54:41 -07001504 .set_page_dirty = __set_page_dirty_nobuffers,
Miklos Szeredib2d22722006-12-06 20:35:51 -08001505 .bmap = fuse_bmap,
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001506};
1507
1508void fuse_init_file_inode(struct inode *inode)
1509{
Miklos Szeredi45323fb2005-09-09 13:10:37 -07001510 inode->i_fop = &fuse_file_operations;
1511 inode->i_data.a_ops = &fuse_file_aops;
Miklos Szeredib6aeade2005-09-09 13:10:30 -07001512}