2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2008 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/sched.h>
14 #include <linux/namei.h>
15 #include <linux/slab.h>
17 static bool fuse_use_readdirplus(struct inode
*dir
, struct dir_context
*ctx
)
19 struct fuse_conn
*fc
= get_fuse_conn(dir
);
20 struct fuse_inode
*fi
= get_fuse_inode(dir
);
22 if (!fc
->do_readdirplus
)
24 if (!fc
->readdirplus_auto
)
26 if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS
, &fi
->state
))
33 static void fuse_advise_use_readdirplus(struct inode
*dir
)
35 struct fuse_inode
*fi
= get_fuse_inode(dir
);
37 set_bit(FUSE_I_ADVISE_RDPLUS
, &fi
->state
);
40 #if BITS_PER_LONG >= 64
41 static inline void fuse_dentry_settime(struct dentry
*entry
, u64 time
)
46 static inline u64
fuse_dentry_time(struct dentry
*entry
)
52 * On 32 bit archs store the high 32 bits of time in d_fsdata
54 static void fuse_dentry_settime(struct dentry
*entry
, u64 time
)
57 entry
->d_fsdata
= (void *) (unsigned long) (time
>> 32);
60 static u64
fuse_dentry_time(struct dentry
*entry
)
62 return (u64
) entry
->d_time
+
63 ((u64
) (unsigned long) entry
->d_fsdata
<< 32);
68 * FUSE caches dentries and attributes with separate timeout. The
69 * time in jiffies until the dentry/attributes are valid is stored in
70 * dentry->d_time and fuse_inode->i_time respectively.
74 * Calculate the time in jiffies until a dentry/attributes are valid
76 static u64
time_to_jiffies(unsigned long sec
, unsigned long nsec
)
79 struct timespec ts
= {sec
, nsec
};
80 return get_jiffies_64() + timespec_to_jiffies(&ts
);
86 * Set dentry and possibly attribute timeouts from the lookup/mk*
89 static void fuse_change_entry_timeout(struct dentry
*entry
,
90 struct fuse_entry_out
*o
)
92 fuse_dentry_settime(entry
,
93 time_to_jiffies(o
->entry_valid
, o
->entry_valid_nsec
));
96 static u64
attr_timeout(struct fuse_attr_out
*o
)
98 return time_to_jiffies(o
->attr_valid
, o
->attr_valid_nsec
);
101 static u64
entry_attr_timeout(struct fuse_entry_out
*o
)
103 return time_to_jiffies(o
->attr_valid
, o
->attr_valid_nsec
);
107 * Mark the attributes as stale, so that at the next call to
108 * ->getattr() they will be fetched from userspace
110 void fuse_invalidate_attr(struct inode
*inode
)
112 get_fuse_inode(inode
)->i_time
= 0;
116 * Mark the attributes as stale due to an atime change. Avoid the invalidate if
119 void fuse_invalidate_atime(struct inode
*inode
)
121 if (!IS_RDONLY(inode
))
122 fuse_invalidate_attr(inode
);
126 * Just mark the entry as stale, so that a next attempt to look it up
127 * will result in a new lookup call to userspace
129 * This is called when a dentry is about to become negative and the
130 * timeout is unknown (unlink, rmdir, rename and in some cases
133 void fuse_invalidate_entry_cache(struct dentry
*entry
)
135 fuse_dentry_settime(entry
, 0);
139 * Same as fuse_invalidate_entry_cache(), but also try to remove the
140 * dentry from the hash
142 static void fuse_invalidate_entry(struct dentry
*entry
)
145 fuse_invalidate_entry_cache(entry
);
148 static void fuse_lookup_init(struct fuse_conn
*fc
, struct fuse_args
*args
,
149 u64 nodeid
, struct qstr
*name
,
150 struct fuse_entry_out
*outarg
)
152 memset(outarg
, 0, sizeof(struct fuse_entry_out
));
153 args
->in
.h
.opcode
= FUSE_LOOKUP
;
154 args
->in
.h
.nodeid
= nodeid
;
155 args
->in
.numargs
= 1;
156 args
->in
.args
[0].size
= name
->len
+ 1;
157 args
->in
.args
[0].value
= name
->name
;
158 args
->out
.numargs
= 1;
159 args
->out
.args
[0].size
= sizeof(struct fuse_entry_out
);
160 args
->out
.args
[0].value
= outarg
;
163 u64
fuse_get_attr_version(struct fuse_conn
*fc
)
168 * The spin lock isn't actually needed on 64bit archs, but we
169 * don't yet care too much about such optimizations.
171 spin_lock(&fc
->lock
);
172 curr_version
= fc
->attr_version
;
173 spin_unlock(&fc
->lock
);
179 * Check whether the dentry is still valid
181 * If the entry validity timeout has expired and the dentry is
182 * positive, try to redo the lookup. If the lookup results in a
183 * different inode, then let the VFS invalidate the dentry and redo
184 * the lookup once more. If the lookup results in the same inode,
185 * then refresh the attributes, timeouts and mark the dentry valid.
187 static int fuse_dentry_revalidate(struct dentry
*entry
, unsigned int flags
)
190 struct dentry
*parent
;
191 struct fuse_conn
*fc
;
192 struct fuse_inode
*fi
;
195 inode
= d_inode_rcu(entry
);
196 if (inode
&& is_bad_inode(inode
))
198 else if (time_before64(fuse_dentry_time(entry
), get_jiffies_64()) ||
199 (flags
& LOOKUP_REVAL
)) {
200 struct fuse_entry_out outarg
;
202 struct fuse_forget_link
*forget
;
205 /* For negative dentries, always do a fresh lookup */
210 if (flags
& LOOKUP_RCU
)
213 fc
= get_fuse_conn(inode
);
215 forget
= fuse_alloc_forget();
220 attr_version
= fuse_get_attr_version(fc
);
222 parent
= dget_parent(entry
);
223 fuse_lookup_init(fc
, &args
, get_node_id(d_inode(parent
)),
224 &entry
->d_name
, &outarg
);
225 ret
= fuse_simple_request(fc
, &args
);
227 /* Zero nodeid is same as -ENOENT */
228 if (!ret
&& !outarg
.nodeid
)
231 fi
= get_fuse_inode(inode
);
232 if (outarg
.nodeid
!= get_node_id(inode
)) {
233 fuse_queue_forget(fc
, forget
, outarg
.nodeid
, 1);
236 spin_lock(&fc
->lock
);
238 spin_unlock(&fc
->lock
);
243 if (ret
|| (outarg
.attr
.mode
^ inode
->i_mode
) & S_IFMT
)
246 fuse_change_attributes(inode
, &outarg
.attr
,
247 entry_attr_timeout(&outarg
),
249 fuse_change_entry_timeout(entry
, &outarg
);
251 fi
= get_fuse_inode(inode
);
252 if (flags
& LOOKUP_RCU
) {
253 if (test_bit(FUSE_I_INIT_RDPLUS
, &fi
->state
))
255 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS
, &fi
->state
)) {
256 parent
= dget_parent(entry
);
257 fuse_advise_use_readdirplus(d_inode(parent
));
270 static int invalid_nodeid(u64 nodeid
)
272 return !nodeid
|| nodeid
== FUSE_ROOT_ID
;
275 const struct dentry_operations fuse_dentry_operations
= {
276 .d_revalidate
= fuse_dentry_revalidate
,
279 int fuse_valid_type(int m
)
281 return S_ISREG(m
) || S_ISDIR(m
) || S_ISLNK(m
) || S_ISCHR(m
) ||
282 S_ISBLK(m
) || S_ISFIFO(m
) || S_ISSOCK(m
);
285 int fuse_lookup_name(struct super_block
*sb
, u64 nodeid
, struct qstr
*name
,
286 struct fuse_entry_out
*outarg
, struct inode
**inode
)
288 struct fuse_conn
*fc
= get_fuse_conn_super(sb
);
290 struct fuse_forget_link
*forget
;
296 if (name
->len
> FUSE_NAME_MAX
)
300 forget
= fuse_alloc_forget();
305 attr_version
= fuse_get_attr_version(fc
);
307 fuse_lookup_init(fc
, &args
, nodeid
, name
, outarg
);
308 err
= fuse_simple_request(fc
, &args
);
309 /* Zero nodeid is same as -ENOENT, but with valid timeout */
310 if (err
|| !outarg
->nodeid
)
316 if (!fuse_valid_type(outarg
->attr
.mode
))
319 *inode
= fuse_iget(sb
, outarg
->nodeid
, outarg
->generation
,
320 &outarg
->attr
, entry_attr_timeout(outarg
),
324 fuse_queue_forget(fc
, forget
, outarg
->nodeid
, 1);
335 static struct dentry
*fuse_lookup(struct inode
*dir
, struct dentry
*entry
,
339 struct fuse_entry_out outarg
;
341 struct dentry
*newent
;
342 bool outarg_valid
= true;
344 fuse_lock_inode(dir
);
345 err
= fuse_lookup_name(dir
->i_sb
, get_node_id(dir
), &entry
->d_name
,
347 fuse_unlock_inode(dir
);
348 if (err
== -ENOENT
) {
349 outarg_valid
= false;
356 if (inode
&& get_node_id(inode
) == FUSE_ROOT_ID
)
359 newent
= d_splice_alias(inode
, entry
);
360 err
= PTR_ERR(newent
);
364 entry
= newent
? newent
: entry
;
366 fuse_change_entry_timeout(entry
, &outarg
);
368 fuse_invalidate_entry_cache(entry
);
370 fuse_advise_use_readdirplus(dir
);
380 * Atomic create+open operation
382 * If the filesystem doesn't support this, then fall back to separate
383 * 'mknod' + 'open' requests.
385 static int fuse_create_open(struct inode
*dir
, struct dentry
*entry
,
386 struct file
*file
, unsigned flags
,
387 umode_t mode
, int *opened
)
391 struct fuse_conn
*fc
= get_fuse_conn(dir
);
393 struct fuse_forget_link
*forget
;
394 struct fuse_create_in inarg
;
395 struct fuse_open_out outopen
;
396 struct fuse_entry_out outentry
;
397 struct fuse_file
*ff
;
399 /* Userspace expects S_IFREG in create mode */
400 BUG_ON((mode
& S_IFMT
) != S_IFREG
);
402 forget
= fuse_alloc_forget();
408 ff
= fuse_file_alloc(fc
);
410 goto out_put_forget_req
;
413 mode
&= ~current_umask();
416 memset(&inarg
, 0, sizeof(inarg
));
417 memset(&outentry
, 0, sizeof(outentry
));
420 inarg
.umask
= current_umask();
421 args
.in
.h
.opcode
= FUSE_CREATE
;
422 args
.in
.h
.nodeid
= get_node_id(dir
);
424 args
.in
.args
[0].size
= sizeof(inarg
);
425 args
.in
.args
[0].value
= &inarg
;
426 args
.in
.args
[1].size
= entry
->d_name
.len
+ 1;
427 args
.in
.args
[1].value
= entry
->d_name
.name
;
428 args
.out
.numargs
= 2;
429 args
.out
.args
[0].size
= sizeof(outentry
);
430 args
.out
.args
[0].value
= &outentry
;
431 args
.out
.args
[1].size
= sizeof(outopen
);
432 args
.out
.args
[1].value
= &outopen
;
433 err
= fuse_simple_request(fc
, &args
);
438 if (!S_ISREG(outentry
.attr
.mode
) || invalid_nodeid(outentry
.nodeid
))
442 ff
->nodeid
= outentry
.nodeid
;
443 ff
->open_flags
= outopen
.open_flags
;
444 inode
= fuse_iget(dir
->i_sb
, outentry
.nodeid
, outentry
.generation
,
445 &outentry
.attr
, entry_attr_timeout(&outentry
), 0);
447 flags
&= ~(O_CREAT
| O_EXCL
| O_TRUNC
);
448 fuse_sync_release(ff
, flags
);
449 fuse_queue_forget(fc
, forget
, outentry
.nodeid
, 1);
454 d_instantiate(entry
, inode
);
455 fuse_change_entry_timeout(entry
, &outentry
);
456 fuse_invalidate_attr(dir
);
457 err
= finish_open(file
, entry
, generic_file_open
, opened
);
459 fuse_sync_release(ff
, flags
);
461 file
->private_data
= fuse_file_get(ff
);
462 fuse_finish_open(inode
, file
);
474 static int fuse_mknod(struct inode
*, struct dentry
*, umode_t
, dev_t
);
475 static int fuse_atomic_open(struct inode
*dir
, struct dentry
*entry
,
476 struct file
*file
, unsigned flags
,
477 umode_t mode
, int *opened
)
480 struct fuse_conn
*fc
= get_fuse_conn(dir
);
481 struct dentry
*res
= NULL
;
483 if (d_unhashed(entry
)) {
484 res
= fuse_lookup(dir
, entry
, 0);
492 if (!(flags
& O_CREAT
) || d_really_is_positive(entry
))
496 *opened
|= FILE_CREATED
;
501 err
= fuse_create_open(dir
, entry
, file
, flags
, mode
, opened
);
502 if (err
== -ENOSYS
) {
511 err
= fuse_mknod(dir
, entry
, mode
, 0);
515 return finish_no_open(file
, res
);
519 * Code shared between mknod, mkdir, symlink and link
521 static int create_new_entry(struct fuse_conn
*fc
, struct fuse_args
*args
,
522 struct inode
*dir
, struct dentry
*entry
,
525 struct fuse_entry_out outarg
;
528 struct fuse_forget_link
*forget
;
530 forget
= fuse_alloc_forget();
534 memset(&outarg
, 0, sizeof(outarg
));
535 args
->in
.h
.nodeid
= get_node_id(dir
);
536 args
->out
.numargs
= 1;
537 args
->out
.args
[0].size
= sizeof(outarg
);
538 args
->out
.args
[0].value
= &outarg
;
539 err
= fuse_simple_request(fc
, args
);
541 goto out_put_forget_req
;
544 if (invalid_nodeid(outarg
.nodeid
))
545 goto out_put_forget_req
;
547 if ((outarg
.attr
.mode
^ mode
) & S_IFMT
)
548 goto out_put_forget_req
;
550 inode
= fuse_iget(dir
->i_sb
, outarg
.nodeid
, outarg
.generation
,
551 &outarg
.attr
, entry_attr_timeout(&outarg
), 0);
553 fuse_queue_forget(fc
, forget
, outarg
.nodeid
, 1);
558 err
= d_instantiate_no_diralias(entry
, inode
);
562 fuse_change_entry_timeout(entry
, &outarg
);
563 fuse_invalidate_attr(dir
);
571 static int fuse_mknod(struct inode
*dir
, struct dentry
*entry
, umode_t mode
,
574 struct fuse_mknod_in inarg
;
575 struct fuse_conn
*fc
= get_fuse_conn(dir
);
579 mode
&= ~current_umask();
581 memset(&inarg
, 0, sizeof(inarg
));
583 inarg
.rdev
= new_encode_dev(rdev
);
584 inarg
.umask
= current_umask();
585 args
.in
.h
.opcode
= FUSE_MKNOD
;
587 args
.in
.args
[0].size
= sizeof(inarg
);
588 args
.in
.args
[0].value
= &inarg
;
589 args
.in
.args
[1].size
= entry
->d_name
.len
+ 1;
590 args
.in
.args
[1].value
= entry
->d_name
.name
;
591 return create_new_entry(fc
, &args
, dir
, entry
, mode
);
594 static int fuse_create(struct inode
*dir
, struct dentry
*entry
, umode_t mode
,
597 return fuse_mknod(dir
, entry
, mode
, 0);
600 static int fuse_mkdir(struct inode
*dir
, struct dentry
*entry
, umode_t mode
)
602 struct fuse_mkdir_in inarg
;
603 struct fuse_conn
*fc
= get_fuse_conn(dir
);
607 mode
&= ~current_umask();
609 memset(&inarg
, 0, sizeof(inarg
));
611 inarg
.umask
= current_umask();
612 args
.in
.h
.opcode
= FUSE_MKDIR
;
614 args
.in
.args
[0].size
= sizeof(inarg
);
615 args
.in
.args
[0].value
= &inarg
;
616 args
.in
.args
[1].size
= entry
->d_name
.len
+ 1;
617 args
.in
.args
[1].value
= entry
->d_name
.name
;
618 return create_new_entry(fc
, &args
, dir
, entry
, S_IFDIR
);
621 static int fuse_symlink(struct inode
*dir
, struct dentry
*entry
,
624 struct fuse_conn
*fc
= get_fuse_conn(dir
);
625 unsigned len
= strlen(link
) + 1;
628 args
.in
.h
.opcode
= FUSE_SYMLINK
;
630 args
.in
.args
[0].size
= entry
->d_name
.len
+ 1;
631 args
.in
.args
[0].value
= entry
->d_name
.name
;
632 args
.in
.args
[1].size
= len
;
633 args
.in
.args
[1].value
= link
;
634 return create_new_entry(fc
, &args
, dir
, entry
, S_IFLNK
);
637 static inline void fuse_update_ctime(struct inode
*inode
)
639 if (!IS_NOCMTIME(inode
)) {
640 inode
->i_ctime
= current_fs_time(inode
->i_sb
);
641 mark_inode_dirty_sync(inode
);
645 static int fuse_unlink(struct inode
*dir
, struct dentry
*entry
)
648 struct fuse_conn
*fc
= get_fuse_conn(dir
);
651 args
.in
.h
.opcode
= FUSE_UNLINK
;
652 args
.in
.h
.nodeid
= get_node_id(dir
);
654 args
.in
.args
[0].size
= entry
->d_name
.len
+ 1;
655 args
.in
.args
[0].value
= entry
->d_name
.name
;
656 err
= fuse_simple_request(fc
, &args
);
658 struct inode
*inode
= d_inode(entry
);
659 struct fuse_inode
*fi
= get_fuse_inode(inode
);
661 spin_lock(&fc
->lock
);
662 fi
->attr_version
= ++fc
->attr_version
;
664 * If i_nlink == 0 then unlink doesn't make sense, yet this can
665 * happen if userspace filesystem is careless. It would be
666 * difficult to enforce correct nlink usage so just ignore this
669 if (inode
->i_nlink
> 0)
671 spin_unlock(&fc
->lock
);
672 fuse_invalidate_attr(inode
);
673 fuse_invalidate_attr(dir
);
674 fuse_invalidate_entry_cache(entry
);
675 fuse_update_ctime(inode
);
676 } else if (err
== -EINTR
)
677 fuse_invalidate_entry(entry
);
681 static int fuse_rmdir(struct inode
*dir
, struct dentry
*entry
)
684 struct fuse_conn
*fc
= get_fuse_conn(dir
);
687 args
.in
.h
.opcode
= FUSE_RMDIR
;
688 args
.in
.h
.nodeid
= get_node_id(dir
);
690 args
.in
.args
[0].size
= entry
->d_name
.len
+ 1;
691 args
.in
.args
[0].value
= entry
->d_name
.name
;
692 err
= fuse_simple_request(fc
, &args
);
694 clear_nlink(d_inode(entry
));
695 fuse_invalidate_attr(dir
);
696 fuse_invalidate_entry_cache(entry
);
697 } else if (err
== -EINTR
)
698 fuse_invalidate_entry(entry
);
702 static int fuse_rename_common(struct inode
*olddir
, struct dentry
*oldent
,
703 struct inode
*newdir
, struct dentry
*newent
,
704 unsigned int flags
, int opcode
, size_t argsize
)
707 struct fuse_rename2_in inarg
;
708 struct fuse_conn
*fc
= get_fuse_conn(olddir
);
711 memset(&inarg
, 0, argsize
);
712 inarg
.newdir
= get_node_id(newdir
);
714 args
.in
.h
.opcode
= opcode
;
715 args
.in
.h
.nodeid
= get_node_id(olddir
);
717 args
.in
.args
[0].size
= argsize
;
718 args
.in
.args
[0].value
= &inarg
;
719 args
.in
.args
[1].size
= oldent
->d_name
.len
+ 1;
720 args
.in
.args
[1].value
= oldent
->d_name
.name
;
721 args
.in
.args
[2].size
= newent
->d_name
.len
+ 1;
722 args
.in
.args
[2].value
= newent
->d_name
.name
;
723 err
= fuse_simple_request(fc
, &args
);
726 fuse_invalidate_attr(d_inode(oldent
));
727 fuse_update_ctime(d_inode(oldent
));
729 if (flags
& RENAME_EXCHANGE
) {
730 fuse_invalidate_attr(d_inode(newent
));
731 fuse_update_ctime(d_inode(newent
));
734 fuse_invalidate_attr(olddir
);
735 if (olddir
!= newdir
)
736 fuse_invalidate_attr(newdir
);
738 /* newent will end up negative */
739 if (!(flags
& RENAME_EXCHANGE
) && d_really_is_positive(newent
)) {
740 fuse_invalidate_attr(d_inode(newent
));
741 fuse_invalidate_entry_cache(newent
);
742 fuse_update_ctime(d_inode(newent
));
744 } else if (err
== -EINTR
) {
745 /* If request was interrupted, DEITY only knows if the
746 rename actually took place. If the invalidation
747 fails (e.g. some process has CWD under the renamed
748 directory), then there can be inconsistency between
749 the dcache and the real filesystem. Tough luck. */
750 fuse_invalidate_entry(oldent
);
751 if (d_really_is_positive(newent
))
752 fuse_invalidate_entry(newent
);
758 static int fuse_rename2(struct inode
*olddir
, struct dentry
*oldent
,
759 struct inode
*newdir
, struct dentry
*newent
,
762 struct fuse_conn
*fc
= get_fuse_conn(olddir
);
765 if (flags
& ~(RENAME_NOREPLACE
| RENAME_EXCHANGE
))
769 if (fc
->no_rename2
|| fc
->minor
< 23)
772 err
= fuse_rename_common(olddir
, oldent
, newdir
, newent
, flags
,
774 sizeof(struct fuse_rename2_in
));
775 if (err
== -ENOSYS
) {
780 err
= fuse_rename_common(olddir
, oldent
, newdir
, newent
, 0,
782 sizeof(struct fuse_rename_in
));
788 static int fuse_link(struct dentry
*entry
, struct inode
*newdir
,
789 struct dentry
*newent
)
792 struct fuse_link_in inarg
;
793 struct inode
*inode
= d_inode(entry
);
794 struct fuse_conn
*fc
= get_fuse_conn(inode
);
797 memset(&inarg
, 0, sizeof(inarg
));
798 inarg
.oldnodeid
= get_node_id(inode
);
799 args
.in
.h
.opcode
= FUSE_LINK
;
801 args
.in
.args
[0].size
= sizeof(inarg
);
802 args
.in
.args
[0].value
= &inarg
;
803 args
.in
.args
[1].size
= newent
->d_name
.len
+ 1;
804 args
.in
.args
[1].value
= newent
->d_name
.name
;
805 err
= create_new_entry(fc
, &args
, newdir
, newent
, inode
->i_mode
);
806 /* Contrary to "normal" filesystems it can happen that link
807 makes two "logical" inodes point to the same "physical"
808 inode. We invalidate the attributes of the old one, so it
809 will reflect changes in the backing inode (link count,
813 struct fuse_inode
*fi
= get_fuse_inode(inode
);
815 spin_lock(&fc
->lock
);
816 fi
->attr_version
= ++fc
->attr_version
;
818 spin_unlock(&fc
->lock
);
819 fuse_invalidate_attr(inode
);
820 fuse_update_ctime(inode
);
821 } else if (err
== -EINTR
) {
822 fuse_invalidate_attr(inode
);
827 static void fuse_fillattr(struct inode
*inode
, struct fuse_attr
*attr
,
830 unsigned int blkbits
;
831 struct fuse_conn
*fc
= get_fuse_conn(inode
);
833 /* see the comment in fuse_change_attributes() */
834 if (fc
->writeback_cache
&& S_ISREG(inode
->i_mode
)) {
835 attr
->size
= i_size_read(inode
);
836 attr
->mtime
= inode
->i_mtime
.tv_sec
;
837 attr
->mtimensec
= inode
->i_mtime
.tv_nsec
;
838 attr
->ctime
= inode
->i_ctime
.tv_sec
;
839 attr
->ctimensec
= inode
->i_ctime
.tv_nsec
;
842 stat
->dev
= inode
->i_sb
->s_dev
;
843 stat
->ino
= attr
->ino
;
844 stat
->mode
= (inode
->i_mode
& S_IFMT
) | (attr
->mode
& 07777);
845 stat
->nlink
= attr
->nlink
;
846 stat
->uid
= make_kuid(&init_user_ns
, attr
->uid
);
847 stat
->gid
= make_kgid(&init_user_ns
, attr
->gid
);
848 stat
->rdev
= inode
->i_rdev
;
849 stat
->atime
.tv_sec
= attr
->atime
;
850 stat
->atime
.tv_nsec
= attr
->atimensec
;
851 stat
->mtime
.tv_sec
= attr
->mtime
;
852 stat
->mtime
.tv_nsec
= attr
->mtimensec
;
853 stat
->ctime
.tv_sec
= attr
->ctime
;
854 stat
->ctime
.tv_nsec
= attr
->ctimensec
;
855 stat
->size
= attr
->size
;
856 stat
->blocks
= attr
->blocks
;
858 if (attr
->blksize
!= 0)
859 blkbits
= ilog2(attr
->blksize
);
861 blkbits
= inode
->i_sb
->s_blocksize_bits
;
863 stat
->blksize
= 1 << blkbits
;
866 static int fuse_do_getattr(struct inode
*inode
, struct kstat
*stat
,
870 struct fuse_getattr_in inarg
;
871 struct fuse_attr_out outarg
;
872 struct fuse_conn
*fc
= get_fuse_conn(inode
);
876 attr_version
= fuse_get_attr_version(fc
);
878 memset(&inarg
, 0, sizeof(inarg
));
879 memset(&outarg
, 0, sizeof(outarg
));
880 /* Directories have separate file-handle space */
881 if (file
&& S_ISREG(inode
->i_mode
)) {
882 struct fuse_file
*ff
= file
->private_data
;
884 inarg
.getattr_flags
|= FUSE_GETATTR_FH
;
887 args
.in
.h
.opcode
= FUSE_GETATTR
;
888 args
.in
.h
.nodeid
= get_node_id(inode
);
890 args
.in
.args
[0].size
= sizeof(inarg
);
891 args
.in
.args
[0].value
= &inarg
;
892 args
.out
.numargs
= 1;
893 args
.out
.args
[0].size
= sizeof(outarg
);
894 args
.out
.args
[0].value
= &outarg
;
895 err
= fuse_simple_request(fc
, &args
);
897 if ((inode
->i_mode
^ outarg
.attr
.mode
) & S_IFMT
) {
898 make_bad_inode(inode
);
901 fuse_change_attributes(inode
, &outarg
.attr
,
902 attr_timeout(&outarg
),
905 fuse_fillattr(inode
, &outarg
.attr
, stat
);
911 int fuse_update_attributes(struct inode
*inode
, struct kstat
*stat
,
912 struct file
*file
, bool *refreshed
)
914 struct fuse_inode
*fi
= get_fuse_inode(inode
);
918 if (time_before64(fi
->i_time
, get_jiffies_64())) {
920 err
= fuse_do_getattr(inode
, stat
, file
);
925 generic_fillattr(inode
, stat
);
926 stat
->mode
= fi
->orig_i_mode
;
927 stat
->ino
= fi
->orig_ino
;
931 if (refreshed
!= NULL
)
937 int fuse_reverse_inval_entry(struct super_block
*sb
, u64 parent_nodeid
,
938 u64 child_nodeid
, struct qstr
*name
)
941 struct inode
*parent
;
943 struct dentry
*entry
;
945 parent
= ilookup5(sb
, parent_nodeid
, fuse_inode_eq
, &parent_nodeid
);
950 if (!S_ISDIR(parent
->i_mode
))
954 dir
= d_find_alias(parent
);
958 entry
= d_lookup(dir
, name
);
963 fuse_invalidate_attr(parent
);
964 fuse_invalidate_entry(entry
);
966 if (child_nodeid
!= 0 && d_really_is_positive(entry
)) {
967 inode_lock(d_inode(entry
));
968 if (get_node_id(d_inode(entry
)) != child_nodeid
) {
972 if (d_mountpoint(entry
)) {
976 if (d_is_dir(entry
)) {
977 shrink_dcache_parent(entry
);
978 if (!simple_empty(entry
)) {
982 d_inode(entry
)->i_flags
|= S_DEAD
;
985 clear_nlink(d_inode(entry
));
988 inode_unlock(d_inode(entry
));
997 inode_unlock(parent
);
1003 * Calling into a user-controlled filesystem gives the filesystem
1004 * daemon ptrace-like capabilities over the current process. This
1005 * means, that the filesystem daemon is able to record the exact
1006 * filesystem operations performed, and can also control the behavior
1007 * of the requester process in otherwise impossible ways. For example
1008 * it can delay the operation for arbitrary length of time allowing
1009 * DoS against the requester.
1011 * For this reason only those processes can call into the filesystem,
1012 * for which the owner of the mount has ptrace privilege. This
1013 * excludes processes started by other users, suid or sgid processes.
1015 int fuse_allow_current_process(struct fuse_conn
*fc
)
1017 const struct cred
*cred
;
1019 if (fc
->flags
& FUSE_ALLOW_OTHER
)
1022 cred
= current_cred();
1023 if (uid_eq(cred
->euid
, fc
->user_id
) &&
1024 uid_eq(cred
->suid
, fc
->user_id
) &&
1025 uid_eq(cred
->uid
, fc
->user_id
) &&
1026 gid_eq(cred
->egid
, fc
->group_id
) &&
1027 gid_eq(cred
->sgid
, fc
->group_id
) &&
1028 gid_eq(cred
->gid
, fc
->group_id
))
1034 static int fuse_access(struct inode
*inode
, int mask
)
1036 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1038 struct fuse_access_in inarg
;
1041 BUG_ON(mask
& MAY_NOT_BLOCK
);
1046 memset(&inarg
, 0, sizeof(inarg
));
1047 inarg
.mask
= mask
& (MAY_READ
| MAY_WRITE
| MAY_EXEC
);
1048 args
.in
.h
.opcode
= FUSE_ACCESS
;
1049 args
.in
.h
.nodeid
= get_node_id(inode
);
1050 args
.in
.numargs
= 1;
1051 args
.in
.args
[0].size
= sizeof(inarg
);
1052 args
.in
.args
[0].value
= &inarg
;
1053 err
= fuse_simple_request(fc
, &args
);
1054 if (err
== -ENOSYS
) {
1061 static int fuse_perm_getattr(struct inode
*inode
, int mask
)
1063 if (mask
& MAY_NOT_BLOCK
)
1066 return fuse_do_getattr(inode
, NULL
, NULL
);
1070 * Check permission. The two basic access models of FUSE are:
1072 * 1) Local access checking ('default_permissions' mount option) based
1073 * on file mode. This is the plain old disk filesystem permission
1076 * 2) "Remote" access checking, where server is responsible for
1077 * checking permission in each inode operation. An exception to this
1078 * is if ->permission() was invoked from sys_access() in which case an
1079 * access request is sent. Execute permission is still checked
1080 * locally based on file mode.
1082 static int fuse_permission(struct inode
*inode
, int mask
)
1084 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1085 bool refreshed
= false;
1088 if (!fuse_allow_current_process(fc
))
1092 * If attributes are needed, refresh them before proceeding
1094 if ((fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) ||
1095 ((mask
& MAY_EXEC
) && S_ISREG(inode
->i_mode
))) {
1096 struct fuse_inode
*fi
= get_fuse_inode(inode
);
1098 if (time_before64(fi
->i_time
, get_jiffies_64())) {
1101 err
= fuse_perm_getattr(inode
, mask
);
1107 if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
1108 err
= generic_permission(inode
, mask
);
1110 /* If permission is denied, try to refresh file
1111 attributes. This is also needed, because the root
1112 node will at first have no permissions */
1113 if (err
== -EACCES
&& !refreshed
) {
1114 err
= fuse_perm_getattr(inode
, mask
);
1116 err
= generic_permission(inode
, mask
);
1119 /* Note: the opposite of the above test does not
1120 exist. So if permissions are revoked this won't be
1121 noticed immediately, only after the attribute
1122 timeout has expired */
1123 } else if (mask
& (MAY_ACCESS
| MAY_CHDIR
)) {
1124 err
= fuse_access(inode
, mask
);
1125 } else if ((mask
& MAY_EXEC
) && S_ISREG(inode
->i_mode
)) {
1126 if (!(inode
->i_mode
& S_IXUGO
)) {
1130 err
= fuse_perm_getattr(inode
, mask
);
1131 if (!err
&& !(inode
->i_mode
& S_IXUGO
))
1138 static int parse_dirfile(char *buf
, size_t nbytes
, struct file
*file
,
1139 struct dir_context
*ctx
)
1141 while (nbytes
>= FUSE_NAME_OFFSET
) {
1142 struct fuse_dirent
*dirent
= (struct fuse_dirent
*) buf
;
1143 size_t reclen
= FUSE_DIRENT_SIZE(dirent
);
1144 if (!dirent
->namelen
|| dirent
->namelen
> FUSE_NAME_MAX
)
1146 if (reclen
> nbytes
)
1148 if (memchr(dirent
->name
, '/', dirent
->namelen
) != NULL
)
1151 if (!dir_emit(ctx
, dirent
->name
, dirent
->namelen
,
1152 dirent
->ino
, dirent
->type
))
1157 ctx
->pos
= dirent
->off
;
1163 static int fuse_direntplus_link(struct file
*file
,
1164 struct fuse_direntplus
*direntplus
,
1167 struct fuse_entry_out
*o
= &direntplus
->entry_out
;
1168 struct fuse_dirent
*dirent
= &direntplus
->dirent
;
1169 struct dentry
*parent
= file
->f_path
.dentry
;
1170 struct qstr name
= QSTR_INIT(dirent
->name
, dirent
->namelen
);
1171 struct dentry
*dentry
;
1172 struct dentry
*alias
;
1173 struct inode
*dir
= d_inode(parent
);
1174 struct fuse_conn
*fc
;
1175 struct inode
*inode
;
1176 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq
);
1180 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1181 * ENOENT. Instead, it only means the userspace filesystem did
1182 * not want to return attributes/handle for this entry.
1189 if (name
.name
[0] == '.') {
1191 * We could potentially refresh the attributes of the directory
1196 if (name
.name
[1] == '.' && name
.len
== 2)
1200 if (invalid_nodeid(o
->nodeid
))
1202 if (!fuse_valid_type(o
->attr
.mode
))
1205 fc
= get_fuse_conn(dir
);
1207 name
.hash
= full_name_hash(name
.name
, name
.len
);
1208 dentry
= d_lookup(parent
, &name
);
1211 dentry
= d_alloc_parallel(parent
, &name
, &wq
);
1213 return PTR_ERR(dentry
);
1215 if (!d_in_lookup(dentry
)) {
1216 struct fuse_inode
*fi
;
1217 inode
= d_inode(dentry
);
1219 get_node_id(inode
) != o
->nodeid
||
1220 ((o
->attr
.mode
^ inode
->i_mode
) & S_IFMT
)) {
1221 d_invalidate(dentry
);
1225 if (is_bad_inode(inode
)) {
1230 fi
= get_fuse_inode(inode
);
1231 spin_lock(&fc
->lock
);
1233 spin_unlock(&fc
->lock
);
1235 fuse_change_attributes(inode
, &o
->attr
,
1236 entry_attr_timeout(o
),
1239 * The other branch comes via fuse_iget()
1240 * which bumps nlookup inside
1243 inode
= fuse_iget(dir
->i_sb
, o
->nodeid
, o
->generation
,
1244 &o
->attr
, entry_attr_timeout(o
),
1247 inode
= ERR_PTR(-ENOMEM
);
1249 alias
= d_splice_alias(inode
, dentry
);
1250 d_lookup_done(dentry
);
1256 return PTR_ERR(dentry
);
1258 if (fc
->readdirplus_auto
)
1259 set_bit(FUSE_I_INIT_RDPLUS
, &get_fuse_inode(inode
)->state
);
1260 fuse_change_entry_timeout(dentry
, o
);
1266 static int parse_dirplusfile(char *buf
, size_t nbytes
, struct file
*file
,
1267 struct dir_context
*ctx
, u64 attr_version
)
1269 struct fuse_direntplus
*direntplus
;
1270 struct fuse_dirent
*dirent
;
1275 while (nbytes
>= FUSE_NAME_OFFSET_DIRENTPLUS
) {
1276 direntplus
= (struct fuse_direntplus
*) buf
;
1277 dirent
= &direntplus
->dirent
;
1278 reclen
= FUSE_DIRENTPLUS_SIZE(direntplus
);
1280 if (!dirent
->namelen
|| dirent
->namelen
> FUSE_NAME_MAX
)
1282 if (reclen
> nbytes
)
1284 if (memchr(dirent
->name
, '/', dirent
->namelen
) != NULL
)
1288 /* We fill entries into dstbuf only as much as
1289 it can hold. But we still continue iterating
1290 over remaining entries to link them. If not,
1291 we need to send a FORGET for each of those
1292 which we did not link.
1294 over
= !dir_emit(ctx
, dirent
->name
, dirent
->namelen
,
1295 dirent
->ino
, dirent
->type
);
1296 ctx
->pos
= dirent
->off
;
1302 ret
= fuse_direntplus_link(file
, direntplus
, attr_version
);
1304 fuse_force_forget(file
, direntplus
->entry_out
.nodeid
);
1310 static int fuse_readdir(struct file
*file
, struct dir_context
*ctx
)
1315 struct inode
*inode
= file_inode(file
);
1316 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1317 struct fuse_req
*req
;
1318 u64 attr_version
= 0;
1320 if (is_bad_inode(inode
))
1323 req
= fuse_get_req(fc
, 1);
1325 return PTR_ERR(req
);
1327 page
= alloc_page(GFP_KERNEL
);
1329 fuse_put_request(fc
, req
);
1333 plus
= fuse_use_readdirplus(inode
, ctx
);
1334 req
->out
.argpages
= 1;
1336 req
->pages
[0] = page
;
1337 req
->page_descs
[0].length
= PAGE_SIZE
;
1339 attr_version
= fuse_get_attr_version(fc
);
1340 fuse_read_fill(req
, file
, ctx
->pos
, PAGE_SIZE
,
1343 fuse_read_fill(req
, file
, ctx
->pos
, PAGE_SIZE
,
1346 fuse_lock_inode(inode
);
1347 fuse_request_send(fc
, req
);
1348 fuse_unlock_inode(inode
);
1349 nbytes
= req
->out
.args
[0].size
;
1350 err
= req
->out
.h
.error
;
1351 fuse_put_request(fc
, req
);
1354 err
= parse_dirplusfile(page_address(page
), nbytes
,
1358 err
= parse_dirfile(page_address(page
), nbytes
, file
,
1364 fuse_invalidate_atime(inode
);
1368 static const char *fuse_get_link(struct dentry
*dentry
,
1369 struct inode
*inode
,
1370 struct delayed_call
*done
)
1372 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1378 return ERR_PTR(-ECHILD
);
1380 link
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
1382 return ERR_PTR(-ENOMEM
);
1384 args
.in
.h
.opcode
= FUSE_READLINK
;
1385 args
.in
.h
.nodeid
= get_node_id(inode
);
1386 args
.out
.argvar
= 1;
1387 args
.out
.numargs
= 1;
1388 args
.out
.args
[0].size
= PAGE_SIZE
- 1;
1389 args
.out
.args
[0].value
= link
;
1390 ret
= fuse_simple_request(fc
, &args
);
1393 link
= ERR_PTR(ret
);
1396 set_delayed_call(done
, kfree_link
, link
);
1398 fuse_invalidate_atime(inode
);
1402 static int fuse_dir_open(struct inode
*inode
, struct file
*file
)
1404 return fuse_open_common(inode
, file
, true);
1407 static int fuse_dir_release(struct inode
*inode
, struct file
*file
)
1409 fuse_release_common(file
, FUSE_RELEASEDIR
);
1414 static int fuse_dir_fsync(struct file
*file
, loff_t start
, loff_t end
,
1417 return fuse_fsync_common(file
, start
, end
, datasync
, 1);
1420 static long fuse_dir_ioctl(struct file
*file
, unsigned int cmd
,
1423 struct fuse_conn
*fc
= get_fuse_conn(file
->f_mapping
->host
);
1425 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1429 return fuse_ioctl_common(file
, cmd
, arg
, FUSE_IOCTL_DIR
);
1432 static long fuse_dir_compat_ioctl(struct file
*file
, unsigned int cmd
,
1435 struct fuse_conn
*fc
= get_fuse_conn(file
->f_mapping
->host
);
1440 return fuse_ioctl_common(file
, cmd
, arg
,
1441 FUSE_IOCTL_COMPAT
| FUSE_IOCTL_DIR
);
1444 static bool update_mtime(unsigned ivalid
, bool trust_local_mtime
)
1446 /* Always update if mtime is explicitly set */
1447 if (ivalid
& ATTR_MTIME_SET
)
1450 /* Or if kernel i_mtime is the official one */
1451 if (trust_local_mtime
)
1454 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1455 if ((ivalid
& ATTR_SIZE
) && (ivalid
& (ATTR_OPEN
| ATTR_FILE
)))
1458 /* In all other cases update */
1462 static void iattr_to_fattr(struct iattr
*iattr
, struct fuse_setattr_in
*arg
,
1463 bool trust_local_cmtime
)
1465 unsigned ivalid
= iattr
->ia_valid
;
1467 if (ivalid
& ATTR_MODE
)
1468 arg
->valid
|= FATTR_MODE
, arg
->mode
= iattr
->ia_mode
;
1469 if (ivalid
& ATTR_UID
)
1470 arg
->valid
|= FATTR_UID
, arg
->uid
= from_kuid(&init_user_ns
, iattr
->ia_uid
);
1471 if (ivalid
& ATTR_GID
)
1472 arg
->valid
|= FATTR_GID
, arg
->gid
= from_kgid(&init_user_ns
, iattr
->ia_gid
);
1473 if (ivalid
& ATTR_SIZE
)
1474 arg
->valid
|= FATTR_SIZE
, arg
->size
= iattr
->ia_size
;
1475 if (ivalid
& ATTR_ATIME
) {
1476 arg
->valid
|= FATTR_ATIME
;
1477 arg
->atime
= iattr
->ia_atime
.tv_sec
;
1478 arg
->atimensec
= iattr
->ia_atime
.tv_nsec
;
1479 if (!(ivalid
& ATTR_ATIME_SET
))
1480 arg
->valid
|= FATTR_ATIME_NOW
;
1482 if ((ivalid
& ATTR_MTIME
) && update_mtime(ivalid
, trust_local_cmtime
)) {
1483 arg
->valid
|= FATTR_MTIME
;
1484 arg
->mtime
= iattr
->ia_mtime
.tv_sec
;
1485 arg
->mtimensec
= iattr
->ia_mtime
.tv_nsec
;
1486 if (!(ivalid
& ATTR_MTIME_SET
) && !trust_local_cmtime
)
1487 arg
->valid
|= FATTR_MTIME_NOW
;
1489 if ((ivalid
& ATTR_CTIME
) && trust_local_cmtime
) {
1490 arg
->valid
|= FATTR_CTIME
;
1491 arg
->ctime
= iattr
->ia_ctime
.tv_sec
;
1492 arg
->ctimensec
= iattr
->ia_ctime
.tv_nsec
;
1497 * Prevent concurrent writepages on inode
1499 * This is done by adding a negative bias to the inode write counter
1500 * and waiting for all pending writes to finish.
1502 void fuse_set_nowrite(struct inode
*inode
)
1504 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1505 struct fuse_inode
*fi
= get_fuse_inode(inode
);
1507 BUG_ON(!inode_is_locked(inode
));
1509 spin_lock(&fc
->lock
);
1510 BUG_ON(fi
->writectr
< 0);
1511 fi
->writectr
+= FUSE_NOWRITE
;
1512 spin_unlock(&fc
->lock
);
1513 wait_event(fi
->page_waitq
, fi
->writectr
== FUSE_NOWRITE
);
1517 * Allow writepages on inode
1519 * Remove the bias from the writecounter and send any queued
1522 static void __fuse_release_nowrite(struct inode
*inode
)
1524 struct fuse_inode
*fi
= get_fuse_inode(inode
);
1526 BUG_ON(fi
->writectr
!= FUSE_NOWRITE
);
1528 fuse_flush_writepages(inode
);
1531 void fuse_release_nowrite(struct inode
*inode
)
1533 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1535 spin_lock(&fc
->lock
);
1536 __fuse_release_nowrite(inode
);
1537 spin_unlock(&fc
->lock
);
1540 static void fuse_setattr_fill(struct fuse_conn
*fc
, struct fuse_args
*args
,
1541 struct inode
*inode
,
1542 struct fuse_setattr_in
*inarg_p
,
1543 struct fuse_attr_out
*outarg_p
)
1545 args
->in
.h
.opcode
= FUSE_SETATTR
;
1546 args
->in
.h
.nodeid
= get_node_id(inode
);
1547 args
->in
.numargs
= 1;
1548 args
->in
.args
[0].size
= sizeof(*inarg_p
);
1549 args
->in
.args
[0].value
= inarg_p
;
1550 args
->out
.numargs
= 1;
1551 args
->out
.args
[0].size
= sizeof(*outarg_p
);
1552 args
->out
.args
[0].value
= outarg_p
;
1556 * Flush inode->i_mtime to the server
1558 int fuse_flush_times(struct inode
*inode
, struct fuse_file
*ff
)
1560 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1562 struct fuse_setattr_in inarg
;
1563 struct fuse_attr_out outarg
;
1565 memset(&inarg
, 0, sizeof(inarg
));
1566 memset(&outarg
, 0, sizeof(outarg
));
1568 inarg
.valid
= FATTR_MTIME
;
1569 inarg
.mtime
= inode
->i_mtime
.tv_sec
;
1570 inarg
.mtimensec
= inode
->i_mtime
.tv_nsec
;
1571 if (fc
->minor
>= 23) {
1572 inarg
.valid
|= FATTR_CTIME
;
1573 inarg
.ctime
= inode
->i_ctime
.tv_sec
;
1574 inarg
.ctimensec
= inode
->i_ctime
.tv_nsec
;
1577 inarg
.valid
|= FATTR_FH
;
1580 fuse_setattr_fill(fc
, &args
, inode
, &inarg
, &outarg
);
1582 return fuse_simple_request(fc
, &args
);
1586 * Set attributes, and at the same time refresh them.
1588 * Truncation is slightly complicated, because the 'truncate' request
1589 * may fail, in which case we don't want to touch the mapping.
1590 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1591 * and the actual truncation by hand.
1593 int fuse_do_setattr(struct inode
*inode
, struct iattr
*attr
,
1596 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1597 struct fuse_inode
*fi
= get_fuse_inode(inode
);
1599 struct fuse_setattr_in inarg
;
1600 struct fuse_attr_out outarg
;
1601 bool is_truncate
= false;
1602 bool is_wb
= fc
->writeback_cache
;
1605 bool trust_local_cmtime
= is_wb
&& S_ISREG(inode
->i_mode
);
1607 if (!(fc
->flags
& FUSE_DEFAULT_PERMISSIONS
))
1608 attr
->ia_valid
|= ATTR_FORCE
;
1610 err
= inode_change_ok(inode
, attr
);
1614 if (attr
->ia_valid
& ATTR_OPEN
) {
1615 if (fc
->atomic_o_trunc
)
1620 if (attr
->ia_valid
& ATTR_SIZE
)
1624 fuse_set_nowrite(inode
);
1625 set_bit(FUSE_I_SIZE_UNSTABLE
, &fi
->state
);
1626 if (trust_local_cmtime
&& attr
->ia_size
!= inode
->i_size
)
1627 attr
->ia_valid
|= ATTR_MTIME
| ATTR_CTIME
;
1630 memset(&inarg
, 0, sizeof(inarg
));
1631 memset(&outarg
, 0, sizeof(outarg
));
1632 iattr_to_fattr(attr
, &inarg
, trust_local_cmtime
);
1634 struct fuse_file
*ff
= file
->private_data
;
1635 inarg
.valid
|= FATTR_FH
;
1638 if (attr
->ia_valid
& ATTR_SIZE
) {
1639 /* For mandatory locking in truncate */
1640 inarg
.valid
|= FATTR_LOCKOWNER
;
1641 inarg
.lock_owner
= fuse_lock_owner_id(fc
, current
->files
);
1643 fuse_setattr_fill(fc
, &args
, inode
, &inarg
, &outarg
);
1644 err
= fuse_simple_request(fc
, &args
);
1647 fuse_invalidate_attr(inode
);
1651 if ((inode
->i_mode
^ outarg
.attr
.mode
) & S_IFMT
) {
1652 make_bad_inode(inode
);
1657 spin_lock(&fc
->lock
);
1658 /* the kernel maintains i_mtime locally */
1659 if (trust_local_cmtime
) {
1660 if (attr
->ia_valid
& ATTR_MTIME
)
1661 inode
->i_mtime
= attr
->ia_mtime
;
1662 if (attr
->ia_valid
& ATTR_CTIME
)
1663 inode
->i_ctime
= attr
->ia_ctime
;
1664 /* FIXME: clear I_DIRTY_SYNC? */
1667 fuse_change_attributes_common(inode
, &outarg
.attr
,
1668 attr_timeout(&outarg
));
1669 oldsize
= inode
->i_size
;
1670 /* see the comment in fuse_change_attributes() */
1671 if (!is_wb
|| is_truncate
|| !S_ISREG(inode
->i_mode
))
1672 i_size_write(inode
, outarg
.attr
.size
);
1675 /* NOTE: this may release/reacquire fc->lock */
1676 __fuse_release_nowrite(inode
);
1678 spin_unlock(&fc
->lock
);
1681 * Only call invalidate_inode_pages2() after removing
1682 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1684 if ((is_truncate
|| !is_wb
) &&
1685 S_ISREG(inode
->i_mode
) && oldsize
!= outarg
.attr
.size
) {
1686 truncate_pagecache(inode
, outarg
.attr
.size
);
1687 invalidate_inode_pages2(inode
->i_mapping
);
1690 clear_bit(FUSE_I_SIZE_UNSTABLE
, &fi
->state
);
1695 fuse_release_nowrite(inode
);
1697 clear_bit(FUSE_I_SIZE_UNSTABLE
, &fi
->state
);
1701 static int fuse_setattr(struct dentry
*entry
, struct iattr
*attr
)
1703 struct inode
*inode
= d_inode(entry
);
1705 if (!fuse_allow_current_process(get_fuse_conn(inode
)))
1708 if (attr
->ia_valid
& ATTR_FILE
)
1709 return fuse_do_setattr(inode
, attr
, attr
->ia_file
);
1711 return fuse_do_setattr(inode
, attr
, NULL
);
1714 static int fuse_getattr(struct vfsmount
*mnt
, struct dentry
*entry
,
1717 struct inode
*inode
= d_inode(entry
);
1718 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1720 if (!fuse_allow_current_process(fc
))
1723 return fuse_update_attributes(inode
, stat
, NULL
, NULL
);
1726 static int fuse_setxattr(struct dentry
*unused
, struct inode
*inode
,
1727 const char *name
, const void *value
,
1728 size_t size
, int flags
)
1730 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1732 struct fuse_setxattr_in inarg
;
1735 if (fc
->no_setxattr
)
1738 memset(&inarg
, 0, sizeof(inarg
));
1740 inarg
.flags
= flags
;
1741 args
.in
.h
.opcode
= FUSE_SETXATTR
;
1742 args
.in
.h
.nodeid
= get_node_id(inode
);
1743 args
.in
.numargs
= 3;
1744 args
.in
.args
[0].size
= sizeof(inarg
);
1745 args
.in
.args
[0].value
= &inarg
;
1746 args
.in
.args
[1].size
= strlen(name
) + 1;
1747 args
.in
.args
[1].value
= name
;
1748 args
.in
.args
[2].size
= size
;
1749 args
.in
.args
[2].value
= value
;
1750 err
= fuse_simple_request(fc
, &args
);
1751 if (err
== -ENOSYS
) {
1752 fc
->no_setxattr
= 1;
1756 fuse_invalidate_attr(inode
);
1757 fuse_update_ctime(inode
);
1762 static ssize_t
fuse_getxattr(struct dentry
*entry
, struct inode
*inode
,
1763 const char *name
, void *value
, size_t size
)
1765 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1767 struct fuse_getxattr_in inarg
;
1768 struct fuse_getxattr_out outarg
;
1771 if (fc
->no_getxattr
)
1774 memset(&inarg
, 0, sizeof(inarg
));
1776 args
.in
.h
.opcode
= FUSE_GETXATTR
;
1777 args
.in
.h
.nodeid
= get_node_id(inode
);
1778 args
.in
.numargs
= 2;
1779 args
.in
.args
[0].size
= sizeof(inarg
);
1780 args
.in
.args
[0].value
= &inarg
;
1781 args
.in
.args
[1].size
= strlen(name
) + 1;
1782 args
.in
.args
[1].value
= name
;
1783 /* This is really two different operations rolled into one */
1784 args
.out
.numargs
= 1;
1786 args
.out
.argvar
= 1;
1787 args
.out
.args
[0].size
= size
;
1788 args
.out
.args
[0].value
= value
;
1790 args
.out
.args
[0].size
= sizeof(outarg
);
1791 args
.out
.args
[0].value
= &outarg
;
1793 ret
= fuse_simple_request(fc
, &args
);
1796 if (ret
== -ENOSYS
) {
1797 fc
->no_getxattr
= 1;
1803 static ssize_t
fuse_listxattr(struct dentry
*entry
, char *list
, size_t size
)
1805 struct inode
*inode
= d_inode(entry
);
1806 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1808 struct fuse_getxattr_in inarg
;
1809 struct fuse_getxattr_out outarg
;
1812 if (!fuse_allow_current_process(fc
))
1815 if (fc
->no_listxattr
)
1818 memset(&inarg
, 0, sizeof(inarg
));
1820 args
.in
.h
.opcode
= FUSE_LISTXATTR
;
1821 args
.in
.h
.nodeid
= get_node_id(inode
);
1822 args
.in
.numargs
= 1;
1823 args
.in
.args
[0].size
= sizeof(inarg
);
1824 args
.in
.args
[0].value
= &inarg
;
1825 /* This is really two different operations rolled into one */
1826 args
.out
.numargs
= 1;
1828 args
.out
.argvar
= 1;
1829 args
.out
.args
[0].size
= size
;
1830 args
.out
.args
[0].value
= list
;
1832 args
.out
.args
[0].size
= sizeof(outarg
);
1833 args
.out
.args
[0].value
= &outarg
;
1835 ret
= fuse_simple_request(fc
, &args
);
1838 if (ret
== -ENOSYS
) {
1839 fc
->no_listxattr
= 1;
1845 static int fuse_removexattr(struct dentry
*entry
, const char *name
)
1847 struct inode
*inode
= d_inode(entry
);
1848 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1852 if (fc
->no_removexattr
)
1855 args
.in
.h
.opcode
= FUSE_REMOVEXATTR
;
1856 args
.in
.h
.nodeid
= get_node_id(inode
);
1857 args
.in
.numargs
= 1;
1858 args
.in
.args
[0].size
= strlen(name
) + 1;
1859 args
.in
.args
[0].value
= name
;
1860 err
= fuse_simple_request(fc
, &args
);
1861 if (err
== -ENOSYS
) {
1862 fc
->no_removexattr
= 1;
1866 fuse_invalidate_attr(inode
);
1867 fuse_update_ctime(inode
);
1872 static const struct inode_operations fuse_dir_inode_operations
= {
1873 .lookup
= fuse_lookup
,
1874 .mkdir
= fuse_mkdir
,
1875 .symlink
= fuse_symlink
,
1876 .unlink
= fuse_unlink
,
1877 .rmdir
= fuse_rmdir
,
1878 .rename2
= fuse_rename2
,
1880 .setattr
= fuse_setattr
,
1881 .create
= fuse_create
,
1882 .atomic_open
= fuse_atomic_open
,
1883 .mknod
= fuse_mknod
,
1884 .permission
= fuse_permission
,
1885 .getattr
= fuse_getattr
,
1886 .setxattr
= fuse_setxattr
,
1887 .getxattr
= fuse_getxattr
,
1888 .listxattr
= fuse_listxattr
,
1889 .removexattr
= fuse_removexattr
,
1892 static const struct file_operations fuse_dir_operations
= {
1893 .llseek
= generic_file_llseek
,
1894 .read
= generic_read_dir
,
1895 .iterate_shared
= fuse_readdir
,
1896 .open
= fuse_dir_open
,
1897 .release
= fuse_dir_release
,
1898 .fsync
= fuse_dir_fsync
,
1899 .unlocked_ioctl
= fuse_dir_ioctl
,
1900 .compat_ioctl
= fuse_dir_compat_ioctl
,
1903 static const struct inode_operations fuse_common_inode_operations
= {
1904 .setattr
= fuse_setattr
,
1905 .permission
= fuse_permission
,
1906 .getattr
= fuse_getattr
,
1907 .setxattr
= fuse_setxattr
,
1908 .getxattr
= fuse_getxattr
,
1909 .listxattr
= fuse_listxattr
,
1910 .removexattr
= fuse_removexattr
,
1913 static const struct inode_operations fuse_symlink_inode_operations
= {
1914 .setattr
= fuse_setattr
,
1915 .get_link
= fuse_get_link
,
1916 .readlink
= generic_readlink
,
1917 .getattr
= fuse_getattr
,
1918 .setxattr
= fuse_setxattr
,
1919 .getxattr
= fuse_getxattr
,
1920 .listxattr
= fuse_listxattr
,
1921 .removexattr
= fuse_removexattr
,
1924 void fuse_init_common(struct inode
*inode
)
1926 inode
->i_op
= &fuse_common_inode_operations
;
1929 void fuse_init_dir(struct inode
*inode
)
1931 inode
->i_op
= &fuse_dir_inode_operations
;
1932 inode
->i_fop
= &fuse_dir_operations
;
1935 void fuse_init_symlink(struct inode
*inode
)
1937 inode
->i_op
= &fuse_symlink_inode_operations
;