2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2006 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>
17 #if BITS_PER_LONG >= 64
18 static inline void fuse_dentry_settime(struct dentry
*entry
, u64 time
)
23 static inline u64
fuse_dentry_time(struct dentry
*entry
)
29 * On 32 bit archs store the high 32 bits of time in d_fsdata
31 static void fuse_dentry_settime(struct dentry
*entry
, u64 time
)
34 entry
->d_fsdata
= (void *) (unsigned long) (time
>> 32);
37 static u64
fuse_dentry_time(struct dentry
*entry
)
39 return (u64
) entry
->d_time
+
40 ((u64
) (unsigned long) entry
->d_fsdata
<< 32);
45 * FUSE caches dentries and attributes with separate timeout. The
46 * time in jiffies until the dentry/attributes are valid is stored in
47 * dentry->d_time and fuse_inode->i_time respectively.
51 * Calculate the time in jiffies until a dentry/attributes are valid
53 static u64
time_to_jiffies(unsigned long sec
, unsigned long nsec
)
56 struct timespec ts
= {sec
, nsec
};
57 return get_jiffies_64() + timespec_to_jiffies(&ts
);
63 * Set dentry and possibly attribute timeouts from the lookup/mk*
66 static void fuse_change_entry_timeout(struct dentry
*entry
,
67 struct fuse_entry_out
*o
)
69 fuse_dentry_settime(entry
,
70 time_to_jiffies(o
->entry_valid
, o
->entry_valid_nsec
));
73 static u64
attr_timeout(struct fuse_attr_out
*o
)
75 return time_to_jiffies(o
->attr_valid
, o
->attr_valid_nsec
);
78 static u64
entry_attr_timeout(struct fuse_entry_out
*o
)
80 return time_to_jiffies(o
->attr_valid
, o
->attr_valid_nsec
);
84 * Mark the attributes as stale, so that at the next call to
85 * ->getattr() they will be fetched from userspace
87 void fuse_invalidate_attr(struct inode
*inode
)
89 get_fuse_inode(inode
)->i_time
= 0;
93 * Just mark the entry as stale, so that a next attempt to look it up
94 * will result in a new lookup call to userspace
96 * This is called when a dentry is about to become negative and the
97 * timeout is unknown (unlink, rmdir, rename and in some cases
100 void fuse_invalidate_entry_cache(struct dentry
*entry
)
102 fuse_dentry_settime(entry
, 0);
106 * Same as fuse_invalidate_entry_cache(), but also try to remove the
107 * dentry from the hash
109 static void fuse_invalidate_entry(struct dentry
*entry
)
112 fuse_invalidate_entry_cache(entry
);
115 static void fuse_lookup_init(struct fuse_conn
*fc
, struct fuse_req
*req
,
116 u64 nodeid
, struct qstr
*name
,
117 struct fuse_entry_out
*outarg
)
119 memset(outarg
, 0, sizeof(struct fuse_entry_out
));
120 req
->in
.h
.opcode
= FUSE_LOOKUP
;
121 req
->in
.h
.nodeid
= nodeid
;
123 req
->in
.args
[0].size
= name
->len
+ 1;
124 req
->in
.args
[0].value
= name
->name
;
125 req
->out
.numargs
= 1;
127 req
->out
.args
[0].size
= FUSE_COMPAT_ENTRY_OUT_SIZE
;
129 req
->out
.args
[0].size
= sizeof(struct fuse_entry_out
);
130 req
->out
.args
[0].value
= outarg
;
133 u64
fuse_get_attr_version(struct fuse_conn
*fc
)
138 * The spin lock isn't actually needed on 64bit archs, but we
139 * don't yet care too much about such optimizations.
141 spin_lock(&fc
->lock
);
142 curr_version
= fc
->attr_version
;
143 spin_unlock(&fc
->lock
);
149 * Check whether the dentry is still valid
151 * If the entry validity timeout has expired and the dentry is
152 * positive, try to redo the lookup. If the lookup results in a
153 * different inode, then let the VFS invalidate the dentry and redo
154 * the lookup once more. If the lookup results in the same inode,
155 * then refresh the attributes, timeouts and mark the dentry valid.
157 static int fuse_dentry_revalidate(struct dentry
*entry
, struct nameidata
*nd
)
159 struct inode
*inode
= entry
->d_inode
;
161 if (inode
&& is_bad_inode(inode
))
163 else if (fuse_dentry_time(entry
) < get_jiffies_64()) {
165 struct fuse_entry_out outarg
;
166 struct fuse_conn
*fc
;
167 struct fuse_req
*req
;
168 struct fuse_req
*forget_req
;
169 struct dentry
*parent
;
172 /* For negative dentries, always do a fresh lookup */
176 fc
= get_fuse_conn(inode
);
177 req
= fuse_get_req(fc
);
181 forget_req
= fuse_get_req(fc
);
182 if (IS_ERR(forget_req
)) {
183 fuse_put_request(fc
, req
);
187 attr_version
= fuse_get_attr_version(fc
);
189 parent
= dget_parent(entry
);
190 fuse_lookup_init(fc
, req
, get_node_id(parent
->d_inode
),
191 &entry
->d_name
, &outarg
);
192 request_send(fc
, req
);
194 err
= req
->out
.h
.error
;
195 fuse_put_request(fc
, req
);
196 /* Zero nodeid is same as -ENOENT */
197 if (!err
&& !outarg
.nodeid
)
200 struct fuse_inode
*fi
= get_fuse_inode(inode
);
201 if (outarg
.nodeid
!= get_node_id(inode
)) {
202 fuse_send_forget(fc
, forget_req
,
206 spin_lock(&fc
->lock
);
208 spin_unlock(&fc
->lock
);
210 fuse_put_request(fc
, forget_req
);
211 if (err
|| (outarg
.attr
.mode
^ inode
->i_mode
) & S_IFMT
)
214 fuse_change_attributes(inode
, &outarg
.attr
,
215 entry_attr_timeout(&outarg
),
217 fuse_change_entry_timeout(entry
, &outarg
);
222 static int invalid_nodeid(u64 nodeid
)
224 return !nodeid
|| nodeid
== FUSE_ROOT_ID
;
227 struct dentry_operations fuse_dentry_operations
= {
228 .d_revalidate
= fuse_dentry_revalidate
,
231 int fuse_valid_type(int m
)
233 return S_ISREG(m
) || S_ISDIR(m
) || S_ISLNK(m
) || S_ISCHR(m
) ||
234 S_ISBLK(m
) || S_ISFIFO(m
) || S_ISSOCK(m
);
238 * Add a directory inode to a dentry, ensuring that no other dentry
239 * refers to this inode. Called with fc->inst_mutex.
241 static struct dentry
*fuse_d_add_directory(struct dentry
*entry
,
244 struct dentry
*alias
= d_find_alias(inode
);
245 if (alias
&& !(alias
->d_flags
& DCACHE_DISCONNECTED
)) {
246 /* This tries to shrink the subtree below alias */
247 fuse_invalidate_entry(alias
);
249 if (!list_empty(&inode
->i_dentry
))
250 return ERR_PTR(-EBUSY
);
254 return d_splice_alias(inode
, entry
);
257 int fuse_lookup_name(struct super_block
*sb
, u64 nodeid
, struct qstr
*name
,
258 struct fuse_entry_out
*outarg
, struct inode
**inode
)
260 struct fuse_conn
*fc
= get_fuse_conn_super(sb
);
261 struct fuse_req
*req
;
262 struct fuse_req
*forget_req
;
268 if (name
->len
> FUSE_NAME_MAX
)
271 req
= fuse_get_req(fc
);
276 forget_req
= fuse_get_req(fc
);
277 err
= PTR_ERR(forget_req
);
278 if (IS_ERR(forget_req
)) {
279 fuse_put_request(fc
, req
);
283 attr_version
= fuse_get_attr_version(fc
);
285 fuse_lookup_init(fc
, req
, nodeid
, name
, outarg
);
286 request_send(fc
, req
);
287 err
= req
->out
.h
.error
;
288 fuse_put_request(fc
, req
);
289 /* Zero nodeid is same as -ENOENT, but with valid timeout */
290 if (err
|| !outarg
->nodeid
)
296 if (!fuse_valid_type(outarg
->attr
.mode
))
299 *inode
= fuse_iget(sb
, outarg
->nodeid
, outarg
->generation
,
300 &outarg
->attr
, entry_attr_timeout(outarg
),
304 fuse_send_forget(fc
, forget_req
, outarg
->nodeid
, 1);
310 fuse_put_request(fc
, forget_req
);
315 static struct dentry
*fuse_lookup(struct inode
*dir
, struct dentry
*entry
,
316 struct nameidata
*nd
)
319 struct fuse_entry_out outarg
;
321 struct dentry
*newent
;
322 struct fuse_conn
*fc
= get_fuse_conn(dir
);
323 bool outarg_valid
= true;
325 err
= fuse_lookup_name(dir
->i_sb
, get_node_id(dir
), &entry
->d_name
,
327 if (err
== -ENOENT
) {
328 outarg_valid
= false;
335 if (inode
&& get_node_id(inode
) == FUSE_ROOT_ID
)
338 if (inode
&& S_ISDIR(inode
->i_mode
)) {
339 mutex_lock(&fc
->inst_mutex
);
340 newent
= fuse_d_add_directory(entry
, inode
);
341 mutex_unlock(&fc
->inst_mutex
);
342 err
= PTR_ERR(newent
);
346 newent
= d_splice_alias(inode
, entry
);
349 entry
= newent
? newent
: entry
;
350 entry
->d_op
= &fuse_dentry_operations
;
352 fuse_change_entry_timeout(entry
, &outarg
);
354 fuse_invalidate_entry_cache(entry
);
365 * Synchronous release for the case when something goes wrong in CREATE_OPEN
367 static void fuse_sync_release(struct fuse_conn
*fc
, struct fuse_file
*ff
,
368 u64 nodeid
, int flags
)
370 fuse_release_fill(ff
, nodeid
, flags
, FUSE_RELEASE
);
371 ff
->reserved_req
->force
= 1;
372 request_send(fc
, ff
->reserved_req
);
373 fuse_put_request(fc
, ff
->reserved_req
);
378 * Atomic create+open operation
380 * If the filesystem doesn't support this, then fall back to separate
381 * 'mknod' + 'open' requests.
383 static int fuse_create_open(struct inode
*dir
, struct dentry
*entry
, int mode
,
384 struct nameidata
*nd
)
388 struct fuse_conn
*fc
= get_fuse_conn(dir
);
389 struct fuse_req
*req
;
390 struct fuse_req
*forget_req
;
391 struct fuse_open_in inarg
;
392 struct fuse_open_out outopen
;
393 struct fuse_entry_out outentry
;
394 struct fuse_file
*ff
;
396 int flags
= nd
->intent
.open
.flags
- 1;
401 if (flags
& O_DIRECT
)
404 forget_req
= fuse_get_req(fc
);
405 if (IS_ERR(forget_req
))
406 return PTR_ERR(forget_req
);
408 req
= fuse_get_req(fc
);
411 goto out_put_forget_req
;
414 ff
= fuse_file_alloc();
416 goto out_put_request
;
419 memset(&inarg
, 0, sizeof(inarg
));
420 memset(&outentry
, 0, sizeof(outentry
));
423 req
->in
.h
.opcode
= FUSE_CREATE
;
424 req
->in
.h
.nodeid
= get_node_id(dir
);
426 req
->in
.args
[0].size
= sizeof(inarg
);
427 req
->in
.args
[0].value
= &inarg
;
428 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
429 req
->in
.args
[1].value
= entry
->d_name
.name
;
430 req
->out
.numargs
= 2;
432 req
->out
.args
[0].size
= FUSE_COMPAT_ENTRY_OUT_SIZE
;
434 req
->out
.args
[0].size
= sizeof(outentry
);
435 req
->out
.args
[0].value
= &outentry
;
436 req
->out
.args
[1].size
= sizeof(outopen
);
437 req
->out
.args
[1].value
= &outopen
;
438 request_send(fc
, req
);
439 err
= req
->out
.h
.error
;
447 if (!S_ISREG(outentry
.attr
.mode
) || invalid_nodeid(outentry
.nodeid
))
450 fuse_put_request(fc
, req
);
451 inode
= fuse_iget(dir
->i_sb
, outentry
.nodeid
, outentry
.generation
,
452 &outentry
.attr
, entry_attr_timeout(&outentry
), 0);
454 flags
&= ~(O_CREAT
| O_EXCL
| O_TRUNC
);
456 fuse_sync_release(fc
, ff
, outentry
.nodeid
, flags
);
457 fuse_send_forget(fc
, forget_req
, outentry
.nodeid
, 1);
460 fuse_put_request(fc
, forget_req
);
461 d_instantiate(entry
, inode
);
462 fuse_change_entry_timeout(entry
, &outentry
);
463 fuse_invalidate_attr(dir
);
464 file
= lookup_instantiate_filp(nd
, entry
, generic_file_open
);
467 fuse_sync_release(fc
, ff
, outentry
.nodeid
, flags
);
468 return PTR_ERR(file
);
470 fuse_finish_open(inode
, file
, ff
, &outopen
);
476 fuse_put_request(fc
, req
);
478 fuse_put_request(fc
, forget_req
);
483 * Code shared between mknod, mkdir, symlink and link
485 static int create_new_entry(struct fuse_conn
*fc
, struct fuse_req
*req
,
486 struct inode
*dir
, struct dentry
*entry
,
489 struct fuse_entry_out outarg
;
492 struct fuse_req
*forget_req
;
494 forget_req
= fuse_get_req(fc
);
495 if (IS_ERR(forget_req
)) {
496 fuse_put_request(fc
, req
);
497 return PTR_ERR(forget_req
);
500 memset(&outarg
, 0, sizeof(outarg
));
501 req
->in
.h
.nodeid
= get_node_id(dir
);
502 req
->out
.numargs
= 1;
504 req
->out
.args
[0].size
= FUSE_COMPAT_ENTRY_OUT_SIZE
;
506 req
->out
.args
[0].size
= sizeof(outarg
);
507 req
->out
.args
[0].value
= &outarg
;
508 request_send(fc
, req
);
509 err
= req
->out
.h
.error
;
510 fuse_put_request(fc
, req
);
512 goto out_put_forget_req
;
515 if (invalid_nodeid(outarg
.nodeid
))
516 goto out_put_forget_req
;
518 if ((outarg
.attr
.mode
^ mode
) & S_IFMT
)
519 goto out_put_forget_req
;
521 inode
= fuse_iget(dir
->i_sb
, outarg
.nodeid
, outarg
.generation
,
522 &outarg
.attr
, entry_attr_timeout(&outarg
), 0);
524 fuse_send_forget(fc
, forget_req
, outarg
.nodeid
, 1);
527 fuse_put_request(fc
, forget_req
);
529 if (S_ISDIR(inode
->i_mode
)) {
530 struct dentry
*alias
;
531 mutex_lock(&fc
->inst_mutex
);
532 alias
= d_find_alias(inode
);
534 /* New directory must have moved since mkdir */
535 mutex_unlock(&fc
->inst_mutex
);
540 d_instantiate(entry
, inode
);
541 mutex_unlock(&fc
->inst_mutex
);
543 d_instantiate(entry
, inode
);
545 fuse_change_entry_timeout(entry
, &outarg
);
546 fuse_invalidate_attr(dir
);
550 fuse_put_request(fc
, forget_req
);
554 static int fuse_mknod(struct inode
*dir
, struct dentry
*entry
, int mode
,
557 struct fuse_mknod_in inarg
;
558 struct fuse_conn
*fc
= get_fuse_conn(dir
);
559 struct fuse_req
*req
= fuse_get_req(fc
);
563 memset(&inarg
, 0, sizeof(inarg
));
565 inarg
.rdev
= new_encode_dev(rdev
);
566 req
->in
.h
.opcode
= FUSE_MKNOD
;
568 req
->in
.args
[0].size
= sizeof(inarg
);
569 req
->in
.args
[0].value
= &inarg
;
570 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
571 req
->in
.args
[1].value
= entry
->d_name
.name
;
572 return create_new_entry(fc
, req
, dir
, entry
, mode
);
575 static int fuse_create(struct inode
*dir
, struct dentry
*entry
, int mode
,
576 struct nameidata
*nd
)
578 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
579 int err
= fuse_create_open(dir
, entry
, mode
, nd
);
582 /* Fall back on mknod */
584 return fuse_mknod(dir
, entry
, mode
, 0);
587 static int fuse_mkdir(struct inode
*dir
, struct dentry
*entry
, int mode
)
589 struct fuse_mkdir_in inarg
;
590 struct fuse_conn
*fc
= get_fuse_conn(dir
);
591 struct fuse_req
*req
= fuse_get_req(fc
);
595 memset(&inarg
, 0, sizeof(inarg
));
597 req
->in
.h
.opcode
= FUSE_MKDIR
;
599 req
->in
.args
[0].size
= sizeof(inarg
);
600 req
->in
.args
[0].value
= &inarg
;
601 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
602 req
->in
.args
[1].value
= entry
->d_name
.name
;
603 return create_new_entry(fc
, req
, dir
, entry
, S_IFDIR
);
606 static int fuse_symlink(struct inode
*dir
, struct dentry
*entry
,
609 struct fuse_conn
*fc
= get_fuse_conn(dir
);
610 unsigned len
= strlen(link
) + 1;
611 struct fuse_req
*req
= fuse_get_req(fc
);
615 req
->in
.h
.opcode
= FUSE_SYMLINK
;
617 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
618 req
->in
.args
[0].value
= entry
->d_name
.name
;
619 req
->in
.args
[1].size
= len
;
620 req
->in
.args
[1].value
= link
;
621 return create_new_entry(fc
, req
, dir
, entry
, S_IFLNK
);
624 static int fuse_unlink(struct inode
*dir
, struct dentry
*entry
)
627 struct fuse_conn
*fc
= get_fuse_conn(dir
);
628 struct fuse_req
*req
= fuse_get_req(fc
);
632 req
->in
.h
.opcode
= FUSE_UNLINK
;
633 req
->in
.h
.nodeid
= get_node_id(dir
);
635 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
636 req
->in
.args
[0].value
= entry
->d_name
.name
;
637 request_send(fc
, req
);
638 err
= req
->out
.h
.error
;
639 fuse_put_request(fc
, req
);
641 struct inode
*inode
= entry
->d_inode
;
643 /* Set nlink to zero so the inode can be cleared, if
644 the inode does have more links this will be
645 discovered at the next lookup/getattr */
647 fuse_invalidate_attr(inode
);
648 fuse_invalidate_attr(dir
);
649 fuse_invalidate_entry_cache(entry
);
650 } else if (err
== -EINTR
)
651 fuse_invalidate_entry(entry
);
655 static int fuse_rmdir(struct inode
*dir
, struct dentry
*entry
)
658 struct fuse_conn
*fc
= get_fuse_conn(dir
);
659 struct fuse_req
*req
= fuse_get_req(fc
);
663 req
->in
.h
.opcode
= FUSE_RMDIR
;
664 req
->in
.h
.nodeid
= get_node_id(dir
);
666 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
667 req
->in
.args
[0].value
= entry
->d_name
.name
;
668 request_send(fc
, req
);
669 err
= req
->out
.h
.error
;
670 fuse_put_request(fc
, req
);
672 clear_nlink(entry
->d_inode
);
673 fuse_invalidate_attr(dir
);
674 fuse_invalidate_entry_cache(entry
);
675 } else if (err
== -EINTR
)
676 fuse_invalidate_entry(entry
);
680 static int fuse_rename(struct inode
*olddir
, struct dentry
*oldent
,
681 struct inode
*newdir
, struct dentry
*newent
)
684 struct fuse_rename_in inarg
;
685 struct fuse_conn
*fc
= get_fuse_conn(olddir
);
686 struct fuse_req
*req
= fuse_get_req(fc
);
690 memset(&inarg
, 0, sizeof(inarg
));
691 inarg
.newdir
= get_node_id(newdir
);
692 req
->in
.h
.opcode
= FUSE_RENAME
;
693 req
->in
.h
.nodeid
= get_node_id(olddir
);
695 req
->in
.args
[0].size
= sizeof(inarg
);
696 req
->in
.args
[0].value
= &inarg
;
697 req
->in
.args
[1].size
= oldent
->d_name
.len
+ 1;
698 req
->in
.args
[1].value
= oldent
->d_name
.name
;
699 req
->in
.args
[2].size
= newent
->d_name
.len
+ 1;
700 req
->in
.args
[2].value
= newent
->d_name
.name
;
701 request_send(fc
, req
);
702 err
= req
->out
.h
.error
;
703 fuse_put_request(fc
, req
);
706 fuse_invalidate_attr(oldent
->d_inode
);
708 fuse_invalidate_attr(olddir
);
709 if (olddir
!= newdir
)
710 fuse_invalidate_attr(newdir
);
712 /* newent will end up negative */
714 fuse_invalidate_entry_cache(newent
);
715 } else if (err
== -EINTR
) {
716 /* If request was interrupted, DEITY only knows if the
717 rename actually took place. If the invalidation
718 fails (e.g. some process has CWD under the renamed
719 directory), then there can be inconsistency between
720 the dcache and the real filesystem. Tough luck. */
721 fuse_invalidate_entry(oldent
);
723 fuse_invalidate_entry(newent
);
729 static int fuse_link(struct dentry
*entry
, struct inode
*newdir
,
730 struct dentry
*newent
)
733 struct fuse_link_in inarg
;
734 struct inode
*inode
= entry
->d_inode
;
735 struct fuse_conn
*fc
= get_fuse_conn(inode
);
736 struct fuse_req
*req
= fuse_get_req(fc
);
740 memset(&inarg
, 0, sizeof(inarg
));
741 inarg
.oldnodeid
= get_node_id(inode
);
742 req
->in
.h
.opcode
= FUSE_LINK
;
744 req
->in
.args
[0].size
= sizeof(inarg
);
745 req
->in
.args
[0].value
= &inarg
;
746 req
->in
.args
[1].size
= newent
->d_name
.len
+ 1;
747 req
->in
.args
[1].value
= newent
->d_name
.name
;
748 err
= create_new_entry(fc
, req
, newdir
, newent
, inode
->i_mode
);
749 /* Contrary to "normal" filesystems it can happen that link
750 makes two "logical" inodes point to the same "physical"
751 inode. We invalidate the attributes of the old one, so it
752 will reflect changes in the backing inode (link count,
755 if (!err
|| err
== -EINTR
)
756 fuse_invalidate_attr(inode
);
760 static void fuse_fillattr(struct inode
*inode
, struct fuse_attr
*attr
,
763 stat
->dev
= inode
->i_sb
->s_dev
;
764 stat
->ino
= attr
->ino
;
765 stat
->mode
= (inode
->i_mode
& S_IFMT
) | (attr
->mode
& 07777);
766 stat
->nlink
= attr
->nlink
;
767 stat
->uid
= attr
->uid
;
768 stat
->gid
= attr
->gid
;
769 stat
->rdev
= inode
->i_rdev
;
770 stat
->atime
.tv_sec
= attr
->atime
;
771 stat
->atime
.tv_nsec
= attr
->atimensec
;
772 stat
->mtime
.tv_sec
= attr
->mtime
;
773 stat
->mtime
.tv_nsec
= attr
->mtimensec
;
774 stat
->ctime
.tv_sec
= attr
->ctime
;
775 stat
->ctime
.tv_nsec
= attr
->ctimensec
;
776 stat
->size
= attr
->size
;
777 stat
->blocks
= attr
->blocks
;
778 stat
->blksize
= (1 << inode
->i_blkbits
);
781 static int fuse_do_getattr(struct inode
*inode
, struct kstat
*stat
,
785 struct fuse_getattr_in inarg
;
786 struct fuse_attr_out outarg
;
787 struct fuse_conn
*fc
= get_fuse_conn(inode
);
788 struct fuse_req
*req
;
791 req
= fuse_get_req(fc
);
795 attr_version
= fuse_get_attr_version(fc
);
797 memset(&inarg
, 0, sizeof(inarg
));
798 memset(&outarg
, 0, sizeof(outarg
));
799 /* Directories have separate file-handle space */
800 if (file
&& S_ISREG(inode
->i_mode
)) {
801 struct fuse_file
*ff
= file
->private_data
;
803 inarg
.getattr_flags
|= FUSE_GETATTR_FH
;
806 req
->in
.h
.opcode
= FUSE_GETATTR
;
807 req
->in
.h
.nodeid
= get_node_id(inode
);
809 req
->in
.args
[0].size
= sizeof(inarg
);
810 req
->in
.args
[0].value
= &inarg
;
811 req
->out
.numargs
= 1;
813 req
->out
.args
[0].size
= FUSE_COMPAT_ATTR_OUT_SIZE
;
815 req
->out
.args
[0].size
= sizeof(outarg
);
816 req
->out
.args
[0].value
= &outarg
;
817 request_send(fc
, req
);
818 err
= req
->out
.h
.error
;
819 fuse_put_request(fc
, req
);
821 if ((inode
->i_mode
^ outarg
.attr
.mode
) & S_IFMT
) {
822 make_bad_inode(inode
);
825 fuse_change_attributes(inode
, &outarg
.attr
,
826 attr_timeout(&outarg
),
829 fuse_fillattr(inode
, &outarg
.attr
, stat
);
835 int fuse_update_attributes(struct inode
*inode
, struct kstat
*stat
,
836 struct file
*file
, bool *refreshed
)
838 struct fuse_inode
*fi
= get_fuse_inode(inode
);
842 if (fi
->i_time
< get_jiffies_64()) {
844 err
= fuse_do_getattr(inode
, stat
, file
);
849 generic_fillattr(inode
, stat
);
850 stat
->mode
= fi
->orig_i_mode
;
854 if (refreshed
!= NULL
)
861 * Calling into a user-controlled filesystem gives the filesystem
862 * daemon ptrace-like capabilities over the requester process. This
863 * means, that the filesystem daemon is able to record the exact
864 * filesystem operations performed, and can also control the behavior
865 * of the requester process in otherwise impossible ways. For example
866 * it can delay the operation for arbitrary length of time allowing
867 * DoS against the requester.
869 * For this reason only those processes can call into the filesystem,
870 * for which the owner of the mount has ptrace privilege. This
871 * excludes processes started by other users, suid or sgid processes.
873 int fuse_allow_task(struct fuse_conn
*fc
, struct task_struct
*task
)
875 if (fc
->flags
& FUSE_ALLOW_OTHER
)
878 if (task
->euid
== fc
->user_id
&&
879 task
->suid
== fc
->user_id
&&
880 task
->uid
== fc
->user_id
&&
881 task
->egid
== fc
->group_id
&&
882 task
->sgid
== fc
->group_id
&&
883 task
->gid
== fc
->group_id
)
889 static int fuse_access(struct inode
*inode
, int mask
)
891 struct fuse_conn
*fc
= get_fuse_conn(inode
);
892 struct fuse_req
*req
;
893 struct fuse_access_in inarg
;
899 req
= fuse_get_req(fc
);
903 memset(&inarg
, 0, sizeof(inarg
));
904 inarg
.mask
= mask
& (MAY_READ
| MAY_WRITE
| MAY_EXEC
);
905 req
->in
.h
.opcode
= FUSE_ACCESS
;
906 req
->in
.h
.nodeid
= get_node_id(inode
);
908 req
->in
.args
[0].size
= sizeof(inarg
);
909 req
->in
.args
[0].value
= &inarg
;
910 request_send(fc
, req
);
911 err
= req
->out
.h
.error
;
912 fuse_put_request(fc
, req
);
913 if (err
== -ENOSYS
) {
921 * Check permission. The two basic access models of FUSE are:
923 * 1) Local access checking ('default_permissions' mount option) based
924 * on file mode. This is the plain old disk filesystem permission
927 * 2) "Remote" access checking, where server is responsible for
928 * checking permission in each inode operation. An exception to this
929 * is if ->permission() was invoked from sys_access() in which case an
930 * access request is sent. Execute permission is still checked
931 * locally based on file mode.
933 static int fuse_permission(struct inode
*inode
, int mask
)
935 struct fuse_conn
*fc
= get_fuse_conn(inode
);
936 bool refreshed
= false;
939 if (!fuse_allow_task(fc
, current
))
943 * If attributes are needed, refresh them before proceeding
945 if ((fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) ||
946 ((mask
& MAY_EXEC
) && S_ISREG(inode
->i_mode
))) {
947 err
= fuse_update_attributes(inode
, NULL
, NULL
, &refreshed
);
952 if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
953 err
= generic_permission(inode
, mask
, NULL
);
955 /* If permission is denied, try to refresh file
956 attributes. This is also needed, because the root
957 node will at first have no permissions */
958 if (err
== -EACCES
&& !refreshed
) {
959 err
= fuse_do_getattr(inode
, NULL
, NULL
);
961 err
= generic_permission(inode
, mask
, NULL
);
964 /* Note: the opposite of the above test does not
965 exist. So if permissions are revoked this won't be
966 noticed immediately, only after the attribute
967 timeout has expired */
968 } else if (mask
& MAY_ACCESS
) {
969 err
= fuse_access(inode
, mask
);
970 } else if ((mask
& MAY_EXEC
) && S_ISREG(inode
->i_mode
)) {
971 if (!(inode
->i_mode
& S_IXUGO
)) {
975 err
= fuse_do_getattr(inode
, NULL
, NULL
);
976 if (!err
&& !(inode
->i_mode
& S_IXUGO
))
983 static int parse_dirfile(char *buf
, size_t nbytes
, struct file
*file
,
984 void *dstbuf
, filldir_t filldir
)
986 while (nbytes
>= FUSE_NAME_OFFSET
) {
987 struct fuse_dirent
*dirent
= (struct fuse_dirent
*) buf
;
988 size_t reclen
= FUSE_DIRENT_SIZE(dirent
);
990 if (!dirent
->namelen
|| dirent
->namelen
> FUSE_NAME_MAX
)
995 over
= filldir(dstbuf
, dirent
->name
, dirent
->namelen
,
996 file
->f_pos
, dirent
->ino
, dirent
->type
);
1002 file
->f_pos
= dirent
->off
;
1008 static int fuse_readdir(struct file
*file
, void *dstbuf
, filldir_t filldir
)
1013 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1014 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1015 struct fuse_req
*req
;
1017 if (is_bad_inode(inode
))
1020 req
= fuse_get_req(fc
);
1022 return PTR_ERR(req
);
1024 page
= alloc_page(GFP_KERNEL
);
1026 fuse_put_request(fc
, req
);
1030 req
->pages
[0] = page
;
1031 fuse_read_fill(req
, file
, inode
, file
->f_pos
, PAGE_SIZE
, FUSE_READDIR
);
1032 request_send(fc
, req
);
1033 nbytes
= req
->out
.args
[0].size
;
1034 err
= req
->out
.h
.error
;
1035 fuse_put_request(fc
, req
);
1037 err
= parse_dirfile(page_address(page
), nbytes
, file
, dstbuf
,
1041 fuse_invalidate_attr(inode
); /* atime changed */
1045 static char *read_link(struct dentry
*dentry
)
1047 struct inode
*inode
= dentry
->d_inode
;
1048 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1049 struct fuse_req
*req
= fuse_get_req(fc
);
1053 return ERR_CAST(req
);
1055 link
= (char *) __get_free_page(GFP_KERNEL
);
1057 link
= ERR_PTR(-ENOMEM
);
1060 req
->in
.h
.opcode
= FUSE_READLINK
;
1061 req
->in
.h
.nodeid
= get_node_id(inode
);
1062 req
->out
.argvar
= 1;
1063 req
->out
.numargs
= 1;
1064 req
->out
.args
[0].size
= PAGE_SIZE
- 1;
1065 req
->out
.args
[0].value
= link
;
1066 request_send(fc
, req
);
1067 if (req
->out
.h
.error
) {
1068 free_page((unsigned long) link
);
1069 link
= ERR_PTR(req
->out
.h
.error
);
1071 link
[req
->out
.args
[0].size
] = '\0';
1073 fuse_put_request(fc
, req
);
1074 fuse_invalidate_attr(inode
); /* atime changed */
1078 static void free_link(char *link
)
1081 free_page((unsigned long) link
);
1084 static void *fuse_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
1086 nd_set_link(nd
, read_link(dentry
));
1090 static void fuse_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *c
)
1092 free_link(nd_get_link(nd
));
1095 static int fuse_dir_open(struct inode
*inode
, struct file
*file
)
1097 return fuse_open_common(inode
, file
, 1);
1100 static int fuse_dir_release(struct inode
*inode
, struct file
*file
)
1102 return fuse_release_common(inode
, file
, 1);
1105 static int fuse_dir_fsync(struct file
*file
, struct dentry
*de
, int datasync
)
1107 /* nfsd can call this with no file */
1108 return file
? fuse_fsync_common(file
, de
, datasync
, 1) : 0;
1111 static bool update_mtime(unsigned ivalid
)
1113 /* Always update if mtime is explicitly set */
1114 if (ivalid
& ATTR_MTIME_SET
)
1117 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1118 if ((ivalid
& ATTR_SIZE
) && (ivalid
& (ATTR_OPEN
| ATTR_FILE
)))
1121 /* In all other cases update */
1125 static void iattr_to_fattr(struct iattr
*iattr
, struct fuse_setattr_in
*arg
)
1127 unsigned ivalid
= iattr
->ia_valid
;
1129 if (ivalid
& ATTR_MODE
)
1130 arg
->valid
|= FATTR_MODE
, arg
->mode
= iattr
->ia_mode
;
1131 if (ivalid
& ATTR_UID
)
1132 arg
->valid
|= FATTR_UID
, arg
->uid
= iattr
->ia_uid
;
1133 if (ivalid
& ATTR_GID
)
1134 arg
->valid
|= FATTR_GID
, arg
->gid
= iattr
->ia_gid
;
1135 if (ivalid
& ATTR_SIZE
)
1136 arg
->valid
|= FATTR_SIZE
, arg
->size
= iattr
->ia_size
;
1137 if (ivalid
& ATTR_ATIME
) {
1138 arg
->valid
|= FATTR_ATIME
;
1139 arg
->atime
= iattr
->ia_atime
.tv_sec
;
1140 arg
->atimensec
= iattr
->ia_atime
.tv_nsec
;
1141 if (!(ivalid
& ATTR_ATIME_SET
))
1142 arg
->valid
|= FATTR_ATIME_NOW
;
1144 if ((ivalid
& ATTR_MTIME
) && update_mtime(ivalid
)) {
1145 arg
->valid
|= FATTR_MTIME
;
1146 arg
->mtime
= iattr
->ia_mtime
.tv_sec
;
1147 arg
->mtimensec
= iattr
->ia_mtime
.tv_nsec
;
1148 if (!(ivalid
& ATTR_MTIME_SET
))
1149 arg
->valid
|= FATTR_MTIME_NOW
;
1154 * Prevent concurrent writepages on inode
1156 * This is done by adding a negative bias to the inode write counter
1157 * and waiting for all pending writes to finish.
1159 void fuse_set_nowrite(struct inode
*inode
)
1161 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1162 struct fuse_inode
*fi
= get_fuse_inode(inode
);
1164 BUG_ON(!mutex_is_locked(&inode
->i_mutex
));
1166 spin_lock(&fc
->lock
);
1167 BUG_ON(fi
->writectr
< 0);
1168 fi
->writectr
+= FUSE_NOWRITE
;
1169 spin_unlock(&fc
->lock
);
1170 wait_event(fi
->page_waitq
, fi
->writectr
== FUSE_NOWRITE
);
1174 * Allow writepages on inode
1176 * Remove the bias from the writecounter and send any queued
1179 static void __fuse_release_nowrite(struct inode
*inode
)
1181 struct fuse_inode
*fi
= get_fuse_inode(inode
);
1183 BUG_ON(fi
->writectr
!= FUSE_NOWRITE
);
1185 fuse_flush_writepages(inode
);
1188 void fuse_release_nowrite(struct inode
*inode
)
1190 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1192 spin_lock(&fc
->lock
);
1193 __fuse_release_nowrite(inode
);
1194 spin_unlock(&fc
->lock
);
1198 * Set attributes, and at the same time refresh them.
1200 * Truncation is slightly complicated, because the 'truncate' request
1201 * may fail, in which case we don't want to touch the mapping.
1202 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1203 * and the actual truncation by hand.
1205 static int fuse_do_setattr(struct dentry
*entry
, struct iattr
*attr
,
1208 struct inode
*inode
= entry
->d_inode
;
1209 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1210 struct fuse_req
*req
;
1211 struct fuse_setattr_in inarg
;
1212 struct fuse_attr_out outarg
;
1213 bool is_truncate
= false;
1217 if (!fuse_allow_task(fc
, current
))
1220 if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
1221 err
= inode_change_ok(inode
, attr
);
1226 if ((attr
->ia_valid
& ATTR_OPEN
) && fc
->atomic_o_trunc
)
1229 if (attr
->ia_valid
& ATTR_SIZE
) {
1230 unsigned long limit
;
1231 if (IS_SWAPFILE(inode
))
1233 limit
= current
->signal
->rlim
[RLIMIT_FSIZE
].rlim_cur
;
1234 if (limit
!= RLIM_INFINITY
&& attr
->ia_size
> (loff_t
) limit
) {
1235 send_sig(SIGXFSZ
, current
, 0);
1241 req
= fuse_get_req(fc
);
1243 return PTR_ERR(req
);
1246 fuse_set_nowrite(inode
);
1248 memset(&inarg
, 0, sizeof(inarg
));
1249 memset(&outarg
, 0, sizeof(outarg
));
1250 iattr_to_fattr(attr
, &inarg
);
1252 struct fuse_file
*ff
= file
->private_data
;
1253 inarg
.valid
|= FATTR_FH
;
1256 if (attr
->ia_valid
& ATTR_SIZE
) {
1257 /* For mandatory locking in truncate */
1258 inarg
.valid
|= FATTR_LOCKOWNER
;
1259 inarg
.lock_owner
= fuse_lock_owner_id(fc
, current
->files
);
1261 req
->in
.h
.opcode
= FUSE_SETATTR
;
1262 req
->in
.h
.nodeid
= get_node_id(inode
);
1263 req
->in
.numargs
= 1;
1264 req
->in
.args
[0].size
= sizeof(inarg
);
1265 req
->in
.args
[0].value
= &inarg
;
1266 req
->out
.numargs
= 1;
1268 req
->out
.args
[0].size
= FUSE_COMPAT_ATTR_OUT_SIZE
;
1270 req
->out
.args
[0].size
= sizeof(outarg
);
1271 req
->out
.args
[0].value
= &outarg
;
1272 request_send(fc
, req
);
1273 err
= req
->out
.h
.error
;
1274 fuse_put_request(fc
, req
);
1277 fuse_invalidate_attr(inode
);
1281 if ((inode
->i_mode
^ outarg
.attr
.mode
) & S_IFMT
) {
1282 make_bad_inode(inode
);
1287 spin_lock(&fc
->lock
);
1288 fuse_change_attributes_common(inode
, &outarg
.attr
,
1289 attr_timeout(&outarg
));
1290 oldsize
= inode
->i_size
;
1291 i_size_write(inode
, outarg
.attr
.size
);
1294 /* NOTE: this may release/reacquire fc->lock */
1295 __fuse_release_nowrite(inode
);
1297 spin_unlock(&fc
->lock
);
1300 * Only call invalidate_inode_pages2() after removing
1301 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1303 if (S_ISREG(inode
->i_mode
) && oldsize
!= outarg
.attr
.size
) {
1304 if (outarg
.attr
.size
< oldsize
)
1305 fuse_truncate(inode
->i_mapping
, outarg
.attr
.size
);
1306 invalidate_inode_pages2(inode
->i_mapping
);
1313 fuse_release_nowrite(inode
);
1318 static int fuse_setattr(struct dentry
*entry
, struct iattr
*attr
)
1320 if (attr
->ia_valid
& ATTR_FILE
)
1321 return fuse_do_setattr(entry
, attr
, attr
->ia_file
);
1323 return fuse_do_setattr(entry
, attr
, NULL
);
1326 static int fuse_getattr(struct vfsmount
*mnt
, struct dentry
*entry
,
1329 struct inode
*inode
= entry
->d_inode
;
1330 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1332 if (!fuse_allow_task(fc
, current
))
1335 return fuse_update_attributes(inode
, stat
, NULL
, NULL
);
1338 static int fuse_setxattr(struct dentry
*entry
, const char *name
,
1339 const void *value
, size_t size
, int flags
)
1341 struct inode
*inode
= entry
->d_inode
;
1342 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1343 struct fuse_req
*req
;
1344 struct fuse_setxattr_in inarg
;
1347 if (fc
->no_setxattr
)
1350 req
= fuse_get_req(fc
);
1352 return PTR_ERR(req
);
1354 memset(&inarg
, 0, sizeof(inarg
));
1356 inarg
.flags
= flags
;
1357 req
->in
.h
.opcode
= FUSE_SETXATTR
;
1358 req
->in
.h
.nodeid
= get_node_id(inode
);
1359 req
->in
.numargs
= 3;
1360 req
->in
.args
[0].size
= sizeof(inarg
);
1361 req
->in
.args
[0].value
= &inarg
;
1362 req
->in
.args
[1].size
= strlen(name
) + 1;
1363 req
->in
.args
[1].value
= name
;
1364 req
->in
.args
[2].size
= size
;
1365 req
->in
.args
[2].value
= value
;
1366 request_send(fc
, req
);
1367 err
= req
->out
.h
.error
;
1368 fuse_put_request(fc
, req
);
1369 if (err
== -ENOSYS
) {
1370 fc
->no_setxattr
= 1;
1376 static ssize_t
fuse_getxattr(struct dentry
*entry
, const char *name
,
1377 void *value
, size_t size
)
1379 struct inode
*inode
= entry
->d_inode
;
1380 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1381 struct fuse_req
*req
;
1382 struct fuse_getxattr_in inarg
;
1383 struct fuse_getxattr_out outarg
;
1386 if (fc
->no_getxattr
)
1389 req
= fuse_get_req(fc
);
1391 return PTR_ERR(req
);
1393 memset(&inarg
, 0, sizeof(inarg
));
1395 req
->in
.h
.opcode
= FUSE_GETXATTR
;
1396 req
->in
.h
.nodeid
= get_node_id(inode
);
1397 req
->in
.numargs
= 2;
1398 req
->in
.args
[0].size
= sizeof(inarg
);
1399 req
->in
.args
[0].value
= &inarg
;
1400 req
->in
.args
[1].size
= strlen(name
) + 1;
1401 req
->in
.args
[1].value
= name
;
1402 /* This is really two different operations rolled into one */
1403 req
->out
.numargs
= 1;
1405 req
->out
.argvar
= 1;
1406 req
->out
.args
[0].size
= size
;
1407 req
->out
.args
[0].value
= value
;
1409 req
->out
.args
[0].size
= sizeof(outarg
);
1410 req
->out
.args
[0].value
= &outarg
;
1412 request_send(fc
, req
);
1413 ret
= req
->out
.h
.error
;
1415 ret
= size
? req
->out
.args
[0].size
: outarg
.size
;
1417 if (ret
== -ENOSYS
) {
1418 fc
->no_getxattr
= 1;
1422 fuse_put_request(fc
, req
);
1426 static ssize_t
fuse_listxattr(struct dentry
*entry
, char *list
, size_t size
)
1428 struct inode
*inode
= entry
->d_inode
;
1429 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1430 struct fuse_req
*req
;
1431 struct fuse_getxattr_in inarg
;
1432 struct fuse_getxattr_out outarg
;
1435 if (!fuse_allow_task(fc
, current
))
1438 if (fc
->no_listxattr
)
1441 req
= fuse_get_req(fc
);
1443 return PTR_ERR(req
);
1445 memset(&inarg
, 0, sizeof(inarg
));
1447 req
->in
.h
.opcode
= FUSE_LISTXATTR
;
1448 req
->in
.h
.nodeid
= get_node_id(inode
);
1449 req
->in
.numargs
= 1;
1450 req
->in
.args
[0].size
= sizeof(inarg
);
1451 req
->in
.args
[0].value
= &inarg
;
1452 /* This is really two different operations rolled into one */
1453 req
->out
.numargs
= 1;
1455 req
->out
.argvar
= 1;
1456 req
->out
.args
[0].size
= size
;
1457 req
->out
.args
[0].value
= list
;
1459 req
->out
.args
[0].size
= sizeof(outarg
);
1460 req
->out
.args
[0].value
= &outarg
;
1462 request_send(fc
, req
);
1463 ret
= req
->out
.h
.error
;
1465 ret
= size
? req
->out
.args
[0].size
: outarg
.size
;
1467 if (ret
== -ENOSYS
) {
1468 fc
->no_listxattr
= 1;
1472 fuse_put_request(fc
, req
);
1476 static int fuse_removexattr(struct dentry
*entry
, const char *name
)
1478 struct inode
*inode
= entry
->d_inode
;
1479 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1480 struct fuse_req
*req
;
1483 if (fc
->no_removexattr
)
1486 req
= fuse_get_req(fc
);
1488 return PTR_ERR(req
);
1490 req
->in
.h
.opcode
= FUSE_REMOVEXATTR
;
1491 req
->in
.h
.nodeid
= get_node_id(inode
);
1492 req
->in
.numargs
= 1;
1493 req
->in
.args
[0].size
= strlen(name
) + 1;
1494 req
->in
.args
[0].value
= name
;
1495 request_send(fc
, req
);
1496 err
= req
->out
.h
.error
;
1497 fuse_put_request(fc
, req
);
1498 if (err
== -ENOSYS
) {
1499 fc
->no_removexattr
= 1;
1505 static const struct inode_operations fuse_dir_inode_operations
= {
1506 .lookup
= fuse_lookup
,
1507 .mkdir
= fuse_mkdir
,
1508 .symlink
= fuse_symlink
,
1509 .unlink
= fuse_unlink
,
1510 .rmdir
= fuse_rmdir
,
1511 .rename
= fuse_rename
,
1513 .setattr
= fuse_setattr
,
1514 .create
= fuse_create
,
1515 .mknod
= fuse_mknod
,
1516 .permission
= fuse_permission
,
1517 .getattr
= fuse_getattr
,
1518 .setxattr
= fuse_setxattr
,
1519 .getxattr
= fuse_getxattr
,
1520 .listxattr
= fuse_listxattr
,
1521 .removexattr
= fuse_removexattr
,
1524 static const struct file_operations fuse_dir_operations
= {
1525 .llseek
= generic_file_llseek
,
1526 .read
= generic_read_dir
,
1527 .readdir
= fuse_readdir
,
1528 .open
= fuse_dir_open
,
1529 .release
= fuse_dir_release
,
1530 .fsync
= fuse_dir_fsync
,
1533 static const struct inode_operations fuse_common_inode_operations
= {
1534 .setattr
= fuse_setattr
,
1535 .permission
= fuse_permission
,
1536 .getattr
= fuse_getattr
,
1537 .setxattr
= fuse_setxattr
,
1538 .getxattr
= fuse_getxattr
,
1539 .listxattr
= fuse_listxattr
,
1540 .removexattr
= fuse_removexattr
,
1543 static const struct inode_operations fuse_symlink_inode_operations
= {
1544 .setattr
= fuse_setattr
,
1545 .follow_link
= fuse_follow_link
,
1546 .put_link
= fuse_put_link
,
1547 .readlink
= generic_readlink
,
1548 .getattr
= fuse_getattr
,
1549 .setxattr
= fuse_setxattr
,
1550 .getxattr
= fuse_getxattr
,
1551 .listxattr
= fuse_listxattr
,
1552 .removexattr
= fuse_removexattr
,
1555 void fuse_init_common(struct inode
*inode
)
1557 inode
->i_op
= &fuse_common_inode_operations
;
1560 void fuse_init_dir(struct inode
*inode
)
1562 inode
->i_op
= &fuse_dir_inode_operations
;
1563 inode
->i_fop
= &fuse_dir_operations
;
1566 void fuse_init_symlink(struct inode
*inode
)
1568 inode
->i_op
= &fuse_symlink_inode_operations
;