Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / fs / fuse / file.c
1 /*
2   FUSE: Filesystem in Userspace
3   Copyright (C) 2001-2005  Miklos Szeredi <miklos@szeredi.hu>
4
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>
14
15 static struct file_operations fuse_direct_io_file_operations;
16
17 int fuse_open_common(struct inode *inode, struct file *file, int isdir)
18 {
19         struct fuse_conn *fc = get_fuse_conn(inode);
20         struct fuse_req *req;
21         struct fuse_open_in inarg;
22         struct fuse_open_out outarg;
23         struct fuse_file *ff;
24         int err;
25
26         /* VFS checks this, but only _after_ ->open() */
27         if (file->f_flags & O_DIRECT)
28                 return -EINVAL;
29
30         err = generic_file_open(inode, file);
31         if (err)
32                 return err;
33
34         /* If opening the root node, no lookup has been performed on
35            it, so the attributes must be refreshed */
36         if (get_node_id(inode) == FUSE_ROOT_ID) {
37                 int err = fuse_do_getattr(inode);
38                 if (err)
39                         return err;
40         }
41
42         req = fuse_get_request(fc);
43         if (!req)
44                 return -EINTR;
45
46         err = -ENOMEM;
47         ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL);
48         if (!ff)
49                 goto out_put_request;
50
51         ff->release_req = fuse_request_alloc();
52         if (!ff->release_req) {
53                 kfree(ff);
54                 goto out_put_request;
55         }
56
57         memset(&inarg, 0, sizeof(inarg));
58         inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
59         req->in.h.opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
60         req->in.h.nodeid = get_node_id(inode);
61         req->inode = inode;
62         req->in.numargs = 1;
63         req->in.args[0].size = sizeof(inarg);
64         req->in.args[0].value = &inarg;
65         req->out.numargs = 1;
66         req->out.args[0].size = sizeof(outarg);
67         req->out.args[0].value = &outarg;
68         request_send(fc, req);
69         err = req->out.h.error;
70         if (err) {
71                 fuse_request_free(ff->release_req);
72                 kfree(ff);
73         } else {
74                 if (!isdir && (outarg.open_flags & FOPEN_DIRECT_IO))
75                         file->f_op = &fuse_direct_io_file_operations;
76                 if (!(outarg.open_flags & FOPEN_KEEP_CACHE))
77                         invalidate_inode_pages(inode->i_mapping);
78                 ff->fh = outarg.fh;
79                 file->private_data = ff;
80         }
81
82  out_put_request:
83         fuse_put_request(fc, req);
84         return err;
85 }
86
87 int fuse_release_common(struct inode *inode, struct file *file, int isdir)
88 {
89         struct fuse_conn *fc = get_fuse_conn(inode);
90         struct fuse_file *ff = file->private_data;
91         struct fuse_req *req = ff->release_req;
92         struct fuse_release_in *inarg = &req->misc.release_in;
93
94         inarg->fh = ff->fh;
95         inarg->flags = file->f_flags & ~O_EXCL;
96         req->in.h.opcode = isdir ? FUSE_RELEASEDIR : FUSE_RELEASE;
97         req->in.h.nodeid = get_node_id(inode);
98         req->inode = inode;
99         req->in.numargs = 1;
100         req->in.args[0].size = sizeof(struct fuse_release_in);
101         req->in.args[0].value = inarg;
102         request_send_background(fc, req);
103         kfree(ff);
104
105         /* Return value is ignored by VFS */
106         return 0;
107 }
108
109 static int fuse_open(struct inode *inode, struct file *file)
110 {
111         return fuse_open_common(inode, file, 0);
112 }
113
114 static int fuse_release(struct inode *inode, struct file *file)
115 {
116         return fuse_release_common(inode, file, 0);
117 }
118
119 static int fuse_flush(struct file *file)
120 {
121         struct inode *inode = file->f_dentry->d_inode;
122         struct fuse_conn *fc = get_fuse_conn(inode);
123         struct fuse_file *ff = file->private_data;
124         struct fuse_req *req;
125         struct fuse_flush_in inarg;
126         int err;
127
128         if (fc->no_flush)
129                 return 0;
130
131         req = fuse_get_request(fc);
132         if (!req)
133                 return -EINTR;
134
135         memset(&inarg, 0, sizeof(inarg));
136         inarg.fh = ff->fh;
137         req->in.h.opcode = FUSE_FLUSH;
138         req->in.h.nodeid = get_node_id(inode);
139         req->inode = inode;
140         req->file = file;
141         req->in.numargs = 1;
142         req->in.args[0].size = sizeof(inarg);
143         req->in.args[0].value = &inarg;
144         request_send(fc, req);
145         err = req->out.h.error;
146         fuse_put_request(fc, req);
147         if (err == -ENOSYS) {
148                 fc->no_flush = 1;
149                 err = 0;
150         }
151         return err;
152 }
153
154 int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
155                       int isdir)
156 {
157         struct inode *inode = de->d_inode;
158         struct fuse_conn *fc = get_fuse_conn(inode);
159         struct fuse_file *ff = file->private_data;
160         struct fuse_req *req;
161         struct fuse_fsync_in inarg;
162         int err;
163
164         if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir))
165                 return 0;
166
167         req = fuse_get_request(fc);
168         if (!req)
169                 return -EINTR;
170
171         memset(&inarg, 0, sizeof(inarg));
172         inarg.fh = ff->fh;
173         inarg.fsync_flags = datasync ? 1 : 0;
174         req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;
175         req->in.h.nodeid = get_node_id(inode);
176         req->inode = inode;
177         req->file = file;
178         req->in.numargs = 1;
179         req->in.args[0].size = sizeof(inarg);
180         req->in.args[0].value = &inarg;
181         request_send(fc, req);
182         err = req->out.h.error;
183         fuse_put_request(fc, req);
184         if (err == -ENOSYS) {
185                 if (isdir)
186                         fc->no_fsyncdir = 1;
187                 else
188                         fc->no_fsync = 1;
189                 err = 0;
190         }
191         return err;
192 }
193
194 static int fuse_fsync(struct file *file, struct dentry *de, int datasync)
195 {
196         return fuse_fsync_common(file, de, datasync, 0);
197 }
198
199 size_t fuse_send_read_common(struct fuse_req *req, struct file *file,
200                              struct inode *inode, loff_t pos, size_t count,
201                              int isdir)
202 {
203         struct fuse_conn *fc = get_fuse_conn(inode);
204         struct fuse_file *ff = file->private_data;
205         struct fuse_read_in inarg;
206
207         memset(&inarg, 0, sizeof(struct fuse_read_in));
208         inarg.fh = ff->fh;
209         inarg.offset = pos;
210         inarg.size = count;
211         req->in.h.opcode = isdir ? FUSE_READDIR : FUSE_READ;
212         req->in.h.nodeid = get_node_id(inode);
213         req->inode = inode;
214         req->file = file;
215         req->in.numargs = 1;
216         req->in.args[0].size = sizeof(struct fuse_read_in);
217         req->in.args[0].value = &inarg;
218         req->out.argpages = 1;
219         req->out.argvar = 1;
220         req->out.numargs = 1;
221         req->out.args[0].size = count;
222         request_send(fc, req);
223         return req->out.args[0].size;
224 }
225
226 static inline size_t fuse_send_read(struct fuse_req *req, struct file *file,
227                                     struct inode *inode, loff_t pos,
228                                     size_t count)
229 {
230         return fuse_send_read_common(req, file, inode, pos, count, 0);
231 }
232
233 static int fuse_readpage(struct file *file, struct page *page)
234 {
235         struct inode *inode = page->mapping->host;
236         struct fuse_conn *fc = get_fuse_conn(inode);
237         loff_t pos = (loff_t) page->index << PAGE_CACHE_SHIFT;
238         struct fuse_req *req = fuse_get_request(fc);
239         int err = -EINTR;
240         if (!req)
241                 goto out;
242
243         req->out.page_zeroing = 1;
244         req->num_pages = 1;
245         req->pages[0] = page;
246         fuse_send_read(req, file, inode, pos, PAGE_CACHE_SIZE);
247         err = req->out.h.error;
248         fuse_put_request(fc, req);
249         if (!err)
250                 SetPageUptodate(page);
251         fuse_invalidate_attr(inode); /* atime changed */
252  out:
253         unlock_page(page);
254         return err;
255 }
256
257 static int fuse_send_readpages(struct fuse_req *req, struct file *file,
258                                struct inode *inode)
259 {
260         loff_t pos = (loff_t) req->pages[0]->index << PAGE_CACHE_SHIFT;
261         size_t count = req->num_pages << PAGE_CACHE_SHIFT;
262         unsigned i;
263         req->out.page_zeroing = 1;
264         fuse_send_read(req, file, inode, pos, count);
265         for (i = 0; i < req->num_pages; i++) {
266                 struct page *page = req->pages[i];
267                 if (!req->out.h.error)
268                         SetPageUptodate(page);
269                 unlock_page(page);
270         }
271         return req->out.h.error;
272 }
273
274 struct fuse_readpages_data {
275         struct fuse_req *req;
276         struct file *file;
277         struct inode *inode;
278 };
279
280 static int fuse_readpages_fill(void *_data, struct page *page)
281 {
282         struct fuse_readpages_data *data = _data;
283         struct fuse_req *req = data->req;
284         struct inode *inode = data->inode;
285         struct fuse_conn *fc = get_fuse_conn(inode);
286
287         if (req->num_pages &&
288             (req->num_pages == FUSE_MAX_PAGES_PER_REQ ||
289              (req->num_pages + 1) * PAGE_CACHE_SIZE > fc->max_read ||
290              req->pages[req->num_pages - 1]->index + 1 != page->index)) {
291                 int err = fuse_send_readpages(req, data->file, inode);
292                 if (err) {
293                         unlock_page(page);
294                         return err;
295                 }
296                 fuse_reset_request(req);
297         }
298         req->pages[req->num_pages] = page;
299         req->num_pages ++;
300         return 0;
301 }
302
303 static int fuse_readpages(struct file *file, struct address_space *mapping,
304                           struct list_head *pages, unsigned nr_pages)
305 {
306         struct inode *inode = mapping->host;
307         struct fuse_conn *fc = get_fuse_conn(inode);
308         struct fuse_readpages_data data;
309         int err;
310         data.file = file;
311         data.inode = inode;
312         data.req = fuse_get_request(fc);
313         if (!data.req)
314                 return -EINTR;
315
316         err = read_cache_pages(mapping, pages, fuse_readpages_fill, &data);
317         if (!err && data.req->num_pages)
318                 err = fuse_send_readpages(data.req, file, inode);
319         fuse_put_request(fc, data.req);
320         fuse_invalidate_attr(inode); /* atime changed */
321         return err;
322 }
323
324 static size_t fuse_send_write(struct fuse_req *req, struct file *file,
325                               struct inode *inode, loff_t pos, size_t count)
326 {
327         struct fuse_conn *fc = get_fuse_conn(inode);
328         struct fuse_file *ff = file->private_data;
329         struct fuse_write_in inarg;
330         struct fuse_write_out outarg;
331
332         memset(&inarg, 0, sizeof(struct fuse_write_in));
333         inarg.fh = ff->fh;
334         inarg.offset = pos;
335         inarg.size = count;
336         req->in.h.opcode = FUSE_WRITE;
337         req->in.h.nodeid = get_node_id(inode);
338         req->inode = inode;
339         req->file = file;
340         req->in.argpages = 1;
341         req->in.numargs = 2;
342         req->in.args[0].size = sizeof(struct fuse_write_in);
343         req->in.args[0].value = &inarg;
344         req->in.args[1].size = count;
345         req->out.numargs = 1;
346         req->out.args[0].size = sizeof(struct fuse_write_out);
347         req->out.args[0].value = &outarg;
348         request_send(fc, req);
349         return outarg.size;
350 }
351
352 static int fuse_prepare_write(struct file *file, struct page *page,
353                               unsigned offset, unsigned to)
354 {
355         /* No op */
356         return 0;
357 }
358
359 static int fuse_commit_write(struct file *file, struct page *page,
360                              unsigned offset, unsigned to)
361 {
362         int err;
363         size_t nres;
364         unsigned count = to - offset;
365         struct inode *inode = page->mapping->host;
366         struct fuse_conn *fc = get_fuse_conn(inode);
367         loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + offset;
368         struct fuse_req *req = fuse_get_request(fc);
369         if (!req)
370                 return -EINTR;
371
372         req->num_pages = 1;
373         req->pages[0] = page;
374         req->page_offset = offset;
375         nres = fuse_send_write(req, file, inode, pos, count);
376         err = req->out.h.error;
377         fuse_put_request(fc, req);
378         if (!err && nres != count)
379                 err = -EIO;
380         if (!err) {
381                 pos += count;
382                 if (pos > i_size_read(inode))
383                         i_size_write(inode, pos);
384
385                 if (offset == 0 && to == PAGE_CACHE_SIZE) {
386                         clear_page_dirty(page);
387                         SetPageUptodate(page);
388                 }
389         }
390         fuse_invalidate_attr(inode);
391         return err;
392 }
393
394 static void fuse_release_user_pages(struct fuse_req *req, int write)
395 {
396         unsigned i;
397
398         for (i = 0; i < req->num_pages; i++) {
399                 struct page *page = req->pages[i];
400                 if (write)
401                         set_page_dirty_lock(page);
402                 put_page(page);
403         }
404 }
405
406 static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf,
407                                unsigned nbytes, int write)
408 {
409         unsigned long user_addr = (unsigned long) buf;
410         unsigned offset = user_addr & ~PAGE_MASK;
411         int npages;
412
413         /* This doesn't work with nfsd */
414         if (!current->mm)
415                 return -EPERM;
416
417         nbytes = min(nbytes, (unsigned) FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
418         npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
419         npages = min(npages, FUSE_MAX_PAGES_PER_REQ);
420         down_read(&current->mm->mmap_sem);
421         npages = get_user_pages(current, current->mm, user_addr, npages, write,
422                                 0, req->pages, NULL);
423         up_read(&current->mm->mmap_sem);
424         if (npages < 0)
425                 return npages;
426
427         req->num_pages = npages;
428         req->page_offset = offset;
429         return 0;
430 }
431
432 static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
433                               size_t count, loff_t *ppos, int write)
434 {
435         struct inode *inode = file->f_dentry->d_inode;
436         struct fuse_conn *fc = get_fuse_conn(inode);
437         size_t nmax = write ? fc->max_write : fc->max_read;
438         loff_t pos = *ppos;
439         ssize_t res = 0;
440         struct fuse_req *req = fuse_get_request(fc);
441         if (!req)
442                 return -EINTR;
443
444         while (count) {
445                 size_t tmp;
446                 size_t nres;
447                 size_t nbytes = min(count, nmax);
448                 int err = fuse_get_user_pages(req, buf, nbytes, !write);
449                 if (err) {
450                         res = err;
451                         break;
452                 }
453                 tmp = (req->num_pages << PAGE_SHIFT) - req->page_offset;
454                 nbytes = min(nbytes, tmp);
455                 if (write)
456                         nres = fuse_send_write(req, file, inode, pos, nbytes);
457                 else
458                         nres = fuse_send_read(req, file, inode, pos, nbytes);
459                 fuse_release_user_pages(req, !write);
460                 if (req->out.h.error) {
461                         if (!res)
462                                 res = req->out.h.error;
463                         break;
464                 } else if (nres > nbytes) {
465                         res = -EIO;
466                         break;
467                 }
468                 count -= nres;
469                 res += nres;
470                 pos += nres;
471                 buf += nres;
472                 if (nres != nbytes)
473                         break;
474                 if (count)
475                         fuse_reset_request(req);
476         }
477         fuse_put_request(fc, req);
478         if (res > 0) {
479                 if (write && pos > i_size_read(inode))
480                         i_size_write(inode, pos);
481                 *ppos = pos;
482         }
483         fuse_invalidate_attr(inode);
484
485         return res;
486 }
487
488 static ssize_t fuse_direct_read(struct file *file, char __user *buf,
489                                      size_t count, loff_t *ppos)
490 {
491         return fuse_direct_io(file, buf, count, ppos, 0);
492 }
493
494 static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
495                                  size_t count, loff_t *ppos)
496 {
497         struct inode *inode = file->f_dentry->d_inode;
498         ssize_t res;
499         /* Don't allow parallel writes to the same file */
500         down(&inode->i_sem);
501         res = fuse_direct_io(file, buf, count, ppos, 1);
502         up(&inode->i_sem);
503         return res;
504 }
505
506 static int fuse_file_mmap(struct file *file, struct vm_area_struct *vma)
507 {
508         if ((vma->vm_flags & VM_SHARED)) {
509                 if ((vma->vm_flags & VM_WRITE))
510                         return -ENODEV;
511                 else
512                         vma->vm_flags &= ~VM_MAYWRITE;
513         }
514         return generic_file_mmap(file, vma);
515 }
516
517 static int fuse_set_page_dirty(struct page *page)
518 {
519         printk("fuse_set_page_dirty: should not happen\n");
520         dump_stack();
521         return 0;
522 }
523
524 static struct file_operations fuse_file_operations = {
525         .llseek         = generic_file_llseek,
526         .read           = generic_file_read,
527         .write          = generic_file_write,
528         .mmap           = fuse_file_mmap,
529         .open           = fuse_open,
530         .flush          = fuse_flush,
531         .release        = fuse_release,
532         .fsync          = fuse_fsync,
533         .sendfile       = generic_file_sendfile,
534 };
535
536 static struct file_operations fuse_direct_io_file_operations = {
537         .llseek         = generic_file_llseek,
538         .read           = fuse_direct_read,
539         .write          = fuse_direct_write,
540         .open           = fuse_open,
541         .flush          = fuse_flush,
542         .release        = fuse_release,
543         .fsync          = fuse_fsync,
544         /* no mmap and sendfile */
545 };
546
547 static struct address_space_operations fuse_file_aops  = {
548         .readpage       = fuse_readpage,
549         .prepare_write  = fuse_prepare_write,
550         .commit_write   = fuse_commit_write,
551         .readpages      = fuse_readpages,
552         .set_page_dirty = fuse_set_page_dirty,
553 };
554
555 void fuse_init_file_inode(struct inode *inode)
556 {
557         inode->i_fop = &fuse_file_operations;
558         inode->i_data.a_ops = &fuse_file_aops;
559 }