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 #if BITS_PER_LONG >= 64
18 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
23 static inline u64 fuse_dentry_time(struct dentry *entry)
29 * On 32 bit archs store the high 32 bits of time in d_fsdata
31 static void fuse_dentry_settime(struct dentry *entry, u64 time)
34 entry->d_fsdata = (void *) (unsigned long) (time >> 32);
37 static u64 fuse_dentry_time(struct dentry *entry)
39 return (u64) entry->d_time +
40 ((u64) (unsigned long) entry->d_fsdata << 32);
45 * FUSE caches dentries and attributes with separate timeout. The
46 * time in jiffies until the dentry/attributes are valid is stored in
47 * dentry->d_time and fuse_inode->i_time respectively.
51 * Calculate the time in jiffies until a dentry/attributes are valid
53 static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
56 struct timespec ts = {sec, nsec};
57 return get_jiffies_64() + timespec_to_jiffies(&ts);
63 * Set dentry and possibly attribute timeouts from the lookup/mk*
66 static void fuse_change_entry_timeout(struct dentry *entry,
67 struct fuse_entry_out *o)
69 fuse_dentry_settime(entry,
70 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
73 static u64 attr_timeout(struct fuse_attr_out *o)
75 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
78 static u64 entry_attr_timeout(struct fuse_entry_out *o)
80 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
84 * Mark the attributes as stale, so that at the next call to
85 * ->getattr() they will be fetched from userspace
87 void fuse_invalidate_attr(struct inode *inode)
89 get_fuse_inode(inode)->i_time = 0;
93 * Just mark the entry as stale, so that a next attempt to look it up
94 * will result in a new lookup call to userspace
96 * This is called when a dentry is about to become negative and the
97 * timeout is unknown (unlink, rmdir, rename and in some cases
100 void fuse_invalidate_entry_cache(struct dentry *entry)
102 fuse_dentry_settime(entry, 0);
106 * Same as fuse_invalidate_entry_cache(), but also try to remove the
107 * dentry from the hash
109 static void fuse_invalidate_entry(struct dentry *entry)
112 fuse_invalidate_entry_cache(entry);
115 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
116 u64 nodeid, struct qstr *name,
117 struct fuse_entry_out *outarg)
119 memset(outarg, 0, sizeof(struct fuse_entry_out));
120 req->in.h.opcode = FUSE_LOOKUP;
121 req->in.h.nodeid = nodeid;
123 req->in.args[0].size = name->len + 1;
124 req->in.args[0].value = name->name;
125 req->out.numargs = 1;
127 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
129 req->out.args[0].size = sizeof(struct fuse_entry_out);
130 req->out.args[0].value = outarg;
133 u64 fuse_get_attr_version(struct fuse_conn *fc)
138 * The spin lock isn't actually needed on 64bit archs, but we
139 * don't yet care too much about such optimizations.
141 spin_lock(&fc->lock);
142 curr_version = fc->attr_version;
143 spin_unlock(&fc->lock);
149 * Check whether the dentry is still valid
151 * If the entry validity timeout has expired and the dentry is
152 * positive, try to redo the lookup. If the lookup results in a
153 * different inode, then let the VFS invalidate the dentry and redo
154 * the lookup once more. If the lookup results in the same inode,
155 * then refresh the attributes, timeouts and mark the dentry valid.
157 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
161 inode = ACCESS_ONCE(entry->d_inode);
162 if (inode && is_bad_inode(inode))
164 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64())) {
166 struct fuse_entry_out outarg;
167 struct fuse_conn *fc;
168 struct fuse_req *req;
169 struct fuse_forget_link *forget;
170 struct dentry *parent;
173 /* For negative dentries, always do a fresh lookup */
177 if (nd && (nd->flags & LOOKUP_RCU))
180 fc = get_fuse_conn(inode);
181 req = fuse_get_req(fc);
185 forget = fuse_alloc_forget();
187 fuse_put_request(fc, req);
191 attr_version = fuse_get_attr_version(fc);
193 parent = dget_parent(entry);
194 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
195 &entry->d_name, &outarg);
196 fuse_request_send(fc, req);
198 err = req->out.h.error;
199 fuse_put_request(fc, req);
200 /* Zero nodeid is same as -ENOENT */
201 if (!err && !outarg.nodeid)
204 struct fuse_inode *fi = get_fuse_inode(inode);
205 if (outarg.nodeid != get_node_id(inode)) {
206 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
209 spin_lock(&fc->lock);
211 spin_unlock(&fc->lock);
214 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
217 fuse_change_attributes(inode, &outarg.attr,
218 entry_attr_timeout(&outarg),
220 fuse_change_entry_timeout(entry, &outarg);
225 static int invalid_nodeid(u64 nodeid)
227 return !nodeid || nodeid == FUSE_ROOT_ID;
230 const struct dentry_operations fuse_dentry_operations = {
231 .d_revalidate = fuse_dentry_revalidate,
234 int fuse_valid_type(int m)
236 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
237 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
241 * Add a directory inode to a dentry, ensuring that no other dentry
242 * refers to this inode. Called with fc->inst_mutex.
244 static struct dentry *fuse_d_add_directory(struct dentry *entry,
247 struct dentry *alias = d_find_alias(inode);
248 if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
249 /* This tries to shrink the subtree below alias */
250 fuse_invalidate_entry(alias);
252 if (!list_empty(&inode->i_dentry))
253 return ERR_PTR(-EBUSY);
257 return d_splice_alias(inode, entry);
260 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
261 struct fuse_entry_out *outarg, struct inode **inode)
263 struct fuse_conn *fc = get_fuse_conn_super(sb);
264 struct fuse_req *req;
265 struct fuse_forget_link *forget;
271 if (name->len > FUSE_NAME_MAX)
274 req = fuse_get_req(fc);
279 forget = fuse_alloc_forget();
282 fuse_put_request(fc, req);
286 attr_version = fuse_get_attr_version(fc);
288 fuse_lookup_init(fc, req, nodeid, name, outarg);
289 fuse_request_send(fc, req);
290 err = req->out.h.error;
291 fuse_put_request(fc, req);
292 /* Zero nodeid is same as -ENOENT, but with valid timeout */
293 if (err || !outarg->nodeid)
299 if (!fuse_valid_type(outarg->attr.mode))
302 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
303 &outarg->attr, entry_attr_timeout(outarg),
307 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
318 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
319 struct nameidata *nd)
322 struct fuse_entry_out outarg;
324 struct dentry *newent;
325 struct fuse_conn *fc = get_fuse_conn(dir);
326 bool outarg_valid = true;
328 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
330 if (err == -ENOENT) {
331 outarg_valid = false;
338 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
341 if (inode && S_ISDIR(inode->i_mode)) {
342 mutex_lock(&fc->inst_mutex);
343 newent = fuse_d_add_directory(entry, inode);
344 mutex_unlock(&fc->inst_mutex);
345 err = PTR_ERR(newent);
349 newent = d_splice_alias(inode, entry);
352 entry = newent ? newent : entry;
354 fuse_change_entry_timeout(entry, &outarg);
356 fuse_invalidate_entry_cache(entry);
367 * Atomic create+open operation
369 * If the filesystem doesn't support this, then fall back to separate
370 * 'mknod' + 'open' requests.
372 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
373 struct nameidata *nd)
377 struct fuse_conn *fc = get_fuse_conn(dir);
378 struct fuse_req *req;
379 struct fuse_forget_link *forget;
380 struct fuse_create_in inarg;
381 struct fuse_open_out outopen;
382 struct fuse_entry_out outentry;
383 struct fuse_file *ff;
385 int flags = nd->intent.open.flags;
390 if (flags & O_DIRECT)
393 forget = fuse_alloc_forget();
397 req = fuse_get_req(fc);
400 goto out_put_forget_req;
403 ff = fuse_file_alloc(fc);
405 goto out_put_request;
408 mode &= ~current_umask();
411 memset(&inarg, 0, sizeof(inarg));
412 memset(&outentry, 0, sizeof(outentry));
415 inarg.umask = current_umask();
416 req->in.h.opcode = FUSE_CREATE;
417 req->in.h.nodeid = get_node_id(dir);
419 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
421 req->in.args[0].value = &inarg;
422 req->in.args[1].size = entry->d_name.len + 1;
423 req->in.args[1].value = entry->d_name.name;
424 req->out.numargs = 2;
426 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
428 req->out.args[0].size = sizeof(outentry);
429 req->out.args[0].value = &outentry;
430 req->out.args[1].size = sizeof(outopen);
431 req->out.args[1].value = &outopen;
432 fuse_request_send(fc, req);
433 err = req->out.h.error;
441 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
444 fuse_put_request(fc, req);
446 ff->nodeid = outentry.nodeid;
447 ff->open_flags = outopen.open_flags;
448 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
449 &outentry.attr, entry_attr_timeout(&outentry), 0);
451 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
452 fuse_sync_release(ff, flags);
453 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
457 d_instantiate(entry, inode);
458 fuse_change_entry_timeout(entry, &outentry);
459 fuse_invalidate_attr(dir);
460 file = lookup_instantiate_filp(nd, entry, generic_file_open);
462 fuse_sync_release(ff, flags);
463 return PTR_ERR(file);
465 file->private_data = fuse_file_get(ff);
466 fuse_finish_open(inode, file);
472 fuse_put_request(fc, req);
479 * Code shared between mknod, mkdir, symlink and link
481 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
482 struct inode *dir, struct dentry *entry,
485 struct fuse_entry_out outarg;
488 struct fuse_forget_link *forget;
490 forget = fuse_alloc_forget();
492 fuse_put_request(fc, req);
496 memset(&outarg, 0, sizeof(outarg));
497 req->in.h.nodeid = get_node_id(dir);
498 req->out.numargs = 1;
500 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
502 req->out.args[0].size = sizeof(outarg);
503 req->out.args[0].value = &outarg;
504 fuse_request_send(fc, req);
505 err = req->out.h.error;
506 fuse_put_request(fc, req);
508 goto out_put_forget_req;
511 if (invalid_nodeid(outarg.nodeid))
512 goto out_put_forget_req;
514 if ((outarg.attr.mode ^ mode) & S_IFMT)
515 goto out_put_forget_req;
517 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
518 &outarg.attr, entry_attr_timeout(&outarg), 0);
520 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
525 if (S_ISDIR(inode->i_mode)) {
526 struct dentry *alias;
527 mutex_lock(&fc->inst_mutex);
528 alias = d_find_alias(inode);
530 /* New directory must have moved since mkdir */
531 mutex_unlock(&fc->inst_mutex);
536 d_instantiate(entry, inode);
537 mutex_unlock(&fc->inst_mutex);
539 d_instantiate(entry, inode);
541 fuse_change_entry_timeout(entry, &outarg);
542 fuse_invalidate_attr(dir);
550 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
553 struct fuse_mknod_in inarg;
554 struct fuse_conn *fc = get_fuse_conn(dir);
555 struct fuse_req *req = fuse_get_req(fc);
560 mode &= ~current_umask();
562 memset(&inarg, 0, sizeof(inarg));
564 inarg.rdev = new_encode_dev(rdev);
565 inarg.umask = current_umask();
566 req->in.h.opcode = FUSE_MKNOD;
568 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
570 req->in.args[0].value = &inarg;
571 req->in.args[1].size = entry->d_name.len + 1;
572 req->in.args[1].value = entry->d_name.name;
573 return create_new_entry(fc, req, dir, entry, mode);
576 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
577 struct nameidata *nd)
580 int err = fuse_create_open(dir, entry, mode, nd);
583 /* Fall back on mknod */
585 return fuse_mknod(dir, entry, mode, 0);
588 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
590 struct fuse_mkdir_in inarg;
591 struct fuse_conn *fc = get_fuse_conn(dir);
592 struct fuse_req *req = fuse_get_req(fc);
597 mode &= ~current_umask();
599 memset(&inarg, 0, sizeof(inarg));
601 inarg.umask = current_umask();
602 req->in.h.opcode = FUSE_MKDIR;
604 req->in.args[0].size = sizeof(inarg);
605 req->in.args[0].value = &inarg;
606 req->in.args[1].size = entry->d_name.len + 1;
607 req->in.args[1].value = entry->d_name.name;
608 return create_new_entry(fc, req, dir, entry, S_IFDIR);
611 static int fuse_symlink(struct inode *dir, struct dentry *entry,
614 struct fuse_conn *fc = get_fuse_conn(dir);
615 unsigned len = strlen(link) + 1;
616 struct fuse_req *req = fuse_get_req(fc);
620 req->in.h.opcode = FUSE_SYMLINK;
622 req->in.args[0].size = entry->d_name.len + 1;
623 req->in.args[0].value = entry->d_name.name;
624 req->in.args[1].size = len;
625 req->in.args[1].value = link;
626 return create_new_entry(fc, req, dir, entry, S_IFLNK);
629 static int fuse_unlink(struct inode *dir, struct dentry *entry)
632 struct fuse_conn *fc = get_fuse_conn(dir);
633 struct fuse_req *req = fuse_get_req(fc);
637 req->in.h.opcode = FUSE_UNLINK;
638 req->in.h.nodeid = get_node_id(dir);
640 req->in.args[0].size = entry->d_name.len + 1;
641 req->in.args[0].value = entry->d_name.name;
642 fuse_request_send(fc, req);
643 err = req->out.h.error;
644 fuse_put_request(fc, req);
646 struct inode *inode = entry->d_inode;
649 * Set nlink to zero so the inode can be cleared, if the inode
650 * does have more links this will be discovered at the next
654 fuse_invalidate_attr(inode);
655 fuse_invalidate_attr(dir);
656 fuse_invalidate_entry_cache(entry);
657 } else if (err == -EINTR)
658 fuse_invalidate_entry(entry);
662 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
665 struct fuse_conn *fc = get_fuse_conn(dir);
666 struct fuse_req *req = fuse_get_req(fc);
670 req->in.h.opcode = FUSE_RMDIR;
671 req->in.h.nodeid = get_node_id(dir);
673 req->in.args[0].size = entry->d_name.len + 1;
674 req->in.args[0].value = entry->d_name.name;
675 fuse_request_send(fc, req);
676 err = req->out.h.error;
677 fuse_put_request(fc, req);
679 clear_nlink(entry->d_inode);
680 fuse_invalidate_attr(dir);
681 fuse_invalidate_entry_cache(entry);
682 } else if (err == -EINTR)
683 fuse_invalidate_entry(entry);
687 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
688 struct inode *newdir, struct dentry *newent)
691 struct fuse_rename_in inarg;
692 struct fuse_conn *fc = get_fuse_conn(olddir);
693 struct fuse_req *req = fuse_get_req(fc);
698 memset(&inarg, 0, sizeof(inarg));
699 inarg.newdir = get_node_id(newdir);
700 req->in.h.opcode = FUSE_RENAME;
701 req->in.h.nodeid = get_node_id(olddir);
703 req->in.args[0].size = sizeof(inarg);
704 req->in.args[0].value = &inarg;
705 req->in.args[1].size = oldent->d_name.len + 1;
706 req->in.args[1].value = oldent->d_name.name;
707 req->in.args[2].size = newent->d_name.len + 1;
708 req->in.args[2].value = newent->d_name.name;
709 fuse_request_send(fc, req);
710 err = req->out.h.error;
711 fuse_put_request(fc, req);
714 fuse_invalidate_attr(oldent->d_inode);
716 fuse_invalidate_attr(olddir);
717 if (olddir != newdir)
718 fuse_invalidate_attr(newdir);
720 /* newent will end up negative */
721 if (newent->d_inode) {
722 fuse_invalidate_attr(newent->d_inode);
723 fuse_invalidate_entry_cache(newent);
725 } else if (err == -EINTR) {
726 /* If request was interrupted, DEITY only knows if the
727 rename actually took place. If the invalidation
728 fails (e.g. some process has CWD under the renamed
729 directory), then there can be inconsistency between
730 the dcache and the real filesystem. Tough luck. */
731 fuse_invalidate_entry(oldent);
733 fuse_invalidate_entry(newent);
739 static int fuse_link(struct dentry *entry, struct inode *newdir,
740 struct dentry *newent)
743 struct fuse_link_in inarg;
744 struct inode *inode = entry->d_inode;
745 struct fuse_conn *fc = get_fuse_conn(inode);
746 struct fuse_req *req = fuse_get_req(fc);
750 memset(&inarg, 0, sizeof(inarg));
751 inarg.oldnodeid = get_node_id(inode);
752 req->in.h.opcode = FUSE_LINK;
754 req->in.args[0].size = sizeof(inarg);
755 req->in.args[0].value = &inarg;
756 req->in.args[1].size = newent->d_name.len + 1;
757 req->in.args[1].value = newent->d_name.name;
758 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
759 /* Contrary to "normal" filesystems it can happen that link
760 makes two "logical" inodes point to the same "physical"
761 inode. We invalidate the attributes of the old one, so it
762 will reflect changes in the backing inode (link count,
765 if (!err || err == -EINTR)
766 fuse_invalidate_attr(inode);
770 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
773 stat->dev = inode->i_sb->s_dev;
774 stat->ino = attr->ino;
775 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
776 stat->nlink = attr->nlink;
777 stat->uid = attr->uid;
778 stat->gid = attr->gid;
779 stat->rdev = inode->i_rdev;
780 stat->atime.tv_sec = attr->atime;
781 stat->atime.tv_nsec = attr->atimensec;
782 stat->mtime.tv_sec = attr->mtime;
783 stat->mtime.tv_nsec = attr->mtimensec;
784 stat->ctime.tv_sec = attr->ctime;
785 stat->ctime.tv_nsec = attr->ctimensec;
786 stat->size = attr->size;
787 stat->blocks = attr->blocks;
788 stat->blksize = (1 << inode->i_blkbits);
791 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
795 struct fuse_getattr_in inarg;
796 struct fuse_attr_out outarg;
797 struct fuse_conn *fc = get_fuse_conn(inode);
798 struct fuse_req *req;
801 req = fuse_get_req(fc);
805 attr_version = fuse_get_attr_version(fc);
807 memset(&inarg, 0, sizeof(inarg));
808 memset(&outarg, 0, sizeof(outarg));
809 /* Directories have separate file-handle space */
810 if (file && S_ISREG(inode->i_mode)) {
811 struct fuse_file *ff = file->private_data;
813 inarg.getattr_flags |= FUSE_GETATTR_FH;
816 req->in.h.opcode = FUSE_GETATTR;
817 req->in.h.nodeid = get_node_id(inode);
819 req->in.args[0].size = sizeof(inarg);
820 req->in.args[0].value = &inarg;
821 req->out.numargs = 1;
823 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
825 req->out.args[0].size = sizeof(outarg);
826 req->out.args[0].value = &outarg;
827 fuse_request_send(fc, req);
828 err = req->out.h.error;
829 fuse_put_request(fc, req);
831 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
832 make_bad_inode(inode);
835 fuse_change_attributes(inode, &outarg.attr,
836 attr_timeout(&outarg),
839 fuse_fillattr(inode, &outarg.attr, stat);
845 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
846 struct file *file, bool *refreshed)
848 struct fuse_inode *fi = get_fuse_inode(inode);
852 if (time_before64(fi->i_time, get_jiffies_64())) {
854 err = fuse_do_getattr(inode, stat, file);
859 generic_fillattr(inode, stat);
860 stat->mode = fi->orig_i_mode;
861 stat->ino = fi->orig_ino;
865 if (refreshed != NULL)
871 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
875 struct inode *parent;
877 struct dentry *entry;
879 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
883 mutex_lock(&parent->i_mutex);
884 if (!S_ISDIR(parent->i_mode))
888 dir = d_find_alias(parent);
892 entry = d_lookup(dir, name);
897 fuse_invalidate_attr(parent);
898 fuse_invalidate_entry(entry);
903 mutex_unlock(&parent->i_mutex);
909 * Calling into a user-controlled filesystem gives the filesystem
910 * daemon ptrace-like capabilities over the requester process. This
911 * means, that the filesystem daemon is able to record the exact
912 * filesystem operations performed, and can also control the behavior
913 * of the requester process in otherwise impossible ways. For example
914 * it can delay the operation for arbitrary length of time allowing
915 * DoS against the requester.
917 * For this reason only those processes can call into the filesystem,
918 * for which the owner of the mount has ptrace privilege. This
919 * excludes processes started by other users, suid or sgid processes.
921 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
923 const struct cred *cred;
926 if (fc->flags & FUSE_ALLOW_OTHER)
931 cred = __task_cred(task);
932 if (cred->euid == fc->user_id &&
933 cred->suid == fc->user_id &&
934 cred->uid == fc->user_id &&
935 cred->egid == fc->group_id &&
936 cred->sgid == fc->group_id &&
937 cred->gid == fc->group_id)
944 static int fuse_access(struct inode *inode, int mask)
946 struct fuse_conn *fc = get_fuse_conn(inode);
947 struct fuse_req *req;
948 struct fuse_access_in inarg;
954 req = fuse_get_req(fc);
958 memset(&inarg, 0, sizeof(inarg));
959 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
960 req->in.h.opcode = FUSE_ACCESS;
961 req->in.h.nodeid = get_node_id(inode);
963 req->in.args[0].size = sizeof(inarg);
964 req->in.args[0].value = &inarg;
965 fuse_request_send(fc, req);
966 err = req->out.h.error;
967 fuse_put_request(fc, req);
968 if (err == -ENOSYS) {
975 static int fuse_perm_getattr(struct inode *inode, int mask)
977 if (mask & MAY_NOT_BLOCK)
980 return fuse_do_getattr(inode, NULL, NULL);
984 * Check permission. The two basic access models of FUSE are:
986 * 1) Local access checking ('default_permissions' mount option) based
987 * on file mode. This is the plain old disk filesystem permission
990 * 2) "Remote" access checking, where server is responsible for
991 * checking permission in each inode operation. An exception to this
992 * is if ->permission() was invoked from sys_access() in which case an
993 * access request is sent. Execute permission is still checked
994 * locally based on file mode.
996 static int fuse_permission(struct inode *inode, int mask)
998 struct fuse_conn *fc = get_fuse_conn(inode);
999 bool refreshed = false;
1002 if (!fuse_allow_task(fc, current))
1006 * If attributes are needed, refresh them before proceeding
1008 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1009 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1010 struct fuse_inode *fi = get_fuse_inode(inode);
1012 if (time_before64(fi->i_time, get_jiffies_64())) {
1015 err = fuse_perm_getattr(inode, mask);
1021 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1022 err = generic_permission(inode, mask);
1024 /* If permission is denied, try to refresh file
1025 attributes. This is also needed, because the root
1026 node will at first have no permissions */
1027 if (err == -EACCES && !refreshed) {
1028 err = fuse_perm_getattr(inode, mask);
1030 err = generic_permission(inode, mask);
1033 /* Note: the opposite of the above test does not
1034 exist. So if permissions are revoked this won't be
1035 noticed immediately, only after the attribute
1036 timeout has expired */
1037 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1038 if (mask & MAY_NOT_BLOCK)
1041 err = fuse_access(inode, mask);
1042 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1043 if (!(inode->i_mode & S_IXUGO)) {
1047 err = fuse_perm_getattr(inode, mask);
1048 if (!err && !(inode->i_mode & S_IXUGO))
1055 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1056 void *dstbuf, filldir_t filldir)
1058 while (nbytes >= FUSE_NAME_OFFSET) {
1059 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1060 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1062 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1064 if (reclen > nbytes)
1066 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1069 over = filldir(dstbuf, dirent->name, dirent->namelen,
1070 file->f_pos, dirent->ino, dirent->type);
1076 file->f_pos = dirent->off;
1082 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1087 struct inode *inode = file->f_path.dentry->d_inode;
1088 struct fuse_conn *fc = get_fuse_conn(inode);
1089 struct fuse_req *req;
1091 if (is_bad_inode(inode))
1094 req = fuse_get_req(fc);
1096 return PTR_ERR(req);
1098 page = alloc_page(GFP_KERNEL);
1100 fuse_put_request(fc, req);
1103 req->out.argpages = 1;
1105 req->pages[0] = page;
1106 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
1107 fuse_request_send(fc, req);
1108 nbytes = req->out.args[0].size;
1109 err = req->out.h.error;
1110 fuse_put_request(fc, req);
1112 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
1116 fuse_invalidate_attr(inode); /* atime changed */
1120 static char *read_link(struct dentry *dentry)
1122 struct inode *inode = dentry->d_inode;
1123 struct fuse_conn *fc = get_fuse_conn(inode);
1124 struct fuse_req *req = fuse_get_req(fc);
1128 return ERR_CAST(req);
1130 link = (char *) __get_free_page(GFP_KERNEL);
1132 link = ERR_PTR(-ENOMEM);
1135 req->in.h.opcode = FUSE_READLINK;
1136 req->in.h.nodeid = get_node_id(inode);
1137 req->out.argvar = 1;
1138 req->out.numargs = 1;
1139 req->out.args[0].size = PAGE_SIZE - 1;
1140 req->out.args[0].value = link;
1141 fuse_request_send(fc, req);
1142 if (req->out.h.error) {
1143 free_page((unsigned long) link);
1144 link = ERR_PTR(req->out.h.error);
1146 link[req->out.args[0].size] = '\0';
1148 fuse_put_request(fc, req);
1149 fuse_invalidate_attr(inode); /* atime changed */
1153 static void free_link(char *link)
1156 free_page((unsigned long) link);
1159 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1161 nd_set_link(nd, read_link(dentry));
1165 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1167 free_link(nd_get_link(nd));
1170 static int fuse_dir_open(struct inode *inode, struct file *file)
1172 return fuse_open_common(inode, file, true);
1175 static int fuse_dir_release(struct inode *inode, struct file *file)
1177 fuse_release_common(file, FUSE_RELEASEDIR);
1182 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1185 return fuse_fsync_common(file, start, end, datasync, 1);
1188 static bool update_mtime(unsigned ivalid)
1190 /* Always update if mtime is explicitly set */
1191 if (ivalid & ATTR_MTIME_SET)
1194 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1195 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1198 /* In all other cases update */
1202 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1204 unsigned ivalid = iattr->ia_valid;
1206 if (ivalid & ATTR_MODE)
1207 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1208 if (ivalid & ATTR_UID)
1209 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
1210 if (ivalid & ATTR_GID)
1211 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
1212 if (ivalid & ATTR_SIZE)
1213 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1214 if (ivalid & ATTR_ATIME) {
1215 arg->valid |= FATTR_ATIME;
1216 arg->atime = iattr->ia_atime.tv_sec;
1217 arg->atimensec = iattr->ia_atime.tv_nsec;
1218 if (!(ivalid & ATTR_ATIME_SET))
1219 arg->valid |= FATTR_ATIME_NOW;
1221 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1222 arg->valid |= FATTR_MTIME;
1223 arg->mtime = iattr->ia_mtime.tv_sec;
1224 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1225 if (!(ivalid & ATTR_MTIME_SET))
1226 arg->valid |= FATTR_MTIME_NOW;
1231 * Prevent concurrent writepages on inode
1233 * This is done by adding a negative bias to the inode write counter
1234 * and waiting for all pending writes to finish.
1236 void fuse_set_nowrite(struct inode *inode)
1238 struct fuse_conn *fc = get_fuse_conn(inode);
1239 struct fuse_inode *fi = get_fuse_inode(inode);
1241 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1243 spin_lock(&fc->lock);
1244 BUG_ON(fi->writectr < 0);
1245 fi->writectr += FUSE_NOWRITE;
1246 spin_unlock(&fc->lock);
1247 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1251 * Allow writepages on inode
1253 * Remove the bias from the writecounter and send any queued
1256 static void __fuse_release_nowrite(struct inode *inode)
1258 struct fuse_inode *fi = get_fuse_inode(inode);
1260 BUG_ON(fi->writectr != FUSE_NOWRITE);
1262 fuse_flush_writepages(inode);
1265 void fuse_release_nowrite(struct inode *inode)
1267 struct fuse_conn *fc = get_fuse_conn(inode);
1269 spin_lock(&fc->lock);
1270 __fuse_release_nowrite(inode);
1271 spin_unlock(&fc->lock);
1275 * Set attributes, and at the same time refresh them.
1277 * Truncation is slightly complicated, because the 'truncate' request
1278 * may fail, in which case we don't want to touch the mapping.
1279 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1280 * and the actual truncation by hand.
1282 static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1285 struct inode *inode = entry->d_inode;
1286 struct fuse_conn *fc = get_fuse_conn(inode);
1287 struct fuse_inode *fi = get_fuse_inode(inode);
1288 struct fuse_req *req;
1289 struct fuse_setattr_in inarg;
1290 struct fuse_attr_out outarg;
1291 bool is_truncate = false;
1295 if (!fuse_allow_task(fc, current))
1298 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1299 attr->ia_valid |= ATTR_FORCE;
1301 err = setattr_prepare(entry, attr);
1305 if (attr->ia_valid & ATTR_OPEN) {
1306 if (fc->atomic_o_trunc)
1311 if (attr->ia_valid & ATTR_SIZE)
1314 req = fuse_get_req(fc);
1316 return PTR_ERR(req);
1319 fuse_set_nowrite(inode);
1320 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1323 memset(&inarg, 0, sizeof(inarg));
1324 memset(&outarg, 0, sizeof(outarg));
1325 iattr_to_fattr(attr, &inarg);
1327 struct fuse_file *ff = file->private_data;
1328 inarg.valid |= FATTR_FH;
1331 if (attr->ia_valid & ATTR_SIZE) {
1332 /* For mandatory locking in truncate */
1333 inarg.valid |= FATTR_LOCKOWNER;
1334 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1336 req->in.h.opcode = FUSE_SETATTR;
1337 req->in.h.nodeid = get_node_id(inode);
1338 req->in.numargs = 1;
1339 req->in.args[0].size = sizeof(inarg);
1340 req->in.args[0].value = &inarg;
1341 req->out.numargs = 1;
1343 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1345 req->out.args[0].size = sizeof(outarg);
1346 req->out.args[0].value = &outarg;
1347 fuse_request_send(fc, req);
1348 err = req->out.h.error;
1349 fuse_put_request(fc, req);
1352 fuse_invalidate_attr(inode);
1356 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1357 make_bad_inode(inode);
1362 spin_lock(&fc->lock);
1363 fuse_change_attributes_common(inode, &outarg.attr,
1364 attr_timeout(&outarg));
1365 oldsize = inode->i_size;
1366 i_size_write(inode, outarg.attr.size);
1369 /* NOTE: this may release/reacquire fc->lock */
1370 __fuse_release_nowrite(inode);
1372 spin_unlock(&fc->lock);
1375 * Only call invalidate_inode_pages2() after removing
1376 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1378 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1379 truncate_pagecache(inode, oldsize, outarg.attr.size);
1380 invalidate_inode_pages2(inode->i_mapping);
1383 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1388 fuse_release_nowrite(inode);
1390 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1394 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1396 struct inode *inode = entry->d_inode;
1397 struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL;
1400 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) {
1403 attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID |
1406 * ia_mode calculation may have used stale i_mode. Refresh and
1409 ret = fuse_do_getattr(inode, NULL, file);
1413 attr->ia_mode = inode->i_mode;
1414 kill = should_remove_suid(entry);
1415 if (kill & ATTR_KILL_SUID) {
1416 attr->ia_valid |= ATTR_MODE;
1417 attr->ia_mode &= ~S_ISUID;
1419 if (kill & ATTR_KILL_SGID) {
1420 attr->ia_valid |= ATTR_MODE;
1421 attr->ia_mode &= ~S_ISGID;
1424 if (!attr->ia_valid)
1427 ret = fuse_do_setattr(entry, attr, file);
1429 /* Directory mode changed, may need to revalidate access */
1430 if (S_ISDIR(entry->d_inode->i_mode) &&
1431 (attr->ia_valid & ATTR_MODE))
1432 fuse_invalidate_entry_cache(entry);
1437 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1440 struct inode *inode = entry->d_inode;
1441 struct fuse_conn *fc = get_fuse_conn(inode);
1443 if (!fuse_allow_task(fc, current))
1446 return fuse_update_attributes(inode, stat, NULL, NULL);
1449 static int fuse_setxattr(struct dentry *entry, const char *name,
1450 const void *value, size_t size, int flags)
1452 struct inode *inode = entry->d_inode;
1453 struct fuse_conn *fc = get_fuse_conn(inode);
1454 struct fuse_req *req;
1455 struct fuse_setxattr_in inarg;
1458 if (fc->no_setxattr)
1461 req = fuse_get_req(fc);
1463 return PTR_ERR(req);
1465 memset(&inarg, 0, sizeof(inarg));
1467 inarg.flags = flags;
1468 req->in.h.opcode = FUSE_SETXATTR;
1469 req->in.h.nodeid = get_node_id(inode);
1470 req->in.numargs = 3;
1471 req->in.args[0].size = sizeof(inarg);
1472 req->in.args[0].value = &inarg;
1473 req->in.args[1].size = strlen(name) + 1;
1474 req->in.args[1].value = name;
1475 req->in.args[2].size = size;
1476 req->in.args[2].value = value;
1477 fuse_request_send(fc, req);
1478 err = req->out.h.error;
1479 fuse_put_request(fc, req);
1480 if (err == -ENOSYS) {
1481 fc->no_setxattr = 1;
1485 fuse_invalidate_attr(inode);
1489 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1490 void *value, size_t size)
1492 struct inode *inode = entry->d_inode;
1493 struct fuse_conn *fc = get_fuse_conn(inode);
1494 struct fuse_req *req;
1495 struct fuse_getxattr_in inarg;
1496 struct fuse_getxattr_out outarg;
1499 if (fc->no_getxattr)
1502 req = fuse_get_req(fc);
1504 return PTR_ERR(req);
1506 memset(&inarg, 0, sizeof(inarg));
1508 req->in.h.opcode = FUSE_GETXATTR;
1509 req->in.h.nodeid = get_node_id(inode);
1510 req->in.numargs = 2;
1511 req->in.args[0].size = sizeof(inarg);
1512 req->in.args[0].value = &inarg;
1513 req->in.args[1].size = strlen(name) + 1;
1514 req->in.args[1].value = name;
1515 /* This is really two different operations rolled into one */
1516 req->out.numargs = 1;
1518 req->out.argvar = 1;
1519 req->out.args[0].size = size;
1520 req->out.args[0].value = value;
1522 req->out.args[0].size = sizeof(outarg);
1523 req->out.args[0].value = &outarg;
1525 fuse_request_send(fc, req);
1526 ret = req->out.h.error;
1528 ret = size ? req->out.args[0].size : outarg.size;
1530 if (ret == -ENOSYS) {
1531 fc->no_getxattr = 1;
1535 fuse_put_request(fc, req);
1539 static int fuse_verify_xattr_list(char *list, size_t size)
1541 size_t origsize = size;
1544 size_t thislen = strnlen(list, size);
1546 if (!thislen || thislen == size)
1549 size -= thislen + 1;
1550 list += thislen + 1;
1556 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1558 struct inode *inode = entry->d_inode;
1559 struct fuse_conn *fc = get_fuse_conn(inode);
1560 struct fuse_req *req;
1561 struct fuse_getxattr_in inarg;
1562 struct fuse_getxattr_out outarg;
1565 if (!fuse_allow_task(fc, current))
1568 if (fc->no_listxattr)
1571 req = fuse_get_req(fc);
1573 return PTR_ERR(req);
1575 memset(&inarg, 0, sizeof(inarg));
1577 req->in.h.opcode = FUSE_LISTXATTR;
1578 req->in.h.nodeid = get_node_id(inode);
1579 req->in.numargs = 1;
1580 req->in.args[0].size = sizeof(inarg);
1581 req->in.args[0].value = &inarg;
1582 /* This is really two different operations rolled into one */
1583 req->out.numargs = 1;
1585 req->out.argvar = 1;
1586 req->out.args[0].size = size;
1587 req->out.args[0].value = list;
1589 req->out.args[0].size = sizeof(outarg);
1590 req->out.args[0].value = &outarg;
1592 fuse_request_send(fc, req);
1593 ret = req->out.h.error;
1595 ret = size ? req->out.args[0].size : outarg.size;
1596 if (ret > 0 && size)
1597 ret = fuse_verify_xattr_list(list, ret);
1599 if (ret == -ENOSYS) {
1600 fc->no_listxattr = 1;
1604 fuse_put_request(fc, req);
1608 static int fuse_removexattr(struct dentry *entry, const char *name)
1610 struct inode *inode = entry->d_inode;
1611 struct fuse_conn *fc = get_fuse_conn(inode);
1612 struct fuse_req *req;
1615 if (fc->no_removexattr)
1618 req = fuse_get_req(fc);
1620 return PTR_ERR(req);
1622 req->in.h.opcode = FUSE_REMOVEXATTR;
1623 req->in.h.nodeid = get_node_id(inode);
1624 req->in.numargs = 1;
1625 req->in.args[0].size = strlen(name) + 1;
1626 req->in.args[0].value = name;
1627 fuse_request_send(fc, req);
1628 err = req->out.h.error;
1629 fuse_put_request(fc, req);
1630 if (err == -ENOSYS) {
1631 fc->no_removexattr = 1;
1635 fuse_invalidate_attr(inode);
1639 static const struct inode_operations fuse_dir_inode_operations = {
1640 .lookup = fuse_lookup,
1641 .mkdir = fuse_mkdir,
1642 .symlink = fuse_symlink,
1643 .unlink = fuse_unlink,
1644 .rmdir = fuse_rmdir,
1645 .rename = fuse_rename,
1647 .setattr = fuse_setattr,
1648 .create = fuse_create,
1649 .mknod = fuse_mknod,
1650 .permission = fuse_permission,
1651 .getattr = fuse_getattr,
1652 .setxattr = fuse_setxattr,
1653 .getxattr = fuse_getxattr,
1654 .listxattr = fuse_listxattr,
1655 .removexattr = fuse_removexattr,
1658 static const struct file_operations fuse_dir_operations = {
1659 .llseek = generic_file_llseek,
1660 .read = generic_read_dir,
1661 .readdir = fuse_readdir,
1662 .open = fuse_dir_open,
1663 .release = fuse_dir_release,
1664 .fsync = fuse_dir_fsync,
1667 static const struct inode_operations fuse_common_inode_operations = {
1668 .setattr = fuse_setattr,
1669 .permission = fuse_permission,
1670 .getattr = fuse_getattr,
1671 .setxattr = fuse_setxattr,
1672 .getxattr = fuse_getxattr,
1673 .listxattr = fuse_listxattr,
1674 .removexattr = fuse_removexattr,
1677 static const struct inode_operations fuse_symlink_inode_operations = {
1678 .setattr = fuse_setattr,
1679 .follow_link = fuse_follow_link,
1680 .put_link = fuse_put_link,
1681 .readlink = generic_readlink,
1682 .getattr = fuse_getattr,
1683 .setxattr = fuse_setxattr,
1684 .getxattr = fuse_getxattr,
1685 .listxattr = fuse_listxattr,
1686 .removexattr = fuse_removexattr,
1689 void fuse_init_common(struct inode *inode)
1691 inode->i_op = &fuse_common_inode_operations;
1694 void fuse_init_dir(struct inode *inode)
1696 inode->i_op = &fuse_dir_inode_operations;
1697 inode->i_fop = &fuse_dir_operations;
1700 void fuse_init_symlink(struct inode *inode)
1702 inode->i_op = &fuse_symlink_inode_operations;