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 int fuse_open(struct inode
*inode
, struct file
*file
)
17 struct fuse_conn
*fc
= get_fuse_conn(inode
);
19 struct fuse_open_in inarg
;
20 struct fuse_open_out outarg
;
23 /* Restarting the syscall is not allowed if O_CREAT and O_EXCL
24 are both set, because creation will fail on the restart */
25 int excl
= (file
->f_flags
& (O_CREAT
|O_EXCL
)) == (O_CREAT
|O_EXCL
);
27 err
= generic_file_open(inode
, file
);
31 /* If opening the root node, no lookup has been performed on
32 it, so the attributes must be refreshed */
33 if (get_node_id(inode
) == FUSE_ROOT_ID
) {
34 int err
= fuse_do_getattr(inode
);
40 req
= fuse_get_request_nonint(fc
);
42 req
= fuse_get_request(fc
);
44 return excl
? -EINTR
: -ERESTARTSYS
;
47 ff
= kmalloc(sizeof(struct fuse_file
), GFP_KERNEL
);
51 ff
->release_req
= fuse_request_alloc();
52 if (!ff
->release_req
) {
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
= FUSE_OPEN
;
60 req
->in
.h
.nodeid
= get_node_id(inode
);
63 req
->in
.args
[0].size
= sizeof(inarg
);
64 req
->in
.args
[0].value
= &inarg
;
66 req
->out
.args
[0].size
= sizeof(outarg
);
67 req
->out
.args
[0].value
= &outarg
;
69 request_send_nonint(fc
, req
);
71 request_send(fc
, req
);
72 err
= req
->out
.h
.error
;
73 if (!err
&& !(fc
->flags
& FUSE_KERNEL_CACHE
))
74 invalidate_inode_pages(inode
->i_mapping
);
76 fuse_request_free(ff
->release_req
);
80 file
->private_data
= ff
;
84 fuse_put_request(fc
, req
);
88 static int fuse_release(struct inode
*inode
, struct file
*file
)
90 struct fuse_conn
*fc
= get_fuse_conn(inode
);
91 struct fuse_file
*ff
= file
->private_data
;
92 struct fuse_req
*req
= ff
->release_req
;
93 struct fuse_release_in
*inarg
= &req
->misc
.release_in
;
96 inarg
->flags
= file
->f_flags
& ~O_EXCL
;
97 req
->in
.h
.opcode
= FUSE_RELEASE
;
98 req
->in
.h
.nodeid
= get_node_id(inode
);
101 req
->in
.args
[0].size
= sizeof(struct fuse_release_in
);
102 req
->in
.args
[0].value
= inarg
;
103 request_send_background(fc
, req
);
106 /* Return value is ignored by VFS */
110 static int fuse_flush(struct file
*file
)
112 struct inode
*inode
= file
->f_dentry
->d_inode
;
113 struct fuse_conn
*fc
= get_fuse_conn(inode
);
114 struct fuse_file
*ff
= file
->private_data
;
115 struct fuse_req
*req
;
116 struct fuse_flush_in inarg
;
122 req
= fuse_get_request_nonint(fc
);
126 memset(&inarg
, 0, sizeof(inarg
));
128 req
->in
.h
.opcode
= FUSE_FLUSH
;
129 req
->in
.h
.nodeid
= get_node_id(inode
);
133 req
->in
.args
[0].size
= sizeof(inarg
);
134 req
->in
.args
[0].value
= &inarg
;
135 request_send_nonint(fc
, req
);
136 err
= req
->out
.h
.error
;
137 fuse_put_request(fc
, req
);
138 if (err
== -ENOSYS
) {
145 static int fuse_fsync(struct file
*file
, struct dentry
*de
, int datasync
)
147 struct inode
*inode
= de
->d_inode
;
148 struct fuse_conn
*fc
= get_fuse_conn(inode
);
149 struct fuse_file
*ff
= file
->private_data
;
150 struct fuse_req
*req
;
151 struct fuse_fsync_in inarg
;
157 req
= fuse_get_request(fc
);
161 memset(&inarg
, 0, sizeof(inarg
));
163 inarg
.fsync_flags
= datasync
? 1 : 0;
164 req
->in
.h
.opcode
= FUSE_FSYNC
;
165 req
->in
.h
.nodeid
= get_node_id(inode
);
169 req
->in
.args
[0].size
= sizeof(inarg
);
170 req
->in
.args
[0].value
= &inarg
;
171 request_send(fc
, req
);
172 err
= req
->out
.h
.error
;
173 fuse_put_request(fc
, req
);
174 if (err
== -ENOSYS
) {
181 static ssize_t
fuse_send_read(struct fuse_req
*req
, struct file
*file
,
182 struct inode
*inode
, loff_t pos
, size_t count
)
184 struct fuse_conn
*fc
= get_fuse_conn(inode
);
185 struct fuse_file
*ff
= file
->private_data
;
186 struct fuse_read_in inarg
;
188 memset(&inarg
, 0, sizeof(struct fuse_read_in
));
192 req
->in
.h
.opcode
= FUSE_READ
;
193 req
->in
.h
.nodeid
= get_node_id(inode
);
197 req
->in
.args
[0].size
= sizeof(struct fuse_read_in
);
198 req
->in
.args
[0].value
= &inarg
;
199 req
->out
.argpages
= 1;
201 req
->out
.numargs
= 1;
202 req
->out
.args
[0].size
= count
;
203 request_send_nonint(fc
, req
);
204 return req
->out
.args
[0].size
;
207 static int fuse_readpage(struct file
*file
, struct page
*page
)
209 struct inode
*inode
= page
->mapping
->host
;
210 struct fuse_conn
*fc
= get_fuse_conn(inode
);
211 loff_t pos
= (loff_t
) page
->index
<< PAGE_CACHE_SHIFT
;
212 struct fuse_req
*req
= fuse_get_request_nonint(fc
);
217 req
->out
.page_zeroing
= 1;
219 req
->pages
[0] = page
;
220 fuse_send_read(req
, file
, inode
, pos
, PAGE_CACHE_SIZE
);
221 err
= req
->out
.h
.error
;
222 fuse_put_request(fc
, req
);
224 SetPageUptodate(page
);
230 static int fuse_send_readpages(struct fuse_req
*req
, struct file
*file
,
233 loff_t pos
= (loff_t
) req
->pages
[0]->index
<< PAGE_CACHE_SHIFT
;
234 size_t count
= req
->num_pages
<< PAGE_CACHE_SHIFT
;
236 req
->out
.page_zeroing
= 1;
237 fuse_send_read(req
, file
, inode
, pos
, count
);
238 for (i
= 0; i
< req
->num_pages
; i
++) {
239 struct page
*page
= req
->pages
[i
];
240 if (!req
->out
.h
.error
)
241 SetPageUptodate(page
);
244 return req
->out
.h
.error
;
247 struct fuse_readpages_data
{
248 struct fuse_req
*req
;
253 static int fuse_readpages_fill(void *_data
, struct page
*page
)
255 struct fuse_readpages_data
*data
= _data
;
256 struct fuse_req
*req
= data
->req
;
257 struct inode
*inode
= data
->inode
;
258 struct fuse_conn
*fc
= get_fuse_conn(inode
);
260 if (req
->num_pages
&&
261 (req
->num_pages
== FUSE_MAX_PAGES_PER_REQ
||
262 (req
->num_pages
+ 1) * PAGE_CACHE_SIZE
> fc
->max_read
||
263 req
->pages
[req
->num_pages
- 1]->index
+ 1 != page
->index
)) {
264 int err
= fuse_send_readpages(req
, data
->file
, inode
);
269 fuse_reset_request(req
);
271 req
->pages
[req
->num_pages
] = page
;
276 static int fuse_readpages(struct file
*file
, struct address_space
*mapping
,
277 struct list_head
*pages
, unsigned nr_pages
)
279 struct inode
*inode
= mapping
->host
;
280 struct fuse_conn
*fc
= get_fuse_conn(inode
);
281 struct fuse_readpages_data data
;
285 data
.req
= fuse_get_request_nonint(fc
);
289 err
= read_cache_pages(mapping
, pages
, fuse_readpages_fill
, &data
);
290 if (!err
&& data
.req
->num_pages
)
291 err
= fuse_send_readpages(data
.req
, file
, inode
);
292 fuse_put_request(fc
, data
.req
);
296 static ssize_t
fuse_send_write(struct fuse_req
*req
, struct file
*file
,
297 struct inode
*inode
, loff_t pos
, size_t count
)
299 struct fuse_conn
*fc
= get_fuse_conn(inode
);
300 struct fuse_file
*ff
= file
->private_data
;
301 struct fuse_write_in inarg
;
302 struct fuse_write_out outarg
;
304 memset(&inarg
, 0, sizeof(struct fuse_write_in
));
308 req
->in
.h
.opcode
= FUSE_WRITE
;
309 req
->in
.h
.nodeid
= get_node_id(inode
);
312 req
->in
.argpages
= 1;
314 req
->in
.args
[0].size
= sizeof(struct fuse_write_in
);
315 req
->in
.args
[0].value
= &inarg
;
316 req
->in
.args
[1].size
= count
;
317 req
->out
.numargs
= 1;
318 req
->out
.args
[0].size
= sizeof(struct fuse_write_out
);
319 req
->out
.args
[0].value
= &outarg
;
320 request_send_nonint(fc
, req
);
324 static int fuse_prepare_write(struct file
*file
, struct page
*page
,
325 unsigned offset
, unsigned to
)
331 static int fuse_commit_write(struct file
*file
, struct page
*page
,
332 unsigned offset
, unsigned to
)
336 unsigned count
= to
- offset
;
337 struct inode
*inode
= page
->mapping
->host
;
338 struct fuse_conn
*fc
= get_fuse_conn(inode
);
339 loff_t pos
= ((loff_t
) page
->index
<< PAGE_CACHE_SHIFT
) + offset
;
340 struct fuse_req
*req
= fuse_get_request_nonint(fc
);
345 req
->pages
[0] = page
;
346 req
->page_offset
= offset
;
347 nres
= fuse_send_write(req
, file
, inode
, pos
, count
);
348 err
= req
->out
.h
.error
;
349 fuse_put_request(fc
, req
);
350 if (!err
&& nres
!= count
)
354 if (pos
> i_size_read(inode
))
355 i_size_write(inode
, pos
);
357 if (offset
== 0 && to
== PAGE_CACHE_SIZE
) {
358 clear_page_dirty(page
);
359 SetPageUptodate(page
);
361 } else if (err
== -EINTR
|| err
== -EIO
)
362 fuse_invalidate_attr(inode
);
366 static void fuse_release_user_pages(struct fuse_req
*req
, int write
)
370 for (i
= 0; i
< req
->num_pages
; i
++) {
371 struct page
*page
= req
->pages
[i
];
373 set_page_dirty_lock(page
);
378 static int fuse_get_user_pages(struct fuse_req
*req
, const char __user
*buf
,
379 unsigned nbytes
, int write
)
381 unsigned long user_addr
= (unsigned long) buf
;
382 unsigned offset
= user_addr
& ~PAGE_MASK
;
385 /* This doesn't work with nfsd */
389 nbytes
= min(nbytes
, (unsigned) FUSE_MAX_PAGES_PER_REQ
<< PAGE_SHIFT
);
390 npages
= (nbytes
+ offset
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
391 npages
= min(npages
, FUSE_MAX_PAGES_PER_REQ
);
392 down_read(¤t
->mm
->mmap_sem
);
393 npages
= get_user_pages(current
, current
->mm
, user_addr
, npages
, write
,
394 0, req
->pages
, NULL
);
395 up_read(¤t
->mm
->mmap_sem
);
399 req
->num_pages
= npages
;
400 req
->page_offset
= offset
;
404 static ssize_t
fuse_direct_io(struct file
*file
, const char __user
*buf
,
405 size_t count
, loff_t
*ppos
, int write
)
407 struct inode
*inode
= file
->f_dentry
->d_inode
;
408 struct fuse_conn
*fc
= get_fuse_conn(inode
);
409 size_t nmax
= write
? fc
->max_write
: fc
->max_read
;
412 struct fuse_req
*req
= fuse_get_request(fc
);
419 size_t nbytes
= min(count
, nmax
);
420 int err
= fuse_get_user_pages(req
, buf
, nbytes
, !write
);
425 tmp
= (req
->num_pages
<< PAGE_SHIFT
) - req
->page_offset
;
426 nbytes
= min(nbytes
, tmp
);
428 nres
= fuse_send_write(req
, file
, inode
, pos
, nbytes
);
430 nres
= fuse_send_read(req
, file
, inode
, pos
, nbytes
);
431 fuse_release_user_pages(req
, !write
);
432 if (req
->out
.h
.error
) {
434 res
= req
->out
.h
.error
;
436 } else if (nres
> nbytes
) {
447 fuse_reset_request(req
);
449 fuse_put_request(fc
, req
);
451 if (write
&& pos
> i_size_read(inode
))
452 i_size_write(inode
, pos
);
454 } else if (write
&& (res
== -EINTR
|| res
== -EIO
))
455 fuse_invalidate_attr(inode
);
460 static ssize_t
fuse_direct_read(struct file
*file
, char __user
*buf
,
461 size_t count
, loff_t
*ppos
)
463 return fuse_direct_io(file
, buf
, count
, ppos
, 0);
466 static ssize_t
fuse_direct_write(struct file
*file
, const char __user
*buf
,
467 size_t count
, loff_t
*ppos
)
469 struct inode
*inode
= file
->f_dentry
->d_inode
;
471 /* Don't allow parallel writes to the same file */
473 res
= fuse_direct_io(file
, buf
, count
, ppos
, 1);
478 static int fuse_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
480 if ((vma
->vm_flags
& VM_SHARED
)) {
481 if ((vma
->vm_flags
& VM_WRITE
))
484 vma
->vm_flags
&= ~VM_MAYWRITE
;
486 return generic_file_mmap(file
, vma
);
489 static int fuse_set_page_dirty(struct page
*page
)
491 printk("fuse_set_page_dirty: should not happen\n");
496 static struct file_operations fuse_file_operations
= {
497 .llseek
= generic_file_llseek
,
498 .read
= generic_file_read
,
499 .write
= generic_file_write
,
500 .mmap
= fuse_file_mmap
,
503 .release
= fuse_release
,
505 .sendfile
= generic_file_sendfile
,
508 static struct file_operations fuse_direct_io_file_operations
= {
509 .llseek
= generic_file_llseek
,
510 .read
= fuse_direct_read
,
511 .write
= fuse_direct_write
,
514 .release
= fuse_release
,
516 /* no mmap and sendfile */
519 static struct address_space_operations fuse_file_aops
= {
520 .readpage
= fuse_readpage
,
521 .prepare_write
= fuse_prepare_write
,
522 .commit_write
= fuse_commit_write
,
523 .readpages
= fuse_readpages
,
524 .set_page_dirty
= fuse_set_page_dirty
,
527 void fuse_init_file_inode(struct inode
*inode
)
529 struct fuse_conn
*fc
= get_fuse_conn(inode
);
531 if (fc
->flags
& FUSE_DIRECT_IO
)
532 inode
->i_fop
= &fuse_direct_io_file_operations
;
534 inode
->i_fop
= &fuse_file_operations
;
535 inode
->i_data
.a_ops
= &fuse_file_aops
;