2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2005 Miklos Szeredi <miklos@szeredi.hu>
5 This program can be distributed under the terms of the GNU GPL.
11 #include <linux/pagemap.h>
12 #include <linux/slab.h>
13 #include <linux/kernel.h>
15 static struct file_operations fuse_direct_io_file_operations
;
17 int fuse_open_common(struct inode
*inode
, struct file
*file
, int isdir
)
19 struct fuse_conn
*fc
= get_fuse_conn(inode
);
21 struct fuse_open_in inarg
;
22 struct fuse_open_out outarg
;
25 /* Restarting the syscall is not allowed if O_CREAT and O_EXCL
26 are both set, because creation will fail on the restart */
27 int excl
= (file
->f_flags
& (O_CREAT
|O_EXCL
)) == (O_CREAT
|O_EXCL
);
29 err
= generic_file_open(inode
, file
);
33 /* If opening the root node, no lookup has been performed on
34 it, so the attributes must be refreshed */
35 if (get_node_id(inode
) == FUSE_ROOT_ID
) {
36 int err
= fuse_do_getattr(inode
);
42 req
= fuse_get_request_nonint(fc
);
44 req
= fuse_get_request(fc
);
46 return excl
? -EINTR
: -ERESTARTSYS
;
49 ff
= kmalloc(sizeof(struct fuse_file
), GFP_KERNEL
);
53 ff
->release_req
= fuse_request_alloc();
54 if (!ff
->release_req
) {
59 memset(&inarg
, 0, sizeof(inarg
));
60 inarg
.flags
= file
->f_flags
& ~(O_CREAT
| O_EXCL
| O_NOCTTY
| O_TRUNC
);
61 req
->in
.h
.opcode
= isdir
? FUSE_OPENDIR
: FUSE_OPEN
;
62 req
->in
.h
.nodeid
= get_node_id(inode
);
65 req
->in
.args
[0].size
= sizeof(inarg
);
66 req
->in
.args
[0].value
= &inarg
;
68 req
->out
.args
[0].size
= sizeof(outarg
);
69 req
->out
.args
[0].value
= &outarg
;
71 request_send_nonint(fc
, req
);
73 request_send(fc
, req
);
74 err
= req
->out
.h
.error
;
76 fuse_request_free(ff
->release_req
);
79 if (!isdir
&& (outarg
.open_flags
& FOPEN_DIRECT_IO
))
80 file
->f_op
= &fuse_direct_io_file_operations
;
81 if (!(outarg
.open_flags
& FOPEN_KEEP_CACHE
))
82 invalidate_inode_pages(inode
->i_mapping
);
84 file
->private_data
= ff
;
88 fuse_put_request(fc
, req
);
92 int fuse_release_common(struct inode
*inode
, struct file
*file
, int isdir
)
94 struct fuse_conn
*fc
= get_fuse_conn(inode
);
95 struct fuse_file
*ff
= file
->private_data
;
96 struct fuse_req
*req
= ff
->release_req
;
97 struct fuse_release_in
*inarg
= &req
->misc
.release_in
;
100 inarg
->flags
= file
->f_flags
& ~O_EXCL
;
101 req
->in
.h
.opcode
= isdir
? FUSE_RELEASEDIR
: FUSE_RELEASE
;
102 req
->in
.h
.nodeid
= get_node_id(inode
);
105 req
->in
.args
[0].size
= sizeof(struct fuse_release_in
);
106 req
->in
.args
[0].value
= inarg
;
107 request_send_background(fc
, req
);
110 /* Return value is ignored by VFS */
114 static int fuse_open(struct inode
*inode
, struct file
*file
)
116 return fuse_open_common(inode
, file
, 0);
119 static int fuse_release(struct inode
*inode
, struct file
*file
)
121 return fuse_release_common(inode
, file
, 0);
124 static int fuse_flush(struct file
*file
)
126 struct inode
*inode
= file
->f_dentry
->d_inode
;
127 struct fuse_conn
*fc
= get_fuse_conn(inode
);
128 struct fuse_file
*ff
= file
->private_data
;
129 struct fuse_req
*req
;
130 struct fuse_flush_in inarg
;
136 req
= fuse_get_request_nonint(fc
);
140 memset(&inarg
, 0, sizeof(inarg
));
142 req
->in
.h
.opcode
= FUSE_FLUSH
;
143 req
->in
.h
.nodeid
= get_node_id(inode
);
147 req
->in
.args
[0].size
= sizeof(inarg
);
148 req
->in
.args
[0].value
= &inarg
;
149 request_send_nonint(fc
, req
);
150 err
= req
->out
.h
.error
;
151 fuse_put_request(fc
, req
);
152 if (err
== -ENOSYS
) {
159 int fuse_fsync_common(struct file
*file
, struct dentry
*de
, int datasync
,
162 struct inode
*inode
= de
->d_inode
;
163 struct fuse_conn
*fc
= get_fuse_conn(inode
);
164 struct fuse_file
*ff
= file
->private_data
;
165 struct fuse_req
*req
;
166 struct fuse_fsync_in inarg
;
169 if ((!isdir
&& fc
->no_fsync
) || (isdir
&& fc
->no_fsyncdir
))
172 req
= fuse_get_request(fc
);
176 memset(&inarg
, 0, sizeof(inarg
));
178 inarg
.fsync_flags
= datasync
? 1 : 0;
179 req
->in
.h
.opcode
= isdir
? FUSE_FSYNCDIR
: FUSE_FSYNC
;
180 req
->in
.h
.nodeid
= get_node_id(inode
);
184 req
->in
.args
[0].size
= sizeof(inarg
);
185 req
->in
.args
[0].value
= &inarg
;
186 request_send(fc
, req
);
187 err
= req
->out
.h
.error
;
188 fuse_put_request(fc
, req
);
189 if (err
== -ENOSYS
) {
199 static int fuse_fsync(struct file
*file
, struct dentry
*de
, int datasync
)
201 return fuse_fsync_common(file
, de
, datasync
, 0);
204 size_t fuse_send_read_common(struct fuse_req
*req
, struct file
*file
,
205 struct inode
*inode
, loff_t pos
, size_t count
,
208 struct fuse_conn
*fc
= get_fuse_conn(inode
);
209 struct fuse_file
*ff
= file
->private_data
;
210 struct fuse_read_in inarg
;
212 memset(&inarg
, 0, sizeof(struct fuse_read_in
));
216 req
->in
.h
.opcode
= isdir
? FUSE_READDIR
: FUSE_READ
;
217 req
->in
.h
.nodeid
= get_node_id(inode
);
221 req
->in
.args
[0].size
= sizeof(struct fuse_read_in
);
222 req
->in
.args
[0].value
= &inarg
;
223 req
->out
.argpages
= 1;
225 req
->out
.numargs
= 1;
226 req
->out
.args
[0].size
= count
;
227 request_send_nonint(fc
, req
);
228 return req
->out
.args
[0].size
;
231 static inline size_t fuse_send_read(struct fuse_req
*req
, struct file
*file
,
232 struct inode
*inode
, loff_t pos
,
235 return fuse_send_read_common(req
, file
, inode
, pos
, count
, 0);
238 static int fuse_readpage(struct file
*file
, struct page
*page
)
240 struct inode
*inode
= page
->mapping
->host
;
241 struct fuse_conn
*fc
= get_fuse_conn(inode
);
242 loff_t pos
= (loff_t
) page
->index
<< PAGE_CACHE_SHIFT
;
243 struct fuse_req
*req
= fuse_get_request_nonint(fc
);
248 req
->out
.page_zeroing
= 1;
250 req
->pages
[0] = page
;
251 fuse_send_read(req
, file
, inode
, pos
, PAGE_CACHE_SIZE
);
252 err
= req
->out
.h
.error
;
253 fuse_put_request(fc
, req
);
255 SetPageUptodate(page
);
256 fuse_invalidate_attr(inode
); /* atime changed */
262 static int fuse_send_readpages(struct fuse_req
*req
, struct file
*file
,
265 loff_t pos
= (loff_t
) req
->pages
[0]->index
<< PAGE_CACHE_SHIFT
;
266 size_t count
= req
->num_pages
<< PAGE_CACHE_SHIFT
;
268 req
->out
.page_zeroing
= 1;
269 fuse_send_read(req
, file
, inode
, pos
, count
);
270 for (i
= 0; i
< req
->num_pages
; i
++) {
271 struct page
*page
= req
->pages
[i
];
272 if (!req
->out
.h
.error
)
273 SetPageUptodate(page
);
276 return req
->out
.h
.error
;
279 struct fuse_readpages_data
{
280 struct fuse_req
*req
;
285 static int fuse_readpages_fill(void *_data
, struct page
*page
)
287 struct fuse_readpages_data
*data
= _data
;
288 struct fuse_req
*req
= data
->req
;
289 struct inode
*inode
= data
->inode
;
290 struct fuse_conn
*fc
= get_fuse_conn(inode
);
292 if (req
->num_pages
&&
293 (req
->num_pages
== FUSE_MAX_PAGES_PER_REQ
||
294 (req
->num_pages
+ 1) * PAGE_CACHE_SIZE
> fc
->max_read
||
295 req
->pages
[req
->num_pages
- 1]->index
+ 1 != page
->index
)) {
296 int err
= fuse_send_readpages(req
, data
->file
, inode
);
301 fuse_reset_request(req
);
303 req
->pages
[req
->num_pages
] = page
;
308 static int fuse_readpages(struct file
*file
, struct address_space
*mapping
,
309 struct list_head
*pages
, unsigned nr_pages
)
311 struct inode
*inode
= mapping
->host
;
312 struct fuse_conn
*fc
= get_fuse_conn(inode
);
313 struct fuse_readpages_data data
;
317 data
.req
= fuse_get_request_nonint(fc
);
321 err
= read_cache_pages(mapping
, pages
, fuse_readpages_fill
, &data
);
322 if (!err
&& data
.req
->num_pages
)
323 err
= fuse_send_readpages(data
.req
, file
, inode
);
324 fuse_put_request(fc
, data
.req
);
325 fuse_invalidate_attr(inode
); /* atime changed */
329 static size_t fuse_send_write(struct fuse_req
*req
, struct file
*file
,
330 struct inode
*inode
, loff_t pos
, size_t count
)
332 struct fuse_conn
*fc
= get_fuse_conn(inode
);
333 struct fuse_file
*ff
= file
->private_data
;
334 struct fuse_write_in inarg
;
335 struct fuse_write_out outarg
;
337 memset(&inarg
, 0, sizeof(struct fuse_write_in
));
341 req
->in
.h
.opcode
= FUSE_WRITE
;
342 req
->in
.h
.nodeid
= get_node_id(inode
);
345 req
->in
.argpages
= 1;
347 req
->in
.args
[0].size
= sizeof(struct fuse_write_in
);
348 req
->in
.args
[0].value
= &inarg
;
349 req
->in
.args
[1].size
= count
;
350 req
->out
.numargs
= 1;
351 req
->out
.args
[0].size
= sizeof(struct fuse_write_out
);
352 req
->out
.args
[0].value
= &outarg
;
353 request_send_nonint(fc
, req
);
357 static int fuse_prepare_write(struct file
*file
, struct page
*page
,
358 unsigned offset
, unsigned to
)
364 static int fuse_commit_write(struct file
*file
, struct page
*page
,
365 unsigned offset
, unsigned to
)
369 unsigned count
= to
- offset
;
370 struct inode
*inode
= page
->mapping
->host
;
371 struct fuse_conn
*fc
= get_fuse_conn(inode
);
372 loff_t pos
= ((loff_t
) page
->index
<< PAGE_CACHE_SHIFT
) + offset
;
373 struct fuse_req
*req
= fuse_get_request_nonint(fc
);
378 req
->pages
[0] = page
;
379 req
->page_offset
= offset
;
380 nres
= fuse_send_write(req
, file
, inode
, pos
, count
);
381 err
= req
->out
.h
.error
;
382 fuse_put_request(fc
, req
);
383 if (!err
&& nres
!= count
)
387 if (pos
> i_size_read(inode
))
388 i_size_write(inode
, pos
);
390 if (offset
== 0 && to
== PAGE_CACHE_SIZE
) {
391 clear_page_dirty(page
);
392 SetPageUptodate(page
);
395 fuse_invalidate_attr(inode
);
399 static void fuse_release_user_pages(struct fuse_req
*req
, int write
)
403 for (i
= 0; i
< req
->num_pages
; i
++) {
404 struct page
*page
= req
->pages
[i
];
406 set_page_dirty_lock(page
);
411 static int fuse_get_user_pages(struct fuse_req
*req
, const char __user
*buf
,
412 unsigned nbytes
, int write
)
414 unsigned long user_addr
= (unsigned long) buf
;
415 unsigned offset
= user_addr
& ~PAGE_MASK
;
418 /* This doesn't work with nfsd */
422 nbytes
= min(nbytes
, (unsigned) FUSE_MAX_PAGES_PER_REQ
<< PAGE_SHIFT
);
423 npages
= (nbytes
+ offset
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
424 npages
= min(npages
, FUSE_MAX_PAGES_PER_REQ
);
425 down_read(¤t
->mm
->mmap_sem
);
426 npages
= get_user_pages(current
, current
->mm
, user_addr
, npages
, write
,
427 0, req
->pages
, NULL
);
428 up_read(¤t
->mm
->mmap_sem
);
432 req
->num_pages
= npages
;
433 req
->page_offset
= offset
;
437 static ssize_t
fuse_direct_io(struct file
*file
, const char __user
*buf
,
438 size_t count
, loff_t
*ppos
, int write
)
440 struct inode
*inode
= file
->f_dentry
->d_inode
;
441 struct fuse_conn
*fc
= get_fuse_conn(inode
);
442 size_t nmax
= write
? fc
->max_write
: fc
->max_read
;
445 struct fuse_req
*req
= fuse_get_request(fc
);
452 size_t nbytes
= min(count
, nmax
);
453 int err
= fuse_get_user_pages(req
, buf
, nbytes
, !write
);
458 tmp
= (req
->num_pages
<< PAGE_SHIFT
) - req
->page_offset
;
459 nbytes
= min(nbytes
, tmp
);
461 nres
= fuse_send_write(req
, file
, inode
, pos
, nbytes
);
463 nres
= fuse_send_read(req
, file
, inode
, pos
, nbytes
);
464 fuse_release_user_pages(req
, !write
);
465 if (req
->out
.h
.error
) {
467 res
= req
->out
.h
.error
;
469 } else if (nres
> nbytes
) {
480 fuse_reset_request(req
);
482 fuse_put_request(fc
, req
);
484 if (write
&& pos
> i_size_read(inode
))
485 i_size_write(inode
, pos
);
488 fuse_invalidate_attr(inode
);
493 static ssize_t
fuse_direct_read(struct file
*file
, char __user
*buf
,
494 size_t count
, loff_t
*ppos
)
496 return fuse_direct_io(file
, buf
, count
, ppos
, 0);
499 static ssize_t
fuse_direct_write(struct file
*file
, const char __user
*buf
,
500 size_t count
, loff_t
*ppos
)
502 struct inode
*inode
= file
->f_dentry
->d_inode
;
504 /* Don't allow parallel writes to the same file */
506 res
= fuse_direct_io(file
, buf
, count
, ppos
, 1);
511 static int fuse_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
513 if ((vma
->vm_flags
& VM_SHARED
)) {
514 if ((vma
->vm_flags
& VM_WRITE
))
517 vma
->vm_flags
&= ~VM_MAYWRITE
;
519 return generic_file_mmap(file
, vma
);
522 static int fuse_set_page_dirty(struct page
*page
)
524 printk("fuse_set_page_dirty: should not happen\n");
529 static struct file_operations fuse_file_operations
= {
530 .llseek
= generic_file_llseek
,
531 .read
= generic_file_read
,
532 .write
= generic_file_write
,
533 .mmap
= fuse_file_mmap
,
536 .release
= fuse_release
,
538 .sendfile
= generic_file_sendfile
,
541 static struct file_operations fuse_direct_io_file_operations
= {
542 .llseek
= generic_file_llseek
,
543 .read
= fuse_direct_read
,
544 .write
= fuse_direct_write
,
547 .release
= fuse_release
,
549 /* no mmap and sendfile */
552 static struct address_space_operations fuse_file_aops
= {
553 .readpage
= fuse_readpage
,
554 .prepare_write
= fuse_prepare_write
,
555 .commit_write
= fuse_commit_write
,
556 .readpages
= fuse_readpages
,
557 .set_page_dirty
= fuse_set_page_dirty
,
560 void fuse_init_file_inode(struct inode
*inode
)
562 inode
->i_fop
= &fuse_file_operations
;
563 inode
->i_data
.a_ops
= &fuse_file_aops
;