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/file.h>
13 #include <linux/gfp.h>
14 #include <linux/sched.h>
15 #include <linux/namei.h>
18 * FUSE caches dentries and attributes with separate timeout. The
19 * time in jiffies until the dentry/attributes are valid is stored in
20 * dentry->d_time and fuse_inode->i_time respectively.
24 * Calculate the time in jiffies until a dentry/attributes are valid
26 static inline unsigned long time_to_jiffies(unsigned long sec
,
29 struct timespec ts
= {sec
, nsec
};
30 return jiffies
+ timespec_to_jiffies(&ts
);
34 * Set dentry and possibly attribute timeouts from the lookup/mk*
37 static void fuse_change_timeout(struct dentry
*entry
, struct fuse_entry_out
*o
)
39 entry
->d_time
= time_to_jiffies(o
->entry_valid
, o
->entry_valid_nsec
);
41 get_fuse_inode(entry
->d_inode
)->i_time
=
42 time_to_jiffies(o
->attr_valid
, o
->attr_valid_nsec
);
46 * Mark the attributes as stale, so that at the next call to
47 * ->getattr() they will be fetched from userspace
49 void fuse_invalidate_attr(struct inode
*inode
)
51 get_fuse_inode(inode
)->i_time
= jiffies
- 1;
55 * Just mark the entry as stale, so that a next attempt to look it up
56 * will result in a new lookup call to userspace
58 * This is called when a dentry is about to become negative and the
59 * timeout is unknown (unlink, rmdir, rename and in some cases
62 static void fuse_invalidate_entry_cache(struct dentry
*entry
)
64 entry
->d_time
= jiffies
- 1;
68 * Same as fuse_invalidate_entry_cache(), but also try to remove the
69 * dentry from the hash
71 static void fuse_invalidate_entry(struct dentry
*entry
)
74 fuse_invalidate_entry_cache(entry
);
77 static void fuse_lookup_init(struct fuse_req
*req
, struct inode
*dir
,
79 struct fuse_entry_out
*outarg
)
81 req
->in
.h
.opcode
= FUSE_LOOKUP
;
82 req
->in
.h
.nodeid
= get_node_id(dir
);
85 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
86 req
->in
.args
[0].value
= entry
->d_name
.name
;
88 req
->out
.args
[0].size
= sizeof(struct fuse_entry_out
);
89 req
->out
.args
[0].value
= outarg
;
93 * Check whether the dentry is still valid
95 * If the entry validity timeout has expired and the dentry is
96 * positive, try to redo the lookup. If the lookup results in a
97 * different inode, then let the VFS invalidate the dentry and redo
98 * the lookup once more. If the lookup results in the same inode,
99 * then refresh the attributes, timeouts and mark the dentry valid.
101 static int fuse_dentry_revalidate(struct dentry
*entry
, struct nameidata
*nd
)
103 struct inode
*inode
= entry
->d_inode
;
105 if (inode
&& is_bad_inode(inode
))
107 else if (time_after(jiffies
, entry
->d_time
)) {
109 struct fuse_entry_out outarg
;
110 struct fuse_conn
*fc
;
111 struct fuse_req
*req
;
113 /* Doesn't hurt to "reset" the validity timeout */
114 fuse_invalidate_entry_cache(entry
);
118 fc
= get_fuse_conn(inode
);
119 req
= fuse_get_request(fc
);
123 fuse_lookup_init(req
, entry
->d_parent
->d_inode
, entry
, &outarg
);
124 request_send(fc
, req
);
125 err
= req
->out
.h
.error
;
127 struct fuse_inode
*fi
= get_fuse_inode(inode
);
128 if (outarg
.nodeid
!= get_node_id(inode
)) {
129 fuse_send_forget(fc
, req
, outarg
.nodeid
, 1);
134 fuse_put_request(fc
, req
);
135 if (err
|| (outarg
.attr
.mode
^ inode
->i_mode
) & S_IFMT
)
138 fuse_change_attributes(inode
, &outarg
.attr
);
139 fuse_change_timeout(entry
, &outarg
);
145 * Check if there's already a hashed alias of this directory inode.
146 * If yes, then lookup and mkdir must not create a new alias.
148 static int dir_alias(struct inode
*inode
)
150 if (S_ISDIR(inode
->i_mode
)) {
151 struct dentry
*alias
= d_find_alias(inode
);
160 static inline int invalid_nodeid(u64 nodeid
)
162 return !nodeid
|| nodeid
== FUSE_ROOT_ID
;
165 static struct dentry_operations fuse_dentry_operations
= {
166 .d_revalidate
= fuse_dentry_revalidate
,
169 static struct dentry
*fuse_lookup(struct inode
*dir
, struct dentry
*entry
,
170 struct nameidata
*nd
)
173 struct fuse_entry_out outarg
;
174 struct inode
*inode
= NULL
;
175 struct fuse_conn
*fc
= get_fuse_conn(dir
);
176 struct fuse_req
*req
;
178 if (entry
->d_name
.len
> FUSE_NAME_MAX
)
179 return ERR_PTR(-ENAMETOOLONG
);
181 req
= fuse_get_request(fc
);
183 return ERR_PTR(-EINTR
);
185 fuse_lookup_init(req
, dir
, entry
, &outarg
);
186 request_send(fc
, req
);
187 err
= req
->out
.h
.error
;
188 if (!err
&& outarg
.nodeid
&& invalid_nodeid(outarg
.nodeid
))
190 if (!err
&& outarg
.nodeid
) {
191 inode
= fuse_iget(dir
->i_sb
, outarg
.nodeid
, outarg
.generation
,
194 fuse_send_forget(fc
, req
, outarg
.nodeid
, 1);
195 return ERR_PTR(-ENOMEM
);
198 fuse_put_request(fc
, req
);
199 if (err
&& err
!= -ENOENT
)
202 if (inode
&& dir_alias(inode
)) {
204 return ERR_PTR(-EIO
);
207 entry
->d_op
= &fuse_dentry_operations
;
209 fuse_change_timeout(entry
, &outarg
);
211 fuse_invalidate_entry_cache(entry
);
216 * Atomic create+open operation
218 * If the filesystem doesn't support this, then fall back to separate
219 * 'mknod' + 'open' requests.
221 static int fuse_create_open(struct inode
*dir
, struct dentry
*entry
, int mode
,
222 struct nameidata
*nd
)
226 struct fuse_conn
*fc
= get_fuse_conn(dir
);
227 struct fuse_req
*req
;
228 struct fuse_open_in inarg
;
229 struct fuse_open_out outopen
;
230 struct fuse_entry_out outentry
;
231 struct fuse_file
*ff
;
233 int flags
= nd
->intent
.open
.flags
- 1;
240 if (entry
->d_name
.len
> FUSE_NAME_MAX
)
244 req
= fuse_get_request(fc
);
248 ff
= fuse_file_alloc();
250 goto out_put_request
;
253 memset(&inarg
, 0, sizeof(inarg
));
256 req
->in
.h
.opcode
= FUSE_CREATE
;
257 req
->in
.h
.nodeid
= get_node_id(dir
);
260 req
->in
.args
[0].size
= sizeof(inarg
);
261 req
->in
.args
[0].value
= &inarg
;
262 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
263 req
->in
.args
[1].value
= entry
->d_name
.name
;
264 req
->out
.numargs
= 2;
265 req
->out
.args
[0].size
= sizeof(outentry
);
266 req
->out
.args
[0].value
= &outentry
;
267 req
->out
.args
[1].size
= sizeof(outopen
);
268 req
->out
.args
[1].value
= &outopen
;
269 request_send(fc
, req
);
270 err
= req
->out
.h
.error
;
278 if (!S_ISREG(outentry
.attr
.mode
) || invalid_nodeid(outentry
.nodeid
))
281 inode
= fuse_iget(dir
->i_sb
, outentry
.nodeid
, outentry
.generation
,
285 flags
&= ~(O_CREAT
| O_EXCL
| O_TRUNC
);
287 /* Special release, with inode = NULL, this will
288 trigger a 'forget' request when the release is
290 fuse_send_release(fc
, ff
, outentry
.nodeid
, NULL
, flags
, 0);
291 goto out_put_request
;
293 fuse_put_request(fc
, req
);
294 d_instantiate(entry
, inode
);
295 fuse_change_timeout(entry
, &outentry
);
296 file
= lookup_instantiate_filp(nd
, entry
, generic_file_open
);
299 fuse_send_release(fc
, ff
, outentry
.nodeid
, inode
, flags
, 0);
300 return PTR_ERR(file
);
302 fuse_finish_open(inode
, file
, ff
, &outopen
);
308 fuse_put_request(fc
, req
);
314 * Code shared between mknod, mkdir, symlink and link
316 static int create_new_entry(struct fuse_conn
*fc
, struct fuse_req
*req
,
317 struct inode
*dir
, struct dentry
*entry
,
320 struct fuse_entry_out outarg
;
324 req
->in
.h
.nodeid
= get_node_id(dir
);
326 req
->out
.numargs
= 1;
327 req
->out
.args
[0].size
= sizeof(outarg
);
328 req
->out
.args
[0].value
= &outarg
;
329 request_send(fc
, req
);
330 err
= req
->out
.h
.error
;
332 fuse_put_request(fc
, req
);
335 if (invalid_nodeid(outarg
.nodeid
)) {
336 fuse_put_request(fc
, req
);
339 inode
= fuse_iget(dir
->i_sb
, outarg
.nodeid
, outarg
.generation
,
342 fuse_send_forget(fc
, req
, outarg
.nodeid
, 1);
345 fuse_put_request(fc
, req
);
347 /* Don't allow userspace to do really stupid things... */
348 if (((inode
->i_mode
^ mode
) & S_IFMT
) || dir_alias(inode
)) {
353 d_instantiate(entry
, inode
);
354 fuse_change_timeout(entry
, &outarg
);
355 fuse_invalidate_attr(dir
);
359 static int fuse_mknod(struct inode
*dir
, struct dentry
*entry
, int mode
,
362 struct fuse_mknod_in inarg
;
363 struct fuse_conn
*fc
= get_fuse_conn(dir
);
364 struct fuse_req
*req
= fuse_get_request(fc
);
368 memset(&inarg
, 0, sizeof(inarg
));
370 inarg
.rdev
= new_encode_dev(rdev
);
371 req
->in
.h
.opcode
= FUSE_MKNOD
;
373 req
->in
.args
[0].size
= sizeof(inarg
);
374 req
->in
.args
[0].value
= &inarg
;
375 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
376 req
->in
.args
[1].value
= entry
->d_name
.name
;
377 return create_new_entry(fc
, req
, dir
, entry
, mode
);
380 static int fuse_create(struct inode
*dir
, struct dentry
*entry
, int mode
,
381 struct nameidata
*nd
)
383 if (nd
&& (nd
->flags
& LOOKUP_CREATE
)) {
384 int err
= fuse_create_open(dir
, entry
, mode
, nd
);
387 /* Fall back on mknod */
389 return fuse_mknod(dir
, entry
, mode
, 0);
392 static int fuse_mkdir(struct inode
*dir
, struct dentry
*entry
, int mode
)
394 struct fuse_mkdir_in inarg
;
395 struct fuse_conn
*fc
= get_fuse_conn(dir
);
396 struct fuse_req
*req
= fuse_get_request(fc
);
400 memset(&inarg
, 0, sizeof(inarg
));
402 req
->in
.h
.opcode
= FUSE_MKDIR
;
404 req
->in
.args
[0].size
= sizeof(inarg
);
405 req
->in
.args
[0].value
= &inarg
;
406 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
407 req
->in
.args
[1].value
= entry
->d_name
.name
;
408 return create_new_entry(fc
, req
, dir
, entry
, S_IFDIR
);
411 static int fuse_symlink(struct inode
*dir
, struct dentry
*entry
,
414 struct fuse_conn
*fc
= get_fuse_conn(dir
);
415 unsigned len
= strlen(link
) + 1;
416 struct fuse_req
*req
;
418 if (len
> FUSE_SYMLINK_MAX
)
419 return -ENAMETOOLONG
;
421 req
= fuse_get_request(fc
);
425 req
->in
.h
.opcode
= FUSE_SYMLINK
;
427 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
428 req
->in
.args
[0].value
= entry
->d_name
.name
;
429 req
->in
.args
[1].size
= len
;
430 req
->in
.args
[1].value
= link
;
431 return create_new_entry(fc
, req
, dir
, entry
, S_IFLNK
);
434 static int fuse_unlink(struct inode
*dir
, struct dentry
*entry
)
437 struct fuse_conn
*fc
= get_fuse_conn(dir
);
438 struct fuse_req
*req
= fuse_get_request(fc
);
442 req
->in
.h
.opcode
= FUSE_UNLINK
;
443 req
->in
.h
.nodeid
= get_node_id(dir
);
446 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
447 req
->in
.args
[0].value
= entry
->d_name
.name
;
448 request_send(fc
, req
);
449 err
= req
->out
.h
.error
;
450 fuse_put_request(fc
, req
);
452 struct inode
*inode
= entry
->d_inode
;
454 /* Set nlink to zero so the inode can be cleared, if
455 the inode does have more links this will be
456 discovered at the next lookup/getattr */
458 fuse_invalidate_attr(inode
);
459 fuse_invalidate_attr(dir
);
460 fuse_invalidate_entry_cache(entry
);
461 } else if (err
== -EINTR
)
462 fuse_invalidate_entry(entry
);
466 static int fuse_rmdir(struct inode
*dir
, struct dentry
*entry
)
469 struct fuse_conn
*fc
= get_fuse_conn(dir
);
470 struct fuse_req
*req
= fuse_get_request(fc
);
474 req
->in
.h
.opcode
= FUSE_RMDIR
;
475 req
->in
.h
.nodeid
= get_node_id(dir
);
478 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
479 req
->in
.args
[0].value
= entry
->d_name
.name
;
480 request_send(fc
, req
);
481 err
= req
->out
.h
.error
;
482 fuse_put_request(fc
, req
);
484 entry
->d_inode
->i_nlink
= 0;
485 fuse_invalidate_attr(dir
);
486 fuse_invalidate_entry_cache(entry
);
487 } else if (err
== -EINTR
)
488 fuse_invalidate_entry(entry
);
492 static int fuse_rename(struct inode
*olddir
, struct dentry
*oldent
,
493 struct inode
*newdir
, struct dentry
*newent
)
496 struct fuse_rename_in inarg
;
497 struct fuse_conn
*fc
= get_fuse_conn(olddir
);
498 struct fuse_req
*req
= fuse_get_request(fc
);
502 memset(&inarg
, 0, sizeof(inarg
));
503 inarg
.newdir
= get_node_id(newdir
);
504 req
->in
.h
.opcode
= FUSE_RENAME
;
505 req
->in
.h
.nodeid
= get_node_id(olddir
);
507 req
->inode2
= newdir
;
509 req
->in
.args
[0].size
= sizeof(inarg
);
510 req
->in
.args
[0].value
= &inarg
;
511 req
->in
.args
[1].size
= oldent
->d_name
.len
+ 1;
512 req
->in
.args
[1].value
= oldent
->d_name
.name
;
513 req
->in
.args
[2].size
= newent
->d_name
.len
+ 1;
514 req
->in
.args
[2].value
= newent
->d_name
.name
;
515 request_send(fc
, req
);
516 err
= req
->out
.h
.error
;
517 fuse_put_request(fc
, req
);
519 fuse_invalidate_attr(olddir
);
520 if (olddir
!= newdir
)
521 fuse_invalidate_attr(newdir
);
523 /* newent will end up negative */
525 fuse_invalidate_entry_cache(newent
);
526 } else if (err
== -EINTR
) {
527 /* If request was interrupted, DEITY only knows if the
528 rename actually took place. If the invalidation
529 fails (e.g. some process has CWD under the renamed
530 directory), then there can be inconsistency between
531 the dcache and the real filesystem. Tough luck. */
532 fuse_invalidate_entry(oldent
);
534 fuse_invalidate_entry(newent
);
540 static int fuse_link(struct dentry
*entry
, struct inode
*newdir
,
541 struct dentry
*newent
)
544 struct fuse_link_in inarg
;
545 struct inode
*inode
= entry
->d_inode
;
546 struct fuse_conn
*fc
= get_fuse_conn(inode
);
547 struct fuse_req
*req
= fuse_get_request(fc
);
551 memset(&inarg
, 0, sizeof(inarg
));
552 inarg
.oldnodeid
= get_node_id(inode
);
553 req
->in
.h
.opcode
= FUSE_LINK
;
556 req
->in
.args
[0].size
= sizeof(inarg
);
557 req
->in
.args
[0].value
= &inarg
;
558 req
->in
.args
[1].size
= newent
->d_name
.len
+ 1;
559 req
->in
.args
[1].value
= newent
->d_name
.name
;
560 err
= create_new_entry(fc
, req
, newdir
, newent
, inode
->i_mode
);
561 /* Contrary to "normal" filesystems it can happen that link
562 makes two "logical" inodes point to the same "physical"
563 inode. We invalidate the attributes of the old one, so it
564 will reflect changes in the backing inode (link count,
567 if (!err
|| err
== -EINTR
)
568 fuse_invalidate_attr(inode
);
572 int fuse_do_getattr(struct inode
*inode
)
575 struct fuse_attr_out arg
;
576 struct fuse_conn
*fc
= get_fuse_conn(inode
);
577 struct fuse_req
*req
= fuse_get_request(fc
);
581 req
->in
.h
.opcode
= FUSE_GETATTR
;
582 req
->in
.h
.nodeid
= get_node_id(inode
);
584 req
->out
.numargs
= 1;
585 req
->out
.args
[0].size
= sizeof(arg
);
586 req
->out
.args
[0].value
= &arg
;
587 request_send(fc
, req
);
588 err
= req
->out
.h
.error
;
589 fuse_put_request(fc
, req
);
591 if ((inode
->i_mode
^ arg
.attr
.mode
) & S_IFMT
) {
592 make_bad_inode(inode
);
595 struct fuse_inode
*fi
= get_fuse_inode(inode
);
596 fuse_change_attributes(inode
, &arg
.attr
);
597 fi
->i_time
= time_to_jiffies(arg
.attr_valid
,
598 arg
.attr_valid_nsec
);
605 * Calling into a user-controlled filesystem gives the filesystem
606 * daemon ptrace-like capabilities over the requester process. This
607 * means, that the filesystem daemon is able to record the exact
608 * filesystem operations performed, and can also control the behavior
609 * of the requester process in otherwise impossible ways. For example
610 * it can delay the operation for arbitrary length of time allowing
611 * DoS against the requester.
613 * For this reason only those processes can call into the filesystem,
614 * for which the owner of the mount has ptrace privilege. This
615 * excludes processes started by other users, suid or sgid processes.
617 static int fuse_allow_task(struct fuse_conn
*fc
, struct task_struct
*task
)
619 if (fc
->flags
& FUSE_ALLOW_OTHER
)
622 if (task
->euid
== fc
->user_id
&&
623 task
->suid
== fc
->user_id
&&
624 task
->uid
== fc
->user_id
&&
625 task
->egid
== fc
->group_id
&&
626 task
->sgid
== fc
->group_id
&&
627 task
->gid
== fc
->group_id
)
634 * Check whether the inode attributes are still valid
636 * If the attribute validity timeout has expired, then fetch the fresh
637 * attributes with a 'getattr' request
639 * I'm not sure why cached attributes are never returned for the root
640 * inode, this is probably being too cautious.
642 static int fuse_revalidate(struct dentry
*entry
)
644 struct inode
*inode
= entry
->d_inode
;
645 struct fuse_inode
*fi
= get_fuse_inode(inode
);
646 struct fuse_conn
*fc
= get_fuse_conn(inode
);
648 if (!fuse_allow_task(fc
, current
))
650 if (get_node_id(inode
) != FUSE_ROOT_ID
&&
651 time_before_eq(jiffies
, fi
->i_time
))
654 return fuse_do_getattr(inode
);
657 static int fuse_access(struct inode
*inode
, int mask
)
659 struct fuse_conn
*fc
= get_fuse_conn(inode
);
660 struct fuse_req
*req
;
661 struct fuse_access_in inarg
;
667 req
= fuse_get_request(fc
);
671 memset(&inarg
, 0, sizeof(inarg
));
673 req
->in
.h
.opcode
= FUSE_ACCESS
;
674 req
->in
.h
.nodeid
= get_node_id(inode
);
677 req
->in
.args
[0].size
= sizeof(inarg
);
678 req
->in
.args
[0].value
= &inarg
;
679 request_send(fc
, req
);
680 err
= req
->out
.h
.error
;
681 fuse_put_request(fc
, req
);
682 if (err
== -ENOSYS
) {
690 * Check permission. The two basic access models of FUSE are:
692 * 1) Local access checking ('default_permissions' mount option) based
693 * on file mode. This is the plain old disk filesystem permission
696 * 2) "Remote" access checking, where server is responsible for
697 * checking permission in each inode operation. An exception to this
698 * is if ->permission() was invoked from sys_access() in which case an
699 * access request is sent. Execute permission is still checked
700 * locally based on file mode.
702 static int fuse_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
704 struct fuse_conn
*fc
= get_fuse_conn(inode
);
706 if (!fuse_allow_task(fc
, current
))
708 else if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
709 int err
= generic_permission(inode
, mask
, NULL
);
711 /* If permission is denied, try to refresh file
712 attributes. This is also needed, because the root
713 node will at first have no permissions */
714 if (err
== -EACCES
) {
715 err
= fuse_do_getattr(inode
);
717 err
= generic_permission(inode
, mask
, NULL
);
720 /* Note: the opposite of the above test does not
721 exist. So if permissions are revoked this won't be
722 noticed immediately, only after the attribute
723 timeout has expired */
727 int mode
= inode
->i_mode
;
728 if ((mask
& MAY_EXEC
) && !S_ISDIR(mode
) && !(mode
& S_IXUGO
))
731 if (nd
&& (nd
->flags
& LOOKUP_ACCESS
))
732 return fuse_access(inode
, mask
);
737 static int parse_dirfile(char *buf
, size_t nbytes
, struct file
*file
,
738 void *dstbuf
, filldir_t filldir
)
740 while (nbytes
>= FUSE_NAME_OFFSET
) {
741 struct fuse_dirent
*dirent
= (struct fuse_dirent
*) buf
;
742 size_t reclen
= FUSE_DIRENT_SIZE(dirent
);
744 if (!dirent
->namelen
|| dirent
->namelen
> FUSE_NAME_MAX
)
749 over
= filldir(dstbuf
, dirent
->name
, dirent
->namelen
,
750 file
->f_pos
, dirent
->ino
, dirent
->type
);
756 file
->f_pos
= dirent
->off
;
762 static inline size_t fuse_send_readdir(struct fuse_req
*req
, struct file
*file
,
763 struct inode
*inode
, loff_t pos
,
766 return fuse_send_read_common(req
, file
, inode
, pos
, count
, 1);
769 static int fuse_readdir(struct file
*file
, void *dstbuf
, filldir_t filldir
)
774 struct inode
*inode
= file
->f_dentry
->d_inode
;
775 struct fuse_conn
*fc
= get_fuse_conn(inode
);
776 struct fuse_req
*req
;
778 if (is_bad_inode(inode
))
781 req
= fuse_get_request(fc
);
785 page
= alloc_page(GFP_KERNEL
);
787 fuse_put_request(fc
, req
);
791 req
->pages
[0] = page
;
792 nbytes
= fuse_send_readdir(req
, file
, inode
, file
->f_pos
, PAGE_SIZE
);
793 err
= req
->out
.h
.error
;
794 fuse_put_request(fc
, req
);
796 err
= parse_dirfile(page_address(page
), nbytes
, file
, dstbuf
,
800 fuse_invalidate_attr(inode
); /* atime changed */
804 static char *read_link(struct dentry
*dentry
)
806 struct inode
*inode
= dentry
->d_inode
;
807 struct fuse_conn
*fc
= get_fuse_conn(inode
);
808 struct fuse_req
*req
= fuse_get_request(fc
);
812 return ERR_PTR(-EINTR
);
814 link
= (char *) __get_free_page(GFP_KERNEL
);
816 link
= ERR_PTR(-ENOMEM
);
819 req
->in
.h
.opcode
= FUSE_READLINK
;
820 req
->in
.h
.nodeid
= get_node_id(inode
);
823 req
->out
.numargs
= 1;
824 req
->out
.args
[0].size
= PAGE_SIZE
- 1;
825 req
->out
.args
[0].value
= link
;
826 request_send(fc
, req
);
827 if (req
->out
.h
.error
) {
828 free_page((unsigned long) link
);
829 link
= ERR_PTR(req
->out
.h
.error
);
831 link
[req
->out
.args
[0].size
] = '\0';
833 fuse_put_request(fc
, req
);
834 fuse_invalidate_attr(inode
); /* atime changed */
838 static void free_link(char *link
)
841 free_page((unsigned long) link
);
844 static void *fuse_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
846 nd_set_link(nd
, read_link(dentry
));
850 static void fuse_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *c
)
852 free_link(nd_get_link(nd
));
855 static int fuse_dir_open(struct inode
*inode
, struct file
*file
)
857 return fuse_open_common(inode
, file
, 1);
860 static int fuse_dir_release(struct inode
*inode
, struct file
*file
)
862 return fuse_release_common(inode
, file
, 1);
865 static int fuse_dir_fsync(struct file
*file
, struct dentry
*de
, int datasync
)
867 /* nfsd can call this with no file */
868 return file
? fuse_fsync_common(file
, de
, datasync
, 1) : 0;
871 static void iattr_to_fattr(struct iattr
*iattr
, struct fuse_setattr_in
*arg
)
873 unsigned ivalid
= iattr
->ia_valid
;
875 if (ivalid
& ATTR_MODE
)
876 arg
->valid
|= FATTR_MODE
, arg
->mode
= iattr
->ia_mode
;
877 if (ivalid
& ATTR_UID
)
878 arg
->valid
|= FATTR_UID
, arg
->uid
= iattr
->ia_uid
;
879 if (ivalid
& ATTR_GID
)
880 arg
->valid
|= FATTR_GID
, arg
->gid
= iattr
->ia_gid
;
881 if (ivalid
& ATTR_SIZE
)
882 arg
->valid
|= FATTR_SIZE
, arg
->size
= iattr
->ia_size
;
883 /* You can only _set_ these together (they may change by themselves) */
884 if ((ivalid
& (ATTR_ATIME
| ATTR_MTIME
)) == (ATTR_ATIME
| ATTR_MTIME
)) {
885 arg
->valid
|= FATTR_ATIME
| FATTR_MTIME
;
886 arg
->atime
= iattr
->ia_atime
.tv_sec
;
887 arg
->mtime
= iattr
->ia_mtime
.tv_sec
;
889 if (ivalid
& ATTR_FILE
) {
890 struct fuse_file
*ff
= iattr
->ia_file
->private_data
;
891 arg
->valid
|= FATTR_FH
;
897 * Set attributes, and at the same time refresh them.
899 * Truncation is slightly complicated, because the 'truncate' request
900 * may fail, in which case we don't want to touch the mapping.
901 * vmtruncate() doesn't allow for this case. So do the rlimit
902 * checking by hand and call vmtruncate() only after the file has
903 * actually been truncated.
905 static int fuse_setattr(struct dentry
*entry
, struct iattr
*attr
)
907 struct inode
*inode
= entry
->d_inode
;
908 struct fuse_conn
*fc
= get_fuse_conn(inode
);
909 struct fuse_inode
*fi
= get_fuse_inode(inode
);
910 struct fuse_req
*req
;
911 struct fuse_setattr_in inarg
;
912 struct fuse_attr_out outarg
;
916 if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
917 err
= inode_change_ok(inode
, attr
);
922 if (attr
->ia_valid
& ATTR_SIZE
) {
925 limit
= current
->signal
->rlim
[RLIMIT_FSIZE
].rlim_cur
;
926 if (limit
!= RLIM_INFINITY
&& attr
->ia_size
> (loff_t
) limit
) {
927 send_sig(SIGXFSZ
, current
, 0);
932 req
= fuse_get_request(fc
);
936 memset(&inarg
, 0, sizeof(inarg
));
937 iattr_to_fattr(attr
, &inarg
);
938 req
->in
.h
.opcode
= FUSE_SETATTR
;
939 req
->in
.h
.nodeid
= get_node_id(inode
);
942 req
->in
.args
[0].size
= sizeof(inarg
);
943 req
->in
.args
[0].value
= &inarg
;
944 req
->out
.numargs
= 1;
945 req
->out
.args
[0].size
= sizeof(outarg
);
946 req
->out
.args
[0].value
= &outarg
;
947 request_send(fc
, req
);
948 err
= req
->out
.h
.error
;
949 fuse_put_request(fc
, req
);
951 if ((inode
->i_mode
^ outarg
.attr
.mode
) & S_IFMT
) {
952 make_bad_inode(inode
);
956 loff_t origsize
= i_size_read(inode
);
957 i_size_write(inode
, outarg
.attr
.size
);
958 if (origsize
> outarg
.attr
.size
)
959 vmtruncate(inode
, outarg
.attr
.size
);
961 fuse_change_attributes(inode
, &outarg
.attr
);
962 fi
->i_time
= time_to_jiffies(outarg
.attr_valid
,
963 outarg
.attr_valid_nsec
);
965 } else if (err
== -EINTR
)
966 fuse_invalidate_attr(inode
);
971 static int fuse_getattr(struct vfsmount
*mnt
, struct dentry
*entry
,
974 struct inode
*inode
= entry
->d_inode
;
975 int err
= fuse_revalidate(entry
);
977 generic_fillattr(inode
, stat
);
982 static int fuse_setxattr(struct dentry
*entry
, const char *name
,
983 const void *value
, size_t size
, int flags
)
985 struct inode
*inode
= entry
->d_inode
;
986 struct fuse_conn
*fc
= get_fuse_conn(inode
);
987 struct fuse_req
*req
;
988 struct fuse_setxattr_in inarg
;
991 if (size
> FUSE_XATTR_SIZE_MAX
)
997 req
= fuse_get_request(fc
);
1001 memset(&inarg
, 0, sizeof(inarg
));
1003 inarg
.flags
= flags
;
1004 req
->in
.h
.opcode
= FUSE_SETXATTR
;
1005 req
->in
.h
.nodeid
= get_node_id(inode
);
1007 req
->in
.numargs
= 3;
1008 req
->in
.args
[0].size
= sizeof(inarg
);
1009 req
->in
.args
[0].value
= &inarg
;
1010 req
->in
.args
[1].size
= strlen(name
) + 1;
1011 req
->in
.args
[1].value
= name
;
1012 req
->in
.args
[2].size
= size
;
1013 req
->in
.args
[2].value
= value
;
1014 request_send(fc
, req
);
1015 err
= req
->out
.h
.error
;
1016 fuse_put_request(fc
, req
);
1017 if (err
== -ENOSYS
) {
1018 fc
->no_setxattr
= 1;
1024 static ssize_t
fuse_getxattr(struct dentry
*entry
, const char *name
,
1025 void *value
, size_t size
)
1027 struct inode
*inode
= entry
->d_inode
;
1028 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1029 struct fuse_req
*req
;
1030 struct fuse_getxattr_in inarg
;
1031 struct fuse_getxattr_out outarg
;
1034 if (fc
->no_getxattr
)
1037 req
= fuse_get_request(fc
);
1041 memset(&inarg
, 0, sizeof(inarg
));
1043 req
->in
.h
.opcode
= FUSE_GETXATTR
;
1044 req
->in
.h
.nodeid
= get_node_id(inode
);
1046 req
->in
.numargs
= 2;
1047 req
->in
.args
[0].size
= sizeof(inarg
);
1048 req
->in
.args
[0].value
= &inarg
;
1049 req
->in
.args
[1].size
= strlen(name
) + 1;
1050 req
->in
.args
[1].value
= name
;
1051 /* This is really two different operations rolled into one */
1052 req
->out
.numargs
= 1;
1054 req
->out
.argvar
= 1;
1055 req
->out
.args
[0].size
= size
;
1056 req
->out
.args
[0].value
= value
;
1058 req
->out
.args
[0].size
= sizeof(outarg
);
1059 req
->out
.args
[0].value
= &outarg
;
1061 request_send(fc
, req
);
1062 ret
= req
->out
.h
.error
;
1064 ret
= size
? req
->out
.args
[0].size
: outarg
.size
;
1066 if (ret
== -ENOSYS
) {
1067 fc
->no_getxattr
= 1;
1071 fuse_put_request(fc
, req
);
1075 static ssize_t
fuse_listxattr(struct dentry
*entry
, char *list
, size_t size
)
1077 struct inode
*inode
= entry
->d_inode
;
1078 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1079 struct fuse_req
*req
;
1080 struct fuse_getxattr_in inarg
;
1081 struct fuse_getxattr_out outarg
;
1084 if (fc
->no_listxattr
)
1087 req
= fuse_get_request(fc
);
1091 memset(&inarg
, 0, sizeof(inarg
));
1093 req
->in
.h
.opcode
= FUSE_LISTXATTR
;
1094 req
->in
.h
.nodeid
= get_node_id(inode
);
1096 req
->in
.numargs
= 1;
1097 req
->in
.args
[0].size
= sizeof(inarg
);
1098 req
->in
.args
[0].value
= &inarg
;
1099 /* This is really two different operations rolled into one */
1100 req
->out
.numargs
= 1;
1102 req
->out
.argvar
= 1;
1103 req
->out
.args
[0].size
= size
;
1104 req
->out
.args
[0].value
= list
;
1106 req
->out
.args
[0].size
= sizeof(outarg
);
1107 req
->out
.args
[0].value
= &outarg
;
1109 request_send(fc
, req
);
1110 ret
= req
->out
.h
.error
;
1112 ret
= size
? req
->out
.args
[0].size
: outarg
.size
;
1114 if (ret
== -ENOSYS
) {
1115 fc
->no_listxattr
= 1;
1119 fuse_put_request(fc
, req
);
1123 static int fuse_removexattr(struct dentry
*entry
, const char *name
)
1125 struct inode
*inode
= entry
->d_inode
;
1126 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1127 struct fuse_req
*req
;
1130 if (fc
->no_removexattr
)
1133 req
= fuse_get_request(fc
);
1137 req
->in
.h
.opcode
= FUSE_REMOVEXATTR
;
1138 req
->in
.h
.nodeid
= get_node_id(inode
);
1140 req
->in
.numargs
= 1;
1141 req
->in
.args
[0].size
= strlen(name
) + 1;
1142 req
->in
.args
[0].value
= name
;
1143 request_send(fc
, req
);
1144 err
= req
->out
.h
.error
;
1145 fuse_put_request(fc
, req
);
1146 if (err
== -ENOSYS
) {
1147 fc
->no_removexattr
= 1;
1153 static struct inode_operations fuse_dir_inode_operations
= {
1154 .lookup
= fuse_lookup
,
1155 .mkdir
= fuse_mkdir
,
1156 .symlink
= fuse_symlink
,
1157 .unlink
= fuse_unlink
,
1158 .rmdir
= fuse_rmdir
,
1159 .rename
= fuse_rename
,
1161 .setattr
= fuse_setattr
,
1162 .create
= fuse_create
,
1163 .mknod
= fuse_mknod
,
1164 .permission
= fuse_permission
,
1165 .getattr
= fuse_getattr
,
1166 .setxattr
= fuse_setxattr
,
1167 .getxattr
= fuse_getxattr
,
1168 .listxattr
= fuse_listxattr
,
1169 .removexattr
= fuse_removexattr
,
1172 static struct file_operations fuse_dir_operations
= {
1173 .llseek
= generic_file_llseek
,
1174 .read
= generic_read_dir
,
1175 .readdir
= fuse_readdir
,
1176 .open
= fuse_dir_open
,
1177 .release
= fuse_dir_release
,
1178 .fsync
= fuse_dir_fsync
,
1181 static struct inode_operations fuse_common_inode_operations
= {
1182 .setattr
= fuse_setattr
,
1183 .permission
= fuse_permission
,
1184 .getattr
= fuse_getattr
,
1185 .setxattr
= fuse_setxattr
,
1186 .getxattr
= fuse_getxattr
,
1187 .listxattr
= fuse_listxattr
,
1188 .removexattr
= fuse_removexattr
,
1191 static struct inode_operations fuse_symlink_inode_operations
= {
1192 .setattr
= fuse_setattr
,
1193 .follow_link
= fuse_follow_link
,
1194 .put_link
= fuse_put_link
,
1195 .readlink
= generic_readlink
,
1196 .getattr
= fuse_getattr
,
1197 .setxattr
= fuse_setxattr
,
1198 .getxattr
= fuse_getxattr
,
1199 .listxattr
= fuse_listxattr
,
1200 .removexattr
= fuse_removexattr
,
1203 void fuse_init_common(struct inode
*inode
)
1205 inode
->i_op
= &fuse_common_inode_operations
;
1208 void fuse_init_dir(struct inode
*inode
)
1210 inode
->i_op
= &fuse_dir_inode_operations
;
1211 inode
->i_fop
= &fuse_dir_operations
;
1214 void fuse_init_symlink(struct inode
*inode
)
1216 inode
->i_op
= &fuse_symlink_inode_operations
;