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 file *filp)
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;
186 inode = ACCESS_ONCE(entry->d_inode);
187 if (inode && is_bad_inode(inode))
189 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
191 struct fuse_entry_out outarg;
192 struct fuse_req *req;
193 struct fuse_forget_link *forget;
196 /* For negative dentries, always do a fresh lookup */
200 if (flags & LOOKUP_RCU)
203 fc = get_fuse_conn(inode);
204 req = fuse_get_req_nopages(fc);
208 forget = fuse_alloc_forget();
210 fuse_put_request(fc, req);
214 attr_version = fuse_get_attr_version(fc);
216 parent = dget_parent(entry);
217 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
218 &entry->d_name, &outarg);
219 fuse_request_send(fc, req);
221 err = req->out.h.error;
222 fuse_put_request(fc, req);
223 /* Zero nodeid is same as -ENOENT */
224 if (!err && !outarg.nodeid)
227 struct fuse_inode *fi = get_fuse_inode(inode);
228 if (outarg.nodeid != get_node_id(inode)) {
229 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
232 spin_lock(&fc->lock);
234 spin_unlock(&fc->lock);
237 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
240 fuse_change_attributes(inode, &outarg.attr,
241 entry_attr_timeout(&outarg),
243 fuse_change_entry_timeout(entry, &outarg);
245 fc = get_fuse_conn(inode);
246 if (fc->readdirplus_auto) {
247 parent = dget_parent(entry);
248 fuse_advise_use_readdirplus(parent->d_inode);
255 static int invalid_nodeid(u64 nodeid)
257 return !nodeid || nodeid == FUSE_ROOT_ID;
260 const struct dentry_operations fuse_dentry_operations = {
261 .d_revalidate = fuse_dentry_revalidate,
264 int fuse_valid_type(int m)
266 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
267 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
271 * Add a directory inode to a dentry, ensuring that no other dentry
272 * refers to this inode. Called with fc->inst_mutex.
274 static struct dentry *fuse_d_add_directory(struct dentry *entry,
277 struct dentry *alias = d_find_alias(inode);
278 if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
279 /* This tries to shrink the subtree below alias */
280 fuse_invalidate_entry(alias);
282 if (!hlist_empty(&inode->i_dentry))
283 return ERR_PTR(-EBUSY);
287 return d_splice_alias(inode, entry);
290 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
291 struct fuse_entry_out *outarg, struct inode **inode)
293 struct fuse_conn *fc = get_fuse_conn_super(sb);
294 struct fuse_req *req;
295 struct fuse_forget_link *forget;
301 if (name->len > FUSE_NAME_MAX)
304 req = fuse_get_req_nopages(fc);
309 forget = fuse_alloc_forget();
312 fuse_put_request(fc, req);
316 attr_version = fuse_get_attr_version(fc);
318 fuse_lookup_init(fc, req, nodeid, name, outarg);
319 fuse_request_send(fc, req);
320 err = req->out.h.error;
321 fuse_put_request(fc, req);
322 /* Zero nodeid is same as -ENOENT, but with valid timeout */
323 if (err || !outarg->nodeid)
329 if (!fuse_valid_type(outarg->attr.mode))
332 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
333 &outarg->attr, entry_attr_timeout(outarg),
337 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
348 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
352 struct fuse_entry_out outarg;
354 struct dentry *newent;
355 struct fuse_conn *fc = get_fuse_conn(dir);
356 bool outarg_valid = true;
358 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
360 if (err == -ENOENT) {
361 outarg_valid = false;
368 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
371 if (inode && S_ISDIR(inode->i_mode)) {
372 mutex_lock(&fc->inst_mutex);
373 newent = fuse_d_add_directory(entry, inode);
374 mutex_unlock(&fc->inst_mutex);
375 err = PTR_ERR(newent);
379 newent = d_splice_alias(inode, entry);
382 entry = newent ? newent : entry;
384 fuse_change_entry_timeout(entry, &outarg);
386 fuse_invalidate_entry_cache(entry);
388 fuse_advise_use_readdirplus(dir);
398 * Atomic create+open operation
400 * If the filesystem doesn't support this, then fall back to separate
401 * 'mknod' + 'open' requests.
403 static int fuse_create_open(struct inode *dir, struct dentry *entry,
404 struct file *file, unsigned flags,
405 umode_t mode, int *opened)
409 struct fuse_conn *fc = get_fuse_conn(dir);
410 struct fuse_req *req;
411 struct fuse_forget_link *forget;
412 struct fuse_create_in inarg;
413 struct fuse_open_out outopen;
414 struct fuse_entry_out outentry;
415 struct fuse_file *ff;
417 /* Userspace expects S_IFREG in create mode */
418 BUG_ON((mode & S_IFMT) != S_IFREG);
420 forget = fuse_alloc_forget();
425 req = fuse_get_req_nopages(fc);
428 goto out_put_forget_req;
431 ff = fuse_file_alloc(fc);
433 goto out_put_request;
436 mode &= ~current_umask();
439 memset(&inarg, 0, sizeof(inarg));
440 memset(&outentry, 0, sizeof(outentry));
443 inarg.umask = current_umask();
444 req->in.h.opcode = FUSE_CREATE;
445 req->in.h.nodeid = get_node_id(dir);
447 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
449 req->in.args[0].value = &inarg;
450 req->in.args[1].size = entry->d_name.len + 1;
451 req->in.args[1].value = entry->d_name.name;
452 req->out.numargs = 2;
454 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
456 req->out.args[0].size = sizeof(outentry);
457 req->out.args[0].value = &outentry;
458 req->out.args[1].size = sizeof(outopen);
459 req->out.args[1].value = &outopen;
460 fuse_request_send(fc, req);
461 err = req->out.h.error;
466 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
469 fuse_put_request(fc, req);
471 ff->nodeid = outentry.nodeid;
472 ff->open_flags = outopen.open_flags;
473 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
474 &outentry.attr, entry_attr_timeout(&outentry), 0);
476 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
477 fuse_sync_release(ff, flags);
478 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
483 d_instantiate(entry, inode);
484 fuse_change_entry_timeout(entry, &outentry);
485 fuse_invalidate_attr(dir);
486 err = finish_open(file, entry, generic_file_open, opened);
488 fuse_sync_release(ff, flags);
490 file->private_data = fuse_file_get(ff);
491 fuse_finish_open(inode, file);
498 fuse_put_request(fc, req);
505 static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
506 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
507 struct file *file, unsigned flags,
508 umode_t mode, int *opened)
511 struct fuse_conn *fc = get_fuse_conn(dir);
512 struct dentry *res = NULL;
514 if (d_unhashed(entry)) {
515 res = fuse_lookup(dir, entry, 0);
523 if (!(flags & O_CREAT) || entry->d_inode)
527 *opened |= FILE_CREATED;
532 err = fuse_create_open(dir, entry, file, flags, mode, opened);
533 if (err == -ENOSYS) {
542 err = fuse_mknod(dir, entry, mode, 0);
546 return finish_no_open(file, res);
550 * Code shared between mknod, mkdir, symlink and link
552 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
553 struct inode *dir, struct dentry *entry,
556 struct fuse_entry_out outarg;
559 struct fuse_forget_link *forget;
561 forget = fuse_alloc_forget();
563 fuse_put_request(fc, req);
567 memset(&outarg, 0, sizeof(outarg));
568 req->in.h.nodeid = get_node_id(dir);
569 req->out.numargs = 1;
571 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
573 req->out.args[0].size = sizeof(outarg);
574 req->out.args[0].value = &outarg;
575 fuse_request_send(fc, req);
576 err = req->out.h.error;
577 fuse_put_request(fc, req);
579 goto out_put_forget_req;
582 if (invalid_nodeid(outarg.nodeid))
583 goto out_put_forget_req;
585 if ((outarg.attr.mode ^ mode) & S_IFMT)
586 goto out_put_forget_req;
588 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
589 &outarg.attr, entry_attr_timeout(&outarg), 0);
591 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
596 if (S_ISDIR(inode->i_mode)) {
597 struct dentry *alias;
598 mutex_lock(&fc->inst_mutex);
599 alias = d_find_alias(inode);
601 /* New directory must have moved since mkdir */
602 mutex_unlock(&fc->inst_mutex);
607 d_instantiate(entry, inode);
608 mutex_unlock(&fc->inst_mutex);
610 d_instantiate(entry, inode);
612 fuse_change_entry_timeout(entry, &outarg);
613 fuse_invalidate_attr(dir);
621 static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
624 struct fuse_mknod_in inarg;
625 struct fuse_conn *fc = get_fuse_conn(dir);
626 struct fuse_req *req = fuse_get_req_nopages(fc);
631 mode &= ~current_umask();
633 memset(&inarg, 0, sizeof(inarg));
635 inarg.rdev = new_encode_dev(rdev);
636 inarg.umask = current_umask();
637 req->in.h.opcode = FUSE_MKNOD;
639 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
641 req->in.args[0].value = &inarg;
642 req->in.args[1].size = entry->d_name.len + 1;
643 req->in.args[1].value = entry->d_name.name;
644 return create_new_entry(fc, req, dir, entry, mode);
647 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
650 return fuse_mknod(dir, entry, mode, 0);
653 static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
655 struct fuse_mkdir_in inarg;
656 struct fuse_conn *fc = get_fuse_conn(dir);
657 struct fuse_req *req = fuse_get_req_nopages(fc);
662 mode &= ~current_umask();
664 memset(&inarg, 0, sizeof(inarg));
666 inarg.umask = current_umask();
667 req->in.h.opcode = FUSE_MKDIR;
669 req->in.args[0].size = sizeof(inarg);
670 req->in.args[0].value = &inarg;
671 req->in.args[1].size = entry->d_name.len + 1;
672 req->in.args[1].value = entry->d_name.name;
673 return create_new_entry(fc, req, dir, entry, S_IFDIR);
676 static int fuse_symlink(struct inode *dir, struct dentry *entry,
679 struct fuse_conn *fc = get_fuse_conn(dir);
680 unsigned len = strlen(link) + 1;
681 struct fuse_req *req = fuse_get_req_nopages(fc);
685 req->in.h.opcode = FUSE_SYMLINK;
687 req->in.args[0].size = entry->d_name.len + 1;
688 req->in.args[0].value = entry->d_name.name;
689 req->in.args[1].size = len;
690 req->in.args[1].value = link;
691 return create_new_entry(fc, req, dir, entry, S_IFLNK);
694 static int fuse_unlink(struct inode *dir, struct dentry *entry)
697 struct fuse_conn *fc = get_fuse_conn(dir);
698 struct fuse_req *req = fuse_get_req_nopages(fc);
702 req->in.h.opcode = FUSE_UNLINK;
703 req->in.h.nodeid = get_node_id(dir);
705 req->in.args[0].size = entry->d_name.len + 1;
706 req->in.args[0].value = entry->d_name.name;
707 fuse_request_send(fc, req);
708 err = req->out.h.error;
709 fuse_put_request(fc, req);
711 struct inode *inode = entry->d_inode;
712 struct fuse_inode *fi = get_fuse_inode(inode);
714 spin_lock(&fc->lock);
715 fi->attr_version = ++fc->attr_version;
717 * If i_nlink == 0 then unlink doesn't make sense, yet this can
718 * happen if userspace filesystem is careless. It would be
719 * difficult to enforce correct nlink usage so just ignore this
722 if (inode->i_nlink > 0)
724 spin_unlock(&fc->lock);
725 fuse_invalidate_attr(inode);
726 fuse_invalidate_attr(dir);
727 fuse_invalidate_entry_cache(entry);
728 } else if (err == -EINTR)
729 fuse_invalidate_entry(entry);
733 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
736 struct fuse_conn *fc = get_fuse_conn(dir);
737 struct fuse_req *req = fuse_get_req_nopages(fc);
741 req->in.h.opcode = FUSE_RMDIR;
742 req->in.h.nodeid = get_node_id(dir);
744 req->in.args[0].size = entry->d_name.len + 1;
745 req->in.args[0].value = entry->d_name.name;
746 fuse_request_send(fc, req);
747 err = req->out.h.error;
748 fuse_put_request(fc, req);
750 clear_nlink(entry->d_inode);
751 fuse_invalidate_attr(dir);
752 fuse_invalidate_entry_cache(entry);
753 } else if (err == -EINTR)
754 fuse_invalidate_entry(entry);
758 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
759 struct inode *newdir, struct dentry *newent)
762 struct fuse_rename_in inarg;
763 struct fuse_conn *fc = get_fuse_conn(olddir);
764 struct fuse_req *req = fuse_get_req_nopages(fc);
769 memset(&inarg, 0, sizeof(inarg));
770 inarg.newdir = get_node_id(newdir);
771 req->in.h.opcode = FUSE_RENAME;
772 req->in.h.nodeid = get_node_id(olddir);
774 req->in.args[0].size = sizeof(inarg);
775 req->in.args[0].value = &inarg;
776 req->in.args[1].size = oldent->d_name.len + 1;
777 req->in.args[1].value = oldent->d_name.name;
778 req->in.args[2].size = newent->d_name.len + 1;
779 req->in.args[2].value = newent->d_name.name;
780 fuse_request_send(fc, req);
781 err = req->out.h.error;
782 fuse_put_request(fc, req);
785 fuse_invalidate_attr(oldent->d_inode);
787 fuse_invalidate_attr(olddir);
788 if (olddir != newdir)
789 fuse_invalidate_attr(newdir);
791 /* newent will end up negative */
792 if (newent->d_inode) {
793 fuse_invalidate_attr(newent->d_inode);
794 fuse_invalidate_entry_cache(newent);
796 } else if (err == -EINTR) {
797 /* If request was interrupted, DEITY only knows if the
798 rename actually took place. If the invalidation
799 fails (e.g. some process has CWD under the renamed
800 directory), then there can be inconsistency between
801 the dcache and the real filesystem. Tough luck. */
802 fuse_invalidate_entry(oldent);
804 fuse_invalidate_entry(newent);
810 static int fuse_link(struct dentry *entry, struct inode *newdir,
811 struct dentry *newent)
814 struct fuse_link_in inarg;
815 struct inode *inode = entry->d_inode;
816 struct fuse_conn *fc = get_fuse_conn(inode);
817 struct fuse_req *req = fuse_get_req_nopages(fc);
821 memset(&inarg, 0, sizeof(inarg));
822 inarg.oldnodeid = get_node_id(inode);
823 req->in.h.opcode = FUSE_LINK;
825 req->in.args[0].size = sizeof(inarg);
826 req->in.args[0].value = &inarg;
827 req->in.args[1].size = newent->d_name.len + 1;
828 req->in.args[1].value = newent->d_name.name;
829 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
830 /* Contrary to "normal" filesystems it can happen that link
831 makes two "logical" inodes point to the same "physical"
832 inode. We invalidate the attributes of the old one, so it
833 will reflect changes in the backing inode (link count,
837 struct fuse_inode *fi = get_fuse_inode(inode);
839 spin_lock(&fc->lock);
840 fi->attr_version = ++fc->attr_version;
842 spin_unlock(&fc->lock);
843 fuse_invalidate_attr(inode);
844 } else if (err == -EINTR) {
845 fuse_invalidate_attr(inode);
850 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
853 unsigned int blkbits;
855 stat->dev = inode->i_sb->s_dev;
856 stat->ino = attr->ino;
857 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
858 stat->nlink = attr->nlink;
859 stat->uid = make_kuid(&init_user_ns, attr->uid);
860 stat->gid = make_kgid(&init_user_ns, attr->gid);
861 stat->rdev = inode->i_rdev;
862 stat->atime.tv_sec = attr->atime;
863 stat->atime.tv_nsec = attr->atimensec;
864 stat->mtime.tv_sec = attr->mtime;
865 stat->mtime.tv_nsec = attr->mtimensec;
866 stat->ctime.tv_sec = attr->ctime;
867 stat->ctime.tv_nsec = attr->ctimensec;
868 stat->size = attr->size;
869 stat->blocks = attr->blocks;
871 if (attr->blksize != 0)
872 blkbits = ilog2(attr->blksize);
874 blkbits = inode->i_sb->s_blocksize_bits;
876 stat->blksize = 1 << blkbits;
879 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
883 struct fuse_getattr_in inarg;
884 struct fuse_attr_out outarg;
885 struct fuse_conn *fc = get_fuse_conn(inode);
886 struct fuse_req *req;
889 req = fuse_get_req_nopages(fc);
893 attr_version = fuse_get_attr_version(fc);
895 memset(&inarg, 0, sizeof(inarg));
896 memset(&outarg, 0, sizeof(outarg));
897 /* Directories have separate file-handle space */
898 if (file && S_ISREG(inode->i_mode)) {
899 struct fuse_file *ff = file->private_data;
901 inarg.getattr_flags |= FUSE_GETATTR_FH;
904 req->in.h.opcode = FUSE_GETATTR;
905 req->in.h.nodeid = get_node_id(inode);
907 req->in.args[0].size = sizeof(inarg);
908 req->in.args[0].value = &inarg;
909 req->out.numargs = 1;
911 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
913 req->out.args[0].size = sizeof(outarg);
914 req->out.args[0].value = &outarg;
915 fuse_request_send(fc, req);
916 err = req->out.h.error;
917 fuse_put_request(fc, req);
919 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
920 make_bad_inode(inode);
923 fuse_change_attributes(inode, &outarg.attr,
924 attr_timeout(&outarg),
927 fuse_fillattr(inode, &outarg.attr, stat);
933 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
934 struct file *file, bool *refreshed)
936 struct fuse_inode *fi = get_fuse_inode(inode);
940 if (fi->i_time < get_jiffies_64()) {
942 err = fuse_do_getattr(inode, stat, file);
947 generic_fillattr(inode, stat);
948 stat->mode = fi->orig_i_mode;
949 stat->ino = fi->orig_ino;
953 if (refreshed != NULL)
959 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
960 u64 child_nodeid, struct qstr *name)
963 struct inode *parent;
965 struct dentry *entry;
967 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
971 mutex_lock(&parent->i_mutex);
972 if (!S_ISDIR(parent->i_mode))
976 dir = d_find_alias(parent);
980 entry = d_lookup(dir, name);
985 fuse_invalidate_attr(parent);
986 fuse_invalidate_entry(entry);
988 if (child_nodeid != 0 && entry->d_inode) {
989 mutex_lock(&entry->d_inode->i_mutex);
990 if (get_node_id(entry->d_inode) != child_nodeid) {
994 if (d_mountpoint(entry)) {
998 if (S_ISDIR(entry->d_inode->i_mode)) {
999 shrink_dcache_parent(entry);
1000 if (!simple_empty(entry)) {
1004 entry->d_inode->i_flags |= S_DEAD;
1007 clear_nlink(entry->d_inode);
1010 mutex_unlock(&entry->d_inode->i_mutex);
1019 mutex_unlock(&parent->i_mutex);
1025 * Calling into a user-controlled filesystem gives the filesystem
1026 * daemon ptrace-like capabilities over the current process. This
1027 * means, that the filesystem daemon is able to record the exact
1028 * filesystem operations performed, and can also control the behavior
1029 * of the requester process in otherwise impossible ways. For example
1030 * it can delay the operation for arbitrary length of time allowing
1031 * DoS against the requester.
1033 * For this reason only those processes can call into the filesystem,
1034 * for which the owner of the mount has ptrace privilege. This
1035 * excludes processes started by other users, suid or sgid processes.
1037 int fuse_allow_current_process(struct fuse_conn *fc)
1039 const struct cred *cred;
1041 if (fc->flags & FUSE_ALLOW_OTHER)
1044 cred = current_cred();
1045 if (uid_eq(cred->euid, fc->user_id) &&
1046 uid_eq(cred->suid, fc->user_id) &&
1047 uid_eq(cred->uid, fc->user_id) &&
1048 gid_eq(cred->egid, fc->group_id) &&
1049 gid_eq(cred->sgid, fc->group_id) &&
1050 gid_eq(cred->gid, fc->group_id))
1056 static int fuse_access(struct inode *inode, int mask)
1058 struct fuse_conn *fc = get_fuse_conn(inode);
1059 struct fuse_req *req;
1060 struct fuse_access_in inarg;
1066 req = fuse_get_req_nopages(fc);
1068 return PTR_ERR(req);
1070 memset(&inarg, 0, sizeof(inarg));
1071 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1072 req->in.h.opcode = FUSE_ACCESS;
1073 req->in.h.nodeid = get_node_id(inode);
1074 req->in.numargs = 1;
1075 req->in.args[0].size = sizeof(inarg);
1076 req->in.args[0].value = &inarg;
1077 fuse_request_send(fc, req);
1078 err = req->out.h.error;
1079 fuse_put_request(fc, req);
1080 if (err == -ENOSYS) {
1087 static int fuse_perm_getattr(struct inode *inode, int mask)
1089 if (mask & MAY_NOT_BLOCK)
1092 return fuse_do_getattr(inode, NULL, NULL);
1096 * Check permission. The two basic access models of FUSE are:
1098 * 1) Local access checking ('default_permissions' mount option) based
1099 * on file mode. This is the plain old disk filesystem permission
1102 * 2) "Remote" access checking, where server is responsible for
1103 * checking permission in each inode operation. An exception to this
1104 * is if ->permission() was invoked from sys_access() in which case an
1105 * access request is sent. Execute permission is still checked
1106 * locally based on file mode.
1108 static int fuse_permission(struct inode *inode, int mask)
1110 struct fuse_conn *fc = get_fuse_conn(inode);
1111 bool refreshed = false;
1114 if (!fuse_allow_current_process(fc))
1118 * If attributes are needed, refresh them before proceeding
1120 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1121 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1122 struct fuse_inode *fi = get_fuse_inode(inode);
1124 if (fi->i_time < get_jiffies_64()) {
1127 err = fuse_perm_getattr(inode, mask);
1133 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1134 err = generic_permission(inode, mask);
1136 /* If permission is denied, try to refresh file
1137 attributes. This is also needed, because the root
1138 node will at first have no permissions */
1139 if (err == -EACCES && !refreshed) {
1140 err = fuse_perm_getattr(inode, mask);
1142 err = generic_permission(inode, mask);
1145 /* Note: the opposite of the above test does not
1146 exist. So if permissions are revoked this won't be
1147 noticed immediately, only after the attribute
1148 timeout has expired */
1149 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1150 if (mask & MAY_NOT_BLOCK)
1153 err = fuse_access(inode, mask);
1154 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1155 if (!(inode->i_mode & S_IXUGO)) {
1159 err = fuse_perm_getattr(inode, mask);
1160 if (!err && !(inode->i_mode & S_IXUGO))
1167 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1168 void *dstbuf, filldir_t filldir)
1170 while (nbytes >= FUSE_NAME_OFFSET) {
1171 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1172 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1174 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1176 if (reclen > nbytes)
1178 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1181 over = filldir(dstbuf, dirent->name, dirent->namelen,
1182 file->f_pos, dirent->ino, dirent->type);
1188 file->f_pos = dirent->off;
1194 static int fuse_direntplus_link(struct file *file,
1195 struct fuse_direntplus *direntplus,
1199 struct fuse_entry_out *o = &direntplus->entry_out;
1200 struct fuse_dirent *dirent = &direntplus->dirent;
1201 struct dentry *parent = file->f_path.dentry;
1202 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1203 struct dentry *dentry;
1204 struct dentry *alias;
1205 struct inode *dir = parent->d_inode;
1206 struct fuse_conn *fc;
1207 struct inode *inode;
1211 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1212 * ENOENT. Instead, it only means the userspace filesystem did
1213 * not want to return attributes/handle for this entry.
1220 if (name.name[0] == '.') {
1222 * We could potentially refresh the attributes of the directory
1227 if (name.name[1] == '.' && name.len == 2)
1231 if (invalid_nodeid(o->nodeid))
1233 if (!fuse_valid_type(o->attr.mode))
1236 fc = get_fuse_conn(dir);
1238 name.hash = full_name_hash(name.name, name.len);
1239 dentry = d_lookup(parent, &name);
1241 inode = dentry->d_inode;
1244 } else if (get_node_id(inode) != o->nodeid ||
1245 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1246 err = d_invalidate(dentry);
1249 } else if (is_bad_inode(inode)) {
1253 struct fuse_inode *fi;
1254 fi = get_fuse_inode(inode);
1255 spin_lock(&fc->lock);
1257 spin_unlock(&fc->lock);
1260 * The other branch to 'found' comes via fuse_iget()
1261 * which bumps nlookup inside
1269 dentry = d_alloc(parent, &name);
1274 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1275 &o->attr, entry_attr_timeout(o), attr_version);
1279 if (S_ISDIR(inode->i_mode)) {
1280 mutex_lock(&fc->inst_mutex);
1281 alias = fuse_d_add_directory(dentry, inode);
1282 mutex_unlock(&fc->inst_mutex);
1283 err = PTR_ERR(alias);
1284 if (IS_ERR(alias)) {
1289 alias = d_splice_alias(inode, dentry);
1298 fuse_change_attributes(inode, &o->attr, entry_attr_timeout(o),
1301 fuse_change_entry_timeout(dentry, o);
1310 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1311 void *dstbuf, filldir_t filldir, u64 attr_version)
1313 struct fuse_direntplus *direntplus;
1314 struct fuse_dirent *dirent;
1319 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1320 direntplus = (struct fuse_direntplus *) buf;
1321 dirent = &direntplus->dirent;
1322 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1324 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1326 if (reclen > nbytes)
1328 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1332 /* We fill entries into dstbuf only as much as
1333 it can hold. But we still continue iterating
1334 over remaining entries to link them. If not,
1335 we need to send a FORGET for each of those
1336 which we did not link.
1338 over = filldir(dstbuf, dirent->name, dirent->namelen,
1339 file->f_pos, dirent->ino,
1341 file->f_pos = dirent->off;
1347 ret = fuse_direntplus_link(file, direntplus, attr_version);
1349 fuse_force_forget(file, direntplus->entry_out.nodeid);
1355 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1360 struct inode *inode = file_inode(file);
1361 struct fuse_conn *fc = get_fuse_conn(inode);
1362 struct fuse_req *req;
1363 u64 attr_version = 0;
1365 if (is_bad_inode(inode))
1368 req = fuse_get_req(fc, 1);
1370 return PTR_ERR(req);
1372 page = alloc_page(GFP_KERNEL);
1374 fuse_put_request(fc, req);
1378 plus = fuse_use_readdirplus(inode, file);
1379 req->out.argpages = 1;
1381 req->pages[0] = page;
1382 req->page_descs[0].length = PAGE_SIZE;
1384 attr_version = fuse_get_attr_version(fc);
1385 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE,
1388 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE,
1391 fuse_request_send(fc, req);
1392 nbytes = req->out.args[0].size;
1393 err = req->out.h.error;
1394 fuse_put_request(fc, req);
1397 err = parse_dirplusfile(page_address(page), nbytes,
1398 file, dstbuf, filldir,
1401 err = parse_dirfile(page_address(page), nbytes, file,
1407 fuse_invalidate_attr(inode); /* atime changed */
1411 static char *read_link(struct dentry *dentry)
1413 struct inode *inode = dentry->d_inode;
1414 struct fuse_conn *fc = get_fuse_conn(inode);
1415 struct fuse_req *req = fuse_get_req_nopages(fc);
1419 return ERR_CAST(req);
1421 link = (char *) __get_free_page(GFP_KERNEL);
1423 link = ERR_PTR(-ENOMEM);
1426 req->in.h.opcode = FUSE_READLINK;
1427 req->in.h.nodeid = get_node_id(inode);
1428 req->out.argvar = 1;
1429 req->out.numargs = 1;
1430 req->out.args[0].size = PAGE_SIZE - 1;
1431 req->out.args[0].value = link;
1432 fuse_request_send(fc, req);
1433 if (req->out.h.error) {
1434 free_page((unsigned long) link);
1435 link = ERR_PTR(req->out.h.error);
1437 link[req->out.args[0].size] = '\0';
1439 fuse_put_request(fc, req);
1440 fuse_invalidate_attr(inode); /* atime changed */
1444 static void free_link(char *link)
1447 free_page((unsigned long) link);
1450 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1452 nd_set_link(nd, read_link(dentry));
1456 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1458 free_link(nd_get_link(nd));
1461 static int fuse_dir_open(struct inode *inode, struct file *file)
1463 return fuse_open_common(inode, file, true);
1466 static int fuse_dir_release(struct inode *inode, struct file *file)
1468 fuse_release_common(file, FUSE_RELEASEDIR);
1473 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1476 return fuse_fsync_common(file, start, end, datasync, 1);
1479 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1482 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1484 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1488 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1491 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1494 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1499 return fuse_ioctl_common(file, cmd, arg,
1500 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1503 static bool update_mtime(unsigned ivalid)
1505 /* Always update if mtime is explicitly set */
1506 if (ivalid & ATTR_MTIME_SET)
1509 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1510 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1513 /* In all other cases update */
1517 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1519 unsigned ivalid = iattr->ia_valid;
1521 if (ivalid & ATTR_MODE)
1522 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1523 if (ivalid & ATTR_UID)
1524 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
1525 if (ivalid & ATTR_GID)
1526 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
1527 if (ivalid & ATTR_SIZE)
1528 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1529 if (ivalid & ATTR_ATIME) {
1530 arg->valid |= FATTR_ATIME;
1531 arg->atime = iattr->ia_atime.tv_sec;
1532 arg->atimensec = iattr->ia_atime.tv_nsec;
1533 if (!(ivalid & ATTR_ATIME_SET))
1534 arg->valid |= FATTR_ATIME_NOW;
1536 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1537 arg->valid |= FATTR_MTIME;
1538 arg->mtime = iattr->ia_mtime.tv_sec;
1539 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1540 if (!(ivalid & ATTR_MTIME_SET))
1541 arg->valid |= FATTR_MTIME_NOW;
1546 * Prevent concurrent writepages on inode
1548 * This is done by adding a negative bias to the inode write counter
1549 * and waiting for all pending writes to finish.
1551 void fuse_set_nowrite(struct inode *inode)
1553 struct fuse_conn *fc = get_fuse_conn(inode);
1554 struct fuse_inode *fi = get_fuse_inode(inode);
1556 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1558 spin_lock(&fc->lock);
1559 BUG_ON(fi->writectr < 0);
1560 fi->writectr += FUSE_NOWRITE;
1561 spin_unlock(&fc->lock);
1562 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1566 * Allow writepages on inode
1568 * Remove the bias from the writecounter and send any queued
1571 static void __fuse_release_nowrite(struct inode *inode)
1573 struct fuse_inode *fi = get_fuse_inode(inode);
1575 BUG_ON(fi->writectr != FUSE_NOWRITE);
1577 fuse_flush_writepages(inode);
1580 void fuse_release_nowrite(struct inode *inode)
1582 struct fuse_conn *fc = get_fuse_conn(inode);
1584 spin_lock(&fc->lock);
1585 __fuse_release_nowrite(inode);
1586 spin_unlock(&fc->lock);
1590 * Set attributes, and at the same time refresh them.
1592 * Truncation is slightly complicated, because the 'truncate' request
1593 * may fail, in which case we don't want to touch the mapping.
1594 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1595 * and the actual truncation by hand.
1597 int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1600 struct fuse_conn *fc = get_fuse_conn(inode);
1601 struct fuse_inode *fi = get_fuse_inode(inode);
1602 struct fuse_req *req;
1603 struct fuse_setattr_in inarg;
1604 struct fuse_attr_out outarg;
1605 bool is_truncate = false;
1609 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1610 attr->ia_valid |= ATTR_FORCE;
1612 err = inode_change_ok(inode, attr);
1616 if (attr->ia_valid & ATTR_OPEN) {
1617 if (fc->atomic_o_trunc)
1622 if (attr->ia_valid & ATTR_SIZE)
1625 req = fuse_get_req_nopages(fc);
1627 return PTR_ERR(req);
1630 fuse_set_nowrite(inode);
1631 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1634 memset(&inarg, 0, sizeof(inarg));
1635 memset(&outarg, 0, sizeof(outarg));
1636 iattr_to_fattr(attr, &inarg);
1638 struct fuse_file *ff = file->private_data;
1639 inarg.valid |= FATTR_FH;
1642 if (attr->ia_valid & ATTR_SIZE) {
1643 /* For mandatory locking in truncate */
1644 inarg.valid |= FATTR_LOCKOWNER;
1645 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1647 req->in.h.opcode = FUSE_SETATTR;
1648 req->in.h.nodeid = get_node_id(inode);
1649 req->in.numargs = 1;
1650 req->in.args[0].size = sizeof(inarg);
1651 req->in.args[0].value = &inarg;
1652 req->out.numargs = 1;
1654 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1656 req->out.args[0].size = sizeof(outarg);
1657 req->out.args[0].value = &outarg;
1658 fuse_request_send(fc, req);
1659 err = req->out.h.error;
1660 fuse_put_request(fc, req);
1663 fuse_invalidate_attr(inode);
1667 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1668 make_bad_inode(inode);
1673 spin_lock(&fc->lock);
1674 fuse_change_attributes_common(inode, &outarg.attr,
1675 attr_timeout(&outarg));
1676 oldsize = inode->i_size;
1677 i_size_write(inode, outarg.attr.size);
1680 /* NOTE: this may release/reacquire fc->lock */
1681 __fuse_release_nowrite(inode);
1683 spin_unlock(&fc->lock);
1686 * Only call invalidate_inode_pages2() after removing
1687 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1689 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1690 truncate_pagecache(inode, oldsize, outarg.attr.size);
1691 invalidate_inode_pages2(inode->i_mapping);
1694 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1699 fuse_release_nowrite(inode);
1701 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1705 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1707 struct inode *inode = entry->d_inode;
1709 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1712 if (attr->ia_valid & ATTR_FILE)
1713 return fuse_do_setattr(inode, attr, attr->ia_file);
1715 return fuse_do_setattr(inode, attr, NULL);
1718 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1721 struct inode *inode = entry->d_inode;
1722 struct fuse_conn *fc = get_fuse_conn(inode);
1724 if (!fuse_allow_current_process(fc))
1727 return fuse_update_attributes(inode, stat, NULL, NULL);
1730 static int fuse_setxattr(struct dentry *entry, const char *name,
1731 const void *value, size_t size, int flags)
1733 struct inode *inode = entry->d_inode;
1734 struct fuse_conn *fc = get_fuse_conn(inode);
1735 struct fuse_req *req;
1736 struct fuse_setxattr_in inarg;
1739 if (fc->no_setxattr)
1742 req = fuse_get_req_nopages(fc);
1744 return PTR_ERR(req);
1746 memset(&inarg, 0, sizeof(inarg));
1748 inarg.flags = flags;
1749 req->in.h.opcode = FUSE_SETXATTR;
1750 req->in.h.nodeid = get_node_id(inode);
1751 req->in.numargs = 3;
1752 req->in.args[0].size = sizeof(inarg);
1753 req->in.args[0].value = &inarg;
1754 req->in.args[1].size = strlen(name) + 1;
1755 req->in.args[1].value = name;
1756 req->in.args[2].size = size;
1757 req->in.args[2].value = value;
1758 fuse_request_send(fc, req);
1759 err = req->out.h.error;
1760 fuse_put_request(fc, req);
1761 if (err == -ENOSYS) {
1762 fc->no_setxattr = 1;
1766 fuse_invalidate_attr(inode);
1770 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1771 void *value, size_t size)
1773 struct inode *inode = entry->d_inode;
1774 struct fuse_conn *fc = get_fuse_conn(inode);
1775 struct fuse_req *req;
1776 struct fuse_getxattr_in inarg;
1777 struct fuse_getxattr_out outarg;
1780 if (fc->no_getxattr)
1783 req = fuse_get_req_nopages(fc);
1785 return PTR_ERR(req);
1787 memset(&inarg, 0, sizeof(inarg));
1789 req->in.h.opcode = FUSE_GETXATTR;
1790 req->in.h.nodeid = get_node_id(inode);
1791 req->in.numargs = 2;
1792 req->in.args[0].size = sizeof(inarg);
1793 req->in.args[0].value = &inarg;
1794 req->in.args[1].size = strlen(name) + 1;
1795 req->in.args[1].value = name;
1796 /* This is really two different operations rolled into one */
1797 req->out.numargs = 1;
1799 req->out.argvar = 1;
1800 req->out.args[0].size = size;
1801 req->out.args[0].value = value;
1803 req->out.args[0].size = sizeof(outarg);
1804 req->out.args[0].value = &outarg;
1806 fuse_request_send(fc, req);
1807 ret = req->out.h.error;
1809 ret = size ? req->out.args[0].size : outarg.size;
1811 if (ret == -ENOSYS) {
1812 fc->no_getxattr = 1;
1816 fuse_put_request(fc, req);
1820 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1822 struct inode *inode = entry->d_inode;
1823 struct fuse_conn *fc = get_fuse_conn(inode);
1824 struct fuse_req *req;
1825 struct fuse_getxattr_in inarg;
1826 struct fuse_getxattr_out outarg;
1829 if (!fuse_allow_current_process(fc))
1832 if (fc->no_listxattr)
1835 req = fuse_get_req_nopages(fc);
1837 return PTR_ERR(req);
1839 memset(&inarg, 0, sizeof(inarg));
1841 req->in.h.opcode = FUSE_LISTXATTR;
1842 req->in.h.nodeid = get_node_id(inode);
1843 req->in.numargs = 1;
1844 req->in.args[0].size = sizeof(inarg);
1845 req->in.args[0].value = &inarg;
1846 /* This is really two different operations rolled into one */
1847 req->out.numargs = 1;
1849 req->out.argvar = 1;
1850 req->out.args[0].size = size;
1851 req->out.args[0].value = list;
1853 req->out.args[0].size = sizeof(outarg);
1854 req->out.args[0].value = &outarg;
1856 fuse_request_send(fc, req);
1857 ret = req->out.h.error;
1859 ret = size ? req->out.args[0].size : outarg.size;
1861 if (ret == -ENOSYS) {
1862 fc->no_listxattr = 1;
1866 fuse_put_request(fc, req);
1870 static int fuse_removexattr(struct dentry *entry, const char *name)
1872 struct inode *inode = entry->d_inode;
1873 struct fuse_conn *fc = get_fuse_conn(inode);
1874 struct fuse_req *req;
1877 if (fc->no_removexattr)
1880 req = fuse_get_req_nopages(fc);
1882 return PTR_ERR(req);
1884 req->in.h.opcode = FUSE_REMOVEXATTR;
1885 req->in.h.nodeid = get_node_id(inode);
1886 req->in.numargs = 1;
1887 req->in.args[0].size = strlen(name) + 1;
1888 req->in.args[0].value = name;
1889 fuse_request_send(fc, req);
1890 err = req->out.h.error;
1891 fuse_put_request(fc, req);
1892 if (err == -ENOSYS) {
1893 fc->no_removexattr = 1;
1897 fuse_invalidate_attr(inode);
1901 static const struct inode_operations fuse_dir_inode_operations = {
1902 .lookup = fuse_lookup,
1903 .mkdir = fuse_mkdir,
1904 .symlink = fuse_symlink,
1905 .unlink = fuse_unlink,
1906 .rmdir = fuse_rmdir,
1907 .rename = fuse_rename,
1909 .setattr = fuse_setattr,
1910 .create = fuse_create,
1911 .atomic_open = fuse_atomic_open,
1912 .mknod = fuse_mknod,
1913 .permission = fuse_permission,
1914 .getattr = fuse_getattr,
1915 .setxattr = fuse_setxattr,
1916 .getxattr = fuse_getxattr,
1917 .listxattr = fuse_listxattr,
1918 .removexattr = fuse_removexattr,
1921 static const struct file_operations fuse_dir_operations = {
1922 .llseek = generic_file_llseek,
1923 .read = generic_read_dir,
1924 .readdir = fuse_readdir,
1925 .open = fuse_dir_open,
1926 .release = fuse_dir_release,
1927 .fsync = fuse_dir_fsync,
1928 .unlocked_ioctl = fuse_dir_ioctl,
1929 .compat_ioctl = fuse_dir_compat_ioctl,
1932 static const struct inode_operations fuse_common_inode_operations = {
1933 .setattr = fuse_setattr,
1934 .permission = fuse_permission,
1935 .getattr = fuse_getattr,
1936 .setxattr = fuse_setxattr,
1937 .getxattr = fuse_getxattr,
1938 .listxattr = fuse_listxattr,
1939 .removexattr = fuse_removexattr,
1942 static const struct inode_operations fuse_symlink_inode_operations = {
1943 .setattr = fuse_setattr,
1944 .follow_link = fuse_follow_link,
1945 .put_link = fuse_put_link,
1946 .readlink = generic_readlink,
1947 .getattr = fuse_getattr,
1948 .setxattr = fuse_setxattr,
1949 .getxattr = fuse_getxattr,
1950 .listxattr = fuse_listxattr,
1951 .removexattr = fuse_removexattr,
1954 void fuse_init_common(struct inode *inode)
1956 inode->i_op = &fuse_common_inode_operations;
1959 void fuse_init_dir(struct inode *inode)
1961 inode->i_op = &fuse_dir_inode_operations;
1962 inode->i_fop = &fuse_dir_operations;
1965 void fuse_init_symlink(struct inode *inode)
1967 inode->i_op = &fuse_symlink_inode_operations;