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 * Just mark the entry as stale, so that a next attempt to look it up
117 * will result in a new lookup call to userspace
119 * This is called when a dentry is about to become negative and the
120 * timeout is unknown (unlink, rmdir, rename and in some cases
123 void fuse_invalidate_entry_cache(struct dentry *entry)
125 fuse_dentry_settime(entry, 0);
129 * Same as fuse_invalidate_entry_cache(), but also try to remove the
130 * dentry from the hash
132 static void fuse_invalidate_entry(struct dentry *entry)
135 fuse_invalidate_entry_cache(entry);
138 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
139 u64 nodeid, struct qstr *name,
140 struct fuse_entry_out *outarg)
142 memset(outarg, 0, sizeof(struct fuse_entry_out));
143 req->in.h.opcode = FUSE_LOOKUP;
144 req->in.h.nodeid = nodeid;
146 req->in.args[0].size = name->len + 1;
147 req->in.args[0].value = name->name;
148 req->out.numargs = 1;
150 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
152 req->out.args[0].size = sizeof(struct fuse_entry_out);
153 req->out.args[0].value = outarg;
156 u64 fuse_get_attr_version(struct fuse_conn *fc)
161 * The spin lock isn't actually needed on 64bit archs, but we
162 * don't yet care too much about such optimizations.
164 spin_lock(&fc->lock);
165 curr_version = fc->attr_version;
166 spin_unlock(&fc->lock);
172 * Check whether the dentry is still valid
174 * If the entry validity timeout has expired and the dentry is
175 * positive, try to redo the lookup. If the lookup results in a
176 * different inode, then let the VFS invalidate the dentry and redo
177 * the lookup once more. If the lookup results in the same inode,
178 * then refresh the attributes, timeouts and mark the dentry valid.
180 static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
183 struct dentry *parent;
184 struct fuse_conn *fc;
185 struct fuse_inode *fi;
188 inode = ACCESS_ONCE(entry->d_inode);
189 if (inode && is_bad_inode(inode))
191 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
193 struct fuse_entry_out outarg;
194 struct fuse_req *req;
195 struct fuse_forget_link *forget;
198 /* For negative dentries, always do a fresh lookup */
203 if (flags & LOOKUP_RCU)
206 fc = get_fuse_conn(inode);
207 req = fuse_get_req_nopages(fc);
212 forget = fuse_alloc_forget();
214 fuse_put_request(fc, req);
219 attr_version = fuse_get_attr_version(fc);
221 parent = dget_parent(entry);
222 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
223 &entry->d_name, &outarg);
224 fuse_request_send(fc, req);
226 err = req->out.h.error;
227 fuse_put_request(fc, req);
228 /* Zero nodeid is same as -ENOENT */
229 if (!err && !outarg.nodeid)
232 fi = get_fuse_inode(inode);
233 if (outarg.nodeid != get_node_id(inode)) {
234 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
237 spin_lock(&fc->lock);
239 spin_unlock(&fc->lock);
242 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
245 fuse_change_attributes(inode, &outarg.attr,
246 entry_attr_timeout(&outarg),
248 fuse_change_entry_timeout(entry, &outarg);
250 fi = get_fuse_inode(inode);
251 if (flags & LOOKUP_RCU) {
252 if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
254 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
255 parent = dget_parent(entry);
256 fuse_advise_use_readdirplus(parent->d_inode);
267 if (!(flags & LOOKUP_RCU) && check_submounts_and_drop(entry) != 0)
272 static int invalid_nodeid(u64 nodeid)
274 return !nodeid || nodeid == FUSE_ROOT_ID;
277 const struct dentry_operations fuse_dentry_operations = {
278 .d_revalidate = fuse_dentry_revalidate,
281 int fuse_valid_type(int m)
283 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
284 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
287 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
288 struct fuse_entry_out *outarg, struct inode **inode)
290 struct fuse_conn *fc = get_fuse_conn_super(sb);
291 struct fuse_req *req;
292 struct fuse_forget_link *forget;
298 if (name->len > FUSE_NAME_MAX)
301 req = fuse_get_req_nopages(fc);
306 forget = fuse_alloc_forget();
309 fuse_put_request(fc, req);
313 attr_version = fuse_get_attr_version(fc);
315 fuse_lookup_init(fc, req, nodeid, name, outarg);
316 fuse_request_send(fc, req);
317 err = req->out.h.error;
318 fuse_put_request(fc, req);
319 /* Zero nodeid is same as -ENOENT, but with valid timeout */
320 if (err || !outarg->nodeid)
326 if (!fuse_valid_type(outarg->attr.mode))
329 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
330 &outarg->attr, entry_attr_timeout(outarg),
334 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
345 static struct dentry *fuse_materialise_dentry(struct dentry *dentry,
348 struct dentry *newent;
350 if (inode && S_ISDIR(inode->i_mode)) {
351 struct fuse_conn *fc = get_fuse_conn(inode);
353 mutex_lock(&fc->inst_mutex);
354 newent = d_materialise_unique(dentry, inode);
355 mutex_unlock(&fc->inst_mutex);
357 newent = d_materialise_unique(dentry, inode);
363 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
367 struct fuse_entry_out outarg;
369 struct dentry *newent;
370 bool outarg_valid = true;
372 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
374 if (err == -ENOENT) {
375 outarg_valid = false;
382 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
385 newent = fuse_materialise_dentry(entry, inode);
386 err = PTR_ERR(newent);
390 entry = newent ? newent : entry;
392 fuse_change_entry_timeout(entry, &outarg);
394 fuse_invalidate_entry_cache(entry);
396 fuse_advise_use_readdirplus(dir);
406 * Atomic create+open operation
408 * If the filesystem doesn't support this, then fall back to separate
409 * 'mknod' + 'open' requests.
411 static int fuse_create_open(struct inode *dir, struct dentry *entry,
412 struct file *file, unsigned flags,
413 umode_t mode, int *opened)
417 struct fuse_conn *fc = get_fuse_conn(dir);
418 struct fuse_req *req;
419 struct fuse_forget_link *forget;
420 struct fuse_create_in inarg;
421 struct fuse_open_out outopen;
422 struct fuse_entry_out outentry;
423 struct fuse_file *ff;
425 /* Userspace expects S_IFREG in create mode */
426 BUG_ON((mode & S_IFMT) != S_IFREG);
428 forget = fuse_alloc_forget();
433 req = fuse_get_req_nopages(fc);
436 goto out_put_forget_req;
439 ff = fuse_file_alloc(fc);
441 goto out_put_request;
444 mode &= ~current_umask();
447 memset(&inarg, 0, sizeof(inarg));
448 memset(&outentry, 0, sizeof(outentry));
451 inarg.umask = current_umask();
452 req->in.h.opcode = FUSE_CREATE;
453 req->in.h.nodeid = get_node_id(dir);
455 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
457 req->in.args[0].value = &inarg;
458 req->in.args[1].size = entry->d_name.len + 1;
459 req->in.args[1].value = entry->d_name.name;
460 req->out.numargs = 2;
462 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
464 req->out.args[0].size = sizeof(outentry);
465 req->out.args[0].value = &outentry;
466 req->out.args[1].size = sizeof(outopen);
467 req->out.args[1].value = &outopen;
468 fuse_request_send(fc, req);
469 err = req->out.h.error;
474 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
477 fuse_put_request(fc, req);
479 ff->nodeid = outentry.nodeid;
480 ff->open_flags = outopen.open_flags;
481 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
482 &outentry.attr, entry_attr_timeout(&outentry), 0);
484 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
485 fuse_sync_release(ff, flags);
486 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
491 d_instantiate(entry, inode);
492 fuse_change_entry_timeout(entry, &outentry);
493 fuse_invalidate_attr(dir);
494 err = finish_open(file, entry, generic_file_open, opened);
496 fuse_sync_release(ff, flags);
498 file->private_data = fuse_file_get(ff);
499 fuse_finish_open(inode, file);
506 fuse_put_request(fc, req);
513 static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
514 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
515 struct file *file, unsigned flags,
516 umode_t mode, int *opened)
519 struct fuse_conn *fc = get_fuse_conn(dir);
520 struct dentry *res = NULL;
522 if (d_unhashed(entry)) {
523 res = fuse_lookup(dir, entry, 0);
531 if (!(flags & O_CREAT) || entry->d_inode)
535 *opened |= FILE_CREATED;
540 err = fuse_create_open(dir, entry, file, flags, mode, opened);
541 if (err == -ENOSYS) {
550 err = fuse_mknod(dir, entry, mode, 0);
554 return finish_no_open(file, res);
558 * Code shared between mknod, mkdir, symlink and link
560 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
561 struct inode *dir, struct dentry *entry,
564 struct fuse_entry_out outarg;
567 struct fuse_forget_link *forget;
569 forget = fuse_alloc_forget();
571 fuse_put_request(fc, req);
575 memset(&outarg, 0, sizeof(outarg));
576 req->in.h.nodeid = get_node_id(dir);
577 req->out.numargs = 1;
579 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
581 req->out.args[0].size = sizeof(outarg);
582 req->out.args[0].value = &outarg;
583 fuse_request_send(fc, req);
584 err = req->out.h.error;
585 fuse_put_request(fc, req);
587 goto out_put_forget_req;
590 if (invalid_nodeid(outarg.nodeid))
591 goto out_put_forget_req;
593 if ((outarg.attr.mode ^ mode) & S_IFMT)
594 goto out_put_forget_req;
596 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
597 &outarg.attr, entry_attr_timeout(&outarg), 0);
599 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
604 if (S_ISDIR(inode->i_mode)) {
605 struct dentry *alias;
606 mutex_lock(&fc->inst_mutex);
607 alias = d_find_alias(inode);
609 /* New directory must have moved since mkdir */
610 mutex_unlock(&fc->inst_mutex);
615 d_instantiate(entry, inode);
616 mutex_unlock(&fc->inst_mutex);
618 d_instantiate(entry, inode);
620 fuse_change_entry_timeout(entry, &outarg);
621 fuse_invalidate_attr(dir);
629 static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
632 struct fuse_mknod_in inarg;
633 struct fuse_conn *fc = get_fuse_conn(dir);
634 struct fuse_req *req = fuse_get_req_nopages(fc);
639 mode &= ~current_umask();
641 memset(&inarg, 0, sizeof(inarg));
643 inarg.rdev = new_encode_dev(rdev);
644 inarg.umask = current_umask();
645 req->in.h.opcode = FUSE_MKNOD;
647 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
649 req->in.args[0].value = &inarg;
650 req->in.args[1].size = entry->d_name.len + 1;
651 req->in.args[1].value = entry->d_name.name;
652 return create_new_entry(fc, req, dir, entry, mode);
655 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
658 return fuse_mknod(dir, entry, mode, 0);
661 static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
663 struct fuse_mkdir_in inarg;
664 struct fuse_conn *fc = get_fuse_conn(dir);
665 struct fuse_req *req = fuse_get_req_nopages(fc);
670 mode &= ~current_umask();
672 memset(&inarg, 0, sizeof(inarg));
674 inarg.umask = current_umask();
675 req->in.h.opcode = FUSE_MKDIR;
677 req->in.args[0].size = sizeof(inarg);
678 req->in.args[0].value = &inarg;
679 req->in.args[1].size = entry->d_name.len + 1;
680 req->in.args[1].value = entry->d_name.name;
681 return create_new_entry(fc, req, dir, entry, S_IFDIR);
684 static int fuse_symlink(struct inode *dir, struct dentry *entry,
687 struct fuse_conn *fc = get_fuse_conn(dir);
688 unsigned len = strlen(link) + 1;
689 struct fuse_req *req = fuse_get_req_nopages(fc);
693 req->in.h.opcode = FUSE_SYMLINK;
695 req->in.args[0].size = entry->d_name.len + 1;
696 req->in.args[0].value = entry->d_name.name;
697 req->in.args[1].size = len;
698 req->in.args[1].value = link;
699 return create_new_entry(fc, req, dir, entry, S_IFLNK);
702 static int fuse_unlink(struct inode *dir, struct dentry *entry)
705 struct fuse_conn *fc = get_fuse_conn(dir);
706 struct fuse_req *req = fuse_get_req_nopages(fc);
710 req->in.h.opcode = FUSE_UNLINK;
711 req->in.h.nodeid = get_node_id(dir);
713 req->in.args[0].size = entry->d_name.len + 1;
714 req->in.args[0].value = entry->d_name.name;
715 fuse_request_send(fc, req);
716 err = req->out.h.error;
717 fuse_put_request(fc, req);
719 struct inode *inode = entry->d_inode;
720 struct fuse_inode *fi = get_fuse_inode(inode);
722 spin_lock(&fc->lock);
723 fi->attr_version = ++fc->attr_version;
725 * If i_nlink == 0 then unlink doesn't make sense, yet this can
726 * happen if userspace filesystem is careless. It would be
727 * difficult to enforce correct nlink usage so just ignore this
730 if (inode->i_nlink > 0)
732 spin_unlock(&fc->lock);
733 fuse_invalidate_attr(inode);
734 fuse_invalidate_attr(dir);
735 fuse_invalidate_entry_cache(entry);
736 } else if (err == -EINTR)
737 fuse_invalidate_entry(entry);
741 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
744 struct fuse_conn *fc = get_fuse_conn(dir);
745 struct fuse_req *req = fuse_get_req_nopages(fc);
749 req->in.h.opcode = FUSE_RMDIR;
750 req->in.h.nodeid = get_node_id(dir);
752 req->in.args[0].size = entry->d_name.len + 1;
753 req->in.args[0].value = entry->d_name.name;
754 fuse_request_send(fc, req);
755 err = req->out.h.error;
756 fuse_put_request(fc, req);
758 clear_nlink(entry->d_inode);
759 fuse_invalidate_attr(dir);
760 fuse_invalidate_entry_cache(entry);
761 } else if (err == -EINTR)
762 fuse_invalidate_entry(entry);
766 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
767 struct inode *newdir, struct dentry *newent)
770 struct fuse_rename_in inarg;
771 struct fuse_conn *fc = get_fuse_conn(olddir);
772 struct fuse_req *req = fuse_get_req_nopages(fc);
777 memset(&inarg, 0, sizeof(inarg));
778 inarg.newdir = get_node_id(newdir);
779 req->in.h.opcode = FUSE_RENAME;
780 req->in.h.nodeid = get_node_id(olddir);
782 req->in.args[0].size = sizeof(inarg);
783 req->in.args[0].value = &inarg;
784 req->in.args[1].size = oldent->d_name.len + 1;
785 req->in.args[1].value = oldent->d_name.name;
786 req->in.args[2].size = newent->d_name.len + 1;
787 req->in.args[2].value = newent->d_name.name;
788 fuse_request_send(fc, req);
789 err = req->out.h.error;
790 fuse_put_request(fc, req);
793 fuse_invalidate_attr(oldent->d_inode);
795 fuse_invalidate_attr(olddir);
796 if (olddir != newdir)
797 fuse_invalidate_attr(newdir);
799 /* newent will end up negative */
800 if (newent->d_inode) {
801 fuse_invalidate_attr(newent->d_inode);
802 fuse_invalidate_entry_cache(newent);
804 } else if (err == -EINTR) {
805 /* If request was interrupted, DEITY only knows if the
806 rename actually took place. If the invalidation
807 fails (e.g. some process has CWD under the renamed
808 directory), then there can be inconsistency between
809 the dcache and the real filesystem. Tough luck. */
810 fuse_invalidate_entry(oldent);
812 fuse_invalidate_entry(newent);
818 static int fuse_link(struct dentry *entry, struct inode *newdir,
819 struct dentry *newent)
822 struct fuse_link_in inarg;
823 struct inode *inode = entry->d_inode;
824 struct fuse_conn *fc = get_fuse_conn(inode);
825 struct fuse_req *req = fuse_get_req_nopages(fc);
829 memset(&inarg, 0, sizeof(inarg));
830 inarg.oldnodeid = get_node_id(inode);
831 req->in.h.opcode = FUSE_LINK;
833 req->in.args[0].size = sizeof(inarg);
834 req->in.args[0].value = &inarg;
835 req->in.args[1].size = newent->d_name.len + 1;
836 req->in.args[1].value = newent->d_name.name;
837 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
838 /* Contrary to "normal" filesystems it can happen that link
839 makes two "logical" inodes point to the same "physical"
840 inode. We invalidate the attributes of the old one, so it
841 will reflect changes in the backing inode (link count,
845 struct fuse_inode *fi = get_fuse_inode(inode);
847 spin_lock(&fc->lock);
848 fi->attr_version = ++fc->attr_version;
850 spin_unlock(&fc->lock);
851 fuse_invalidate_attr(inode);
852 } else if (err == -EINTR) {
853 fuse_invalidate_attr(inode);
858 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
861 unsigned int blkbits;
863 stat->dev = inode->i_sb->s_dev;
864 stat->ino = attr->ino;
865 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
866 stat->nlink = attr->nlink;
867 stat->uid = make_kuid(&init_user_ns, attr->uid);
868 stat->gid = make_kgid(&init_user_ns, attr->gid);
869 stat->rdev = inode->i_rdev;
870 stat->atime.tv_sec = attr->atime;
871 stat->atime.tv_nsec = attr->atimensec;
872 stat->mtime.tv_sec = attr->mtime;
873 stat->mtime.tv_nsec = attr->mtimensec;
874 stat->ctime.tv_sec = attr->ctime;
875 stat->ctime.tv_nsec = attr->ctimensec;
876 stat->size = attr->size;
877 stat->blocks = attr->blocks;
879 if (attr->blksize != 0)
880 blkbits = ilog2(attr->blksize);
882 blkbits = inode->i_sb->s_blocksize_bits;
884 stat->blksize = 1 << blkbits;
887 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
891 struct fuse_getattr_in inarg;
892 struct fuse_attr_out outarg;
893 struct fuse_conn *fc = get_fuse_conn(inode);
894 struct fuse_req *req;
897 req = fuse_get_req_nopages(fc);
901 attr_version = fuse_get_attr_version(fc);
903 memset(&inarg, 0, sizeof(inarg));
904 memset(&outarg, 0, sizeof(outarg));
905 /* Directories have separate file-handle space */
906 if (file && S_ISREG(inode->i_mode)) {
907 struct fuse_file *ff = file->private_data;
909 inarg.getattr_flags |= FUSE_GETATTR_FH;
912 req->in.h.opcode = FUSE_GETATTR;
913 req->in.h.nodeid = get_node_id(inode);
915 req->in.args[0].size = sizeof(inarg);
916 req->in.args[0].value = &inarg;
917 req->out.numargs = 1;
919 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
921 req->out.args[0].size = sizeof(outarg);
922 req->out.args[0].value = &outarg;
923 fuse_request_send(fc, req);
924 err = req->out.h.error;
925 fuse_put_request(fc, req);
927 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
928 make_bad_inode(inode);
931 fuse_change_attributes(inode, &outarg.attr,
932 attr_timeout(&outarg),
935 fuse_fillattr(inode, &outarg.attr, stat);
941 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
942 struct file *file, bool *refreshed)
944 struct fuse_inode *fi = get_fuse_inode(inode);
948 if (fi->i_time < get_jiffies_64()) {
950 err = fuse_do_getattr(inode, stat, file);
955 generic_fillattr(inode, stat);
956 stat->mode = fi->orig_i_mode;
957 stat->ino = fi->orig_ino;
961 if (refreshed != NULL)
967 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
968 u64 child_nodeid, struct qstr *name)
971 struct inode *parent;
973 struct dentry *entry;
975 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
979 mutex_lock(&parent->i_mutex);
980 if (!S_ISDIR(parent->i_mode))
984 dir = d_find_alias(parent);
988 entry = d_lookup(dir, name);
993 fuse_invalidate_attr(parent);
994 fuse_invalidate_entry(entry);
996 if (child_nodeid != 0 && entry->d_inode) {
997 mutex_lock(&entry->d_inode->i_mutex);
998 if (get_node_id(entry->d_inode) != child_nodeid) {
1002 if (d_mountpoint(entry)) {
1006 if (S_ISDIR(entry->d_inode->i_mode)) {
1007 shrink_dcache_parent(entry);
1008 if (!simple_empty(entry)) {
1012 entry->d_inode->i_flags |= S_DEAD;
1015 clear_nlink(entry->d_inode);
1018 mutex_unlock(&entry->d_inode->i_mutex);
1027 mutex_unlock(&parent->i_mutex);
1033 * Calling into a user-controlled filesystem gives the filesystem
1034 * daemon ptrace-like capabilities over the current process. This
1035 * means, that the filesystem daemon is able to record the exact
1036 * filesystem operations performed, and can also control the behavior
1037 * of the requester process in otherwise impossible ways. For example
1038 * it can delay the operation for arbitrary length of time allowing
1039 * DoS against the requester.
1041 * For this reason only those processes can call into the filesystem,
1042 * for which the owner of the mount has ptrace privilege. This
1043 * excludes processes started by other users, suid or sgid processes.
1045 int fuse_allow_current_process(struct fuse_conn *fc)
1047 const struct cred *cred;
1049 if (fc->flags & FUSE_ALLOW_OTHER)
1052 cred = current_cred();
1053 if (uid_eq(cred->euid, fc->user_id) &&
1054 uid_eq(cred->suid, fc->user_id) &&
1055 uid_eq(cred->uid, fc->user_id) &&
1056 gid_eq(cred->egid, fc->group_id) &&
1057 gid_eq(cred->sgid, fc->group_id) &&
1058 gid_eq(cred->gid, fc->group_id))
1064 static int fuse_access(struct inode *inode, int mask)
1066 struct fuse_conn *fc = get_fuse_conn(inode);
1067 struct fuse_req *req;
1068 struct fuse_access_in inarg;
1071 BUG_ON(mask & MAY_NOT_BLOCK);
1076 req = fuse_get_req_nopages(fc);
1078 return PTR_ERR(req);
1080 memset(&inarg, 0, sizeof(inarg));
1081 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1082 req->in.h.opcode = FUSE_ACCESS;
1083 req->in.h.nodeid = get_node_id(inode);
1084 req->in.numargs = 1;
1085 req->in.args[0].size = sizeof(inarg);
1086 req->in.args[0].value = &inarg;
1087 fuse_request_send(fc, req);
1088 err = req->out.h.error;
1089 fuse_put_request(fc, req);
1090 if (err == -ENOSYS) {
1097 static int fuse_perm_getattr(struct inode *inode, int mask)
1099 if (mask & MAY_NOT_BLOCK)
1102 return fuse_do_getattr(inode, NULL, NULL);
1106 * Check permission. The two basic access models of FUSE are:
1108 * 1) Local access checking ('default_permissions' mount option) based
1109 * on file mode. This is the plain old disk filesystem permission
1112 * 2) "Remote" access checking, where server is responsible for
1113 * checking permission in each inode operation. An exception to this
1114 * is if ->permission() was invoked from sys_access() in which case an
1115 * access request is sent. Execute permission is still checked
1116 * locally based on file mode.
1118 static int fuse_permission(struct inode *inode, int mask)
1120 struct fuse_conn *fc = get_fuse_conn(inode);
1121 bool refreshed = false;
1124 if (!fuse_allow_current_process(fc))
1128 * If attributes are needed, refresh them before proceeding
1130 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1131 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1132 struct fuse_inode *fi = get_fuse_inode(inode);
1134 if (fi->i_time < get_jiffies_64()) {
1137 err = fuse_perm_getattr(inode, mask);
1143 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1144 err = generic_permission(inode, mask);
1146 /* If permission is denied, try to refresh file
1147 attributes. This is also needed, because the root
1148 node will at first have no permissions */
1149 if (err == -EACCES && !refreshed) {
1150 err = fuse_perm_getattr(inode, mask);
1152 err = generic_permission(inode, mask);
1155 /* Note: the opposite of the above test does not
1156 exist. So if permissions are revoked this won't be
1157 noticed immediately, only after the attribute
1158 timeout has expired */
1159 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1160 err = fuse_access(inode, mask);
1161 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1162 if (!(inode->i_mode & S_IXUGO)) {
1166 err = fuse_perm_getattr(inode, mask);
1167 if (!err && !(inode->i_mode & S_IXUGO))
1174 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1175 struct dir_context *ctx)
1177 while (nbytes >= FUSE_NAME_OFFSET) {
1178 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1179 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1180 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1182 if (reclen > nbytes)
1184 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1187 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1188 dirent->ino, dirent->type))
1193 ctx->pos = dirent->off;
1199 static int fuse_direntplus_link(struct file *file,
1200 struct fuse_direntplus *direntplus,
1204 struct fuse_entry_out *o = &direntplus->entry_out;
1205 struct fuse_dirent *dirent = &direntplus->dirent;
1206 struct dentry *parent = file->f_path.dentry;
1207 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1208 struct dentry *dentry;
1209 struct dentry *alias;
1210 struct inode *dir = parent->d_inode;
1211 struct fuse_conn *fc;
1212 struct inode *inode;
1216 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1217 * ENOENT. Instead, it only means the userspace filesystem did
1218 * not want to return attributes/handle for this entry.
1225 if (name.name[0] == '.') {
1227 * We could potentially refresh the attributes of the directory
1232 if (name.name[1] == '.' && name.len == 2)
1236 if (invalid_nodeid(o->nodeid))
1238 if (!fuse_valid_type(o->attr.mode))
1241 fc = get_fuse_conn(dir);
1243 name.hash = full_name_hash(name.name, name.len);
1244 dentry = d_lookup(parent, &name);
1246 inode = dentry->d_inode;
1249 } else if (get_node_id(inode) != o->nodeid ||
1250 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1251 err = d_invalidate(dentry);
1254 } else if (is_bad_inode(inode)) {
1258 struct fuse_inode *fi;
1259 fi = get_fuse_inode(inode);
1260 spin_lock(&fc->lock);
1262 spin_unlock(&fc->lock);
1264 fuse_change_attributes(inode, &o->attr,
1265 entry_attr_timeout(o),
1269 * The other branch to 'found' comes via fuse_iget()
1270 * which bumps nlookup inside
1277 dentry = d_alloc(parent, &name);
1282 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1283 &o->attr, entry_attr_timeout(o), attr_version);
1287 alias = fuse_materialise_dentry(dentry, inode);
1288 err = PTR_ERR(alias);
1298 if (fc->readdirplus_auto)
1299 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1300 fuse_change_entry_timeout(dentry, o);
1308 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1309 struct dir_context *ctx, u64 attr_version)
1311 struct fuse_direntplus *direntplus;
1312 struct fuse_dirent *dirent;
1317 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1318 direntplus = (struct fuse_direntplus *) buf;
1319 dirent = &direntplus->dirent;
1320 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1322 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1324 if (reclen > nbytes)
1326 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1330 /* We fill entries into dstbuf only as much as
1331 it can hold. But we still continue iterating
1332 over remaining entries to link them. If not,
1333 we need to send a FORGET for each of those
1334 which we did not link.
1336 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1337 dirent->ino, dirent->type);
1338 ctx->pos = dirent->off;
1344 ret = fuse_direntplus_link(file, direntplus, attr_version);
1346 fuse_force_forget(file, direntplus->entry_out.nodeid);
1352 static int fuse_readdir(struct file *file, struct dir_context *ctx)
1357 struct inode *inode = file_inode(file);
1358 struct fuse_conn *fc = get_fuse_conn(inode);
1359 struct fuse_req *req;
1360 u64 attr_version = 0;
1362 if (is_bad_inode(inode))
1365 req = fuse_get_req(fc, 1);
1367 return PTR_ERR(req);
1369 page = alloc_page(GFP_KERNEL);
1371 fuse_put_request(fc, req);
1375 plus = fuse_use_readdirplus(inode, ctx);
1376 req->out.argpages = 1;
1378 req->pages[0] = page;
1379 req->page_descs[0].length = PAGE_SIZE;
1381 attr_version = fuse_get_attr_version(fc);
1382 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1385 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1388 fuse_request_send(fc, req);
1389 nbytes = req->out.args[0].size;
1390 err = req->out.h.error;
1391 fuse_put_request(fc, req);
1394 err = parse_dirplusfile(page_address(page), nbytes,
1398 err = parse_dirfile(page_address(page), nbytes, file,
1404 fuse_invalidate_attr(inode); /* atime changed */
1408 static char *read_link(struct dentry *dentry)
1410 struct inode *inode = dentry->d_inode;
1411 struct fuse_conn *fc = get_fuse_conn(inode);
1412 struct fuse_req *req = fuse_get_req_nopages(fc);
1416 return ERR_CAST(req);
1418 link = (char *) __get_free_page(GFP_KERNEL);
1420 link = ERR_PTR(-ENOMEM);
1423 req->in.h.opcode = FUSE_READLINK;
1424 req->in.h.nodeid = get_node_id(inode);
1425 req->out.argvar = 1;
1426 req->out.numargs = 1;
1427 req->out.args[0].size = PAGE_SIZE - 1;
1428 req->out.args[0].value = link;
1429 fuse_request_send(fc, req);
1430 if (req->out.h.error) {
1431 free_page((unsigned long) link);
1432 link = ERR_PTR(req->out.h.error);
1434 link[req->out.args[0].size] = '\0';
1436 fuse_put_request(fc, req);
1437 fuse_invalidate_attr(inode); /* atime changed */
1441 static void free_link(char *link)
1444 free_page((unsigned long) link);
1447 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1449 nd_set_link(nd, read_link(dentry));
1453 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1455 free_link(nd_get_link(nd));
1458 static int fuse_dir_open(struct inode *inode, struct file *file)
1460 return fuse_open_common(inode, file, true);
1463 static int fuse_dir_release(struct inode *inode, struct file *file)
1465 fuse_release_common(file, FUSE_RELEASEDIR);
1470 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1473 return fuse_fsync_common(file, start, end, datasync, 1);
1476 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1479 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1481 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1485 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1488 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1491 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1496 return fuse_ioctl_common(file, cmd, arg,
1497 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1500 static bool update_mtime(unsigned ivalid)
1502 /* Always update if mtime is explicitly set */
1503 if (ivalid & ATTR_MTIME_SET)
1506 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1507 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1510 /* In all other cases update */
1514 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1516 unsigned ivalid = iattr->ia_valid;
1518 if (ivalid & ATTR_MODE)
1519 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1520 if (ivalid & ATTR_UID)
1521 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
1522 if (ivalid & ATTR_GID)
1523 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
1524 if (ivalid & ATTR_SIZE)
1525 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1526 if (ivalid & ATTR_ATIME) {
1527 arg->valid |= FATTR_ATIME;
1528 arg->atime = iattr->ia_atime.tv_sec;
1529 arg->atimensec = iattr->ia_atime.tv_nsec;
1530 if (!(ivalid & ATTR_ATIME_SET))
1531 arg->valid |= FATTR_ATIME_NOW;
1533 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1534 arg->valid |= FATTR_MTIME;
1535 arg->mtime = iattr->ia_mtime.tv_sec;
1536 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1537 if (!(ivalid & ATTR_MTIME_SET))
1538 arg->valid |= FATTR_MTIME_NOW;
1543 * Prevent concurrent writepages on inode
1545 * This is done by adding a negative bias to the inode write counter
1546 * and waiting for all pending writes to finish.
1548 void fuse_set_nowrite(struct inode *inode)
1550 struct fuse_conn *fc = get_fuse_conn(inode);
1551 struct fuse_inode *fi = get_fuse_inode(inode);
1553 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1555 spin_lock(&fc->lock);
1556 BUG_ON(fi->writectr < 0);
1557 fi->writectr += FUSE_NOWRITE;
1558 spin_unlock(&fc->lock);
1559 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1563 * Allow writepages on inode
1565 * Remove the bias from the writecounter and send any queued
1568 static void __fuse_release_nowrite(struct inode *inode)
1570 struct fuse_inode *fi = get_fuse_inode(inode);
1572 BUG_ON(fi->writectr != FUSE_NOWRITE);
1574 fuse_flush_writepages(inode);
1577 void fuse_release_nowrite(struct inode *inode)
1579 struct fuse_conn *fc = get_fuse_conn(inode);
1581 spin_lock(&fc->lock);
1582 __fuse_release_nowrite(inode);
1583 spin_unlock(&fc->lock);
1587 * Set attributes, and at the same time refresh them.
1589 * Truncation is slightly complicated, because the 'truncate' request
1590 * may fail, in which case we don't want to touch the mapping.
1591 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1592 * and the actual truncation by hand.
1594 int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1597 struct fuse_conn *fc = get_fuse_conn(inode);
1598 struct fuse_inode *fi = get_fuse_inode(inode);
1599 struct fuse_req *req;
1600 struct fuse_setattr_in inarg;
1601 struct fuse_attr_out outarg;
1602 bool is_truncate = false;
1606 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1607 attr->ia_valid |= ATTR_FORCE;
1609 err = inode_change_ok(inode, attr);
1613 if (attr->ia_valid & ATTR_OPEN) {
1614 if (fc->atomic_o_trunc)
1619 if (attr->ia_valid & ATTR_SIZE)
1622 req = fuse_get_req_nopages(fc);
1624 return PTR_ERR(req);
1627 fuse_set_nowrite(inode);
1628 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1631 memset(&inarg, 0, sizeof(inarg));
1632 memset(&outarg, 0, sizeof(outarg));
1633 iattr_to_fattr(attr, &inarg);
1635 struct fuse_file *ff = file->private_data;
1636 inarg.valid |= FATTR_FH;
1639 if (attr->ia_valid & ATTR_SIZE) {
1640 /* For mandatory locking in truncate */
1641 inarg.valid |= FATTR_LOCKOWNER;
1642 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1644 req->in.h.opcode = FUSE_SETATTR;
1645 req->in.h.nodeid = get_node_id(inode);
1646 req->in.numargs = 1;
1647 req->in.args[0].size = sizeof(inarg);
1648 req->in.args[0].value = &inarg;
1649 req->out.numargs = 1;
1651 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1653 req->out.args[0].size = sizeof(outarg);
1654 req->out.args[0].value = &outarg;
1655 fuse_request_send(fc, req);
1656 err = req->out.h.error;
1657 fuse_put_request(fc, req);
1660 fuse_invalidate_attr(inode);
1664 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1665 make_bad_inode(inode);
1670 spin_lock(&fc->lock);
1671 fuse_change_attributes_common(inode, &outarg.attr,
1672 attr_timeout(&outarg));
1673 oldsize = inode->i_size;
1674 i_size_write(inode, outarg.attr.size);
1677 /* NOTE: this may release/reacquire fc->lock */
1678 __fuse_release_nowrite(inode);
1680 spin_unlock(&fc->lock);
1683 * Only call invalidate_inode_pages2() after removing
1684 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1686 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1687 truncate_pagecache(inode, outarg.attr.size);
1688 invalidate_inode_pages2(inode->i_mapping);
1691 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1696 fuse_release_nowrite(inode);
1698 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1702 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1704 struct inode *inode = entry->d_inode;
1706 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1709 if (attr->ia_valid & ATTR_FILE)
1710 return fuse_do_setattr(inode, attr, attr->ia_file);
1712 return fuse_do_setattr(inode, attr, NULL);
1715 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1718 struct inode *inode = entry->d_inode;
1719 struct fuse_conn *fc = get_fuse_conn(inode);
1721 if (!fuse_allow_current_process(fc))
1724 return fuse_update_attributes(inode, stat, NULL, NULL);
1727 static int fuse_setxattr(struct dentry *entry, const char *name,
1728 const void *value, size_t size, int flags)
1730 struct inode *inode = entry->d_inode;
1731 struct fuse_conn *fc = get_fuse_conn(inode);
1732 struct fuse_req *req;
1733 struct fuse_setxattr_in inarg;
1736 if (fc->no_setxattr)
1739 req = fuse_get_req_nopages(fc);
1741 return PTR_ERR(req);
1743 memset(&inarg, 0, sizeof(inarg));
1745 inarg.flags = flags;
1746 req->in.h.opcode = FUSE_SETXATTR;
1747 req->in.h.nodeid = get_node_id(inode);
1748 req->in.numargs = 3;
1749 req->in.args[0].size = sizeof(inarg);
1750 req->in.args[0].value = &inarg;
1751 req->in.args[1].size = strlen(name) + 1;
1752 req->in.args[1].value = name;
1753 req->in.args[2].size = size;
1754 req->in.args[2].value = value;
1755 fuse_request_send(fc, req);
1756 err = req->out.h.error;
1757 fuse_put_request(fc, req);
1758 if (err == -ENOSYS) {
1759 fc->no_setxattr = 1;
1763 fuse_invalidate_attr(inode);
1767 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1768 void *value, size_t size)
1770 struct inode *inode = entry->d_inode;
1771 struct fuse_conn *fc = get_fuse_conn(inode);
1772 struct fuse_req *req;
1773 struct fuse_getxattr_in inarg;
1774 struct fuse_getxattr_out outarg;
1777 if (fc->no_getxattr)
1780 req = fuse_get_req_nopages(fc);
1782 return PTR_ERR(req);
1784 memset(&inarg, 0, sizeof(inarg));
1786 req->in.h.opcode = FUSE_GETXATTR;
1787 req->in.h.nodeid = get_node_id(inode);
1788 req->in.numargs = 2;
1789 req->in.args[0].size = sizeof(inarg);
1790 req->in.args[0].value = &inarg;
1791 req->in.args[1].size = strlen(name) + 1;
1792 req->in.args[1].value = name;
1793 /* This is really two different operations rolled into one */
1794 req->out.numargs = 1;
1796 req->out.argvar = 1;
1797 req->out.args[0].size = size;
1798 req->out.args[0].value = value;
1800 req->out.args[0].size = sizeof(outarg);
1801 req->out.args[0].value = &outarg;
1803 fuse_request_send(fc, req);
1804 ret = req->out.h.error;
1806 ret = size ? req->out.args[0].size : outarg.size;
1808 if (ret == -ENOSYS) {
1809 fc->no_getxattr = 1;
1813 fuse_put_request(fc, req);
1817 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1819 struct inode *inode = entry->d_inode;
1820 struct fuse_conn *fc = get_fuse_conn(inode);
1821 struct fuse_req *req;
1822 struct fuse_getxattr_in inarg;
1823 struct fuse_getxattr_out outarg;
1826 if (!fuse_allow_current_process(fc))
1829 if (fc->no_listxattr)
1832 req = fuse_get_req_nopages(fc);
1834 return PTR_ERR(req);
1836 memset(&inarg, 0, sizeof(inarg));
1838 req->in.h.opcode = FUSE_LISTXATTR;
1839 req->in.h.nodeid = get_node_id(inode);
1840 req->in.numargs = 1;
1841 req->in.args[0].size = sizeof(inarg);
1842 req->in.args[0].value = &inarg;
1843 /* This is really two different operations rolled into one */
1844 req->out.numargs = 1;
1846 req->out.argvar = 1;
1847 req->out.args[0].size = size;
1848 req->out.args[0].value = list;
1850 req->out.args[0].size = sizeof(outarg);
1851 req->out.args[0].value = &outarg;
1853 fuse_request_send(fc, req);
1854 ret = req->out.h.error;
1856 ret = size ? req->out.args[0].size : outarg.size;
1858 if (ret == -ENOSYS) {
1859 fc->no_listxattr = 1;
1863 fuse_put_request(fc, req);
1867 static int fuse_removexattr(struct dentry *entry, const char *name)
1869 struct inode *inode = entry->d_inode;
1870 struct fuse_conn *fc = get_fuse_conn(inode);
1871 struct fuse_req *req;
1874 if (fc->no_removexattr)
1877 req = fuse_get_req_nopages(fc);
1879 return PTR_ERR(req);
1881 req->in.h.opcode = FUSE_REMOVEXATTR;
1882 req->in.h.nodeid = get_node_id(inode);
1883 req->in.numargs = 1;
1884 req->in.args[0].size = strlen(name) + 1;
1885 req->in.args[0].value = name;
1886 fuse_request_send(fc, req);
1887 err = req->out.h.error;
1888 fuse_put_request(fc, req);
1889 if (err == -ENOSYS) {
1890 fc->no_removexattr = 1;
1894 fuse_invalidate_attr(inode);
1898 static const struct inode_operations fuse_dir_inode_operations = {
1899 .lookup = fuse_lookup,
1900 .mkdir = fuse_mkdir,
1901 .symlink = fuse_symlink,
1902 .unlink = fuse_unlink,
1903 .rmdir = fuse_rmdir,
1904 .rename = fuse_rename,
1906 .setattr = fuse_setattr,
1907 .create = fuse_create,
1908 .atomic_open = fuse_atomic_open,
1909 .mknod = fuse_mknod,
1910 .permission = fuse_permission,
1911 .getattr = fuse_getattr,
1912 .setxattr = fuse_setxattr,
1913 .getxattr = fuse_getxattr,
1914 .listxattr = fuse_listxattr,
1915 .removexattr = fuse_removexattr,
1918 static const struct file_operations fuse_dir_operations = {
1919 .llseek = generic_file_llseek,
1920 .read = generic_read_dir,
1921 .iterate = fuse_readdir,
1922 .open = fuse_dir_open,
1923 .release = fuse_dir_release,
1924 .fsync = fuse_dir_fsync,
1925 .unlocked_ioctl = fuse_dir_ioctl,
1926 .compat_ioctl = fuse_dir_compat_ioctl,
1929 static const struct inode_operations fuse_common_inode_operations = {
1930 .setattr = fuse_setattr,
1931 .permission = fuse_permission,
1932 .getattr = fuse_getattr,
1933 .setxattr = fuse_setxattr,
1934 .getxattr = fuse_getxattr,
1935 .listxattr = fuse_listxattr,
1936 .removexattr = fuse_removexattr,
1939 static const struct inode_operations fuse_symlink_inode_operations = {
1940 .setattr = fuse_setattr,
1941 .follow_link = fuse_follow_link,
1942 .put_link = fuse_put_link,
1943 .readlink = generic_readlink,
1944 .getattr = fuse_getattr,
1945 .setxattr = fuse_setxattr,
1946 .getxattr = fuse_getxattr,
1947 .listxattr = fuse_listxattr,
1948 .removexattr = fuse_removexattr,
1951 void fuse_init_common(struct inode *inode)
1953 inode->i_op = &fuse_common_inode_operations;
1956 void fuse_init_dir(struct inode *inode)
1958 inode->i_op = &fuse_dir_inode_operations;
1959 inode->i_fop = &fuse_dir_operations;
1962 void fuse_init_symlink(struct inode *inode)
1964 inode->i_op = &fuse_symlink_inode_operations;