2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu>
5 This program can be distributed under the terms of the GNU GPL.
11 #include <linux/pagemap.h>
12 #include <linux/file.h>
13 #include <linux/gfp.h>
14 #include <linux/sched.h>
15 #include <linux/namei.h>
17 #if BITS_PER_LONG >= 64
18 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
23 static inline u64 fuse_dentry_time(struct dentry *entry)
29 * On 32 bit archs store the high 32 bits of time in d_fsdata
31 static void fuse_dentry_settime(struct dentry *entry, u64 time)
34 entry->d_fsdata = (void *) (unsigned long) (time >> 32);
37 static u64 fuse_dentry_time(struct dentry *entry)
39 return (u64) entry->d_time +
40 ((u64) (unsigned long) entry->d_fsdata << 32);
45 * FUSE caches dentries and attributes with separate timeout. The
46 * time in jiffies until the dentry/attributes are valid is stored in
47 * dentry->d_time and fuse_inode->i_time respectively.
51 * Calculate the time in jiffies until a dentry/attributes are valid
53 static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
56 struct timespec ts = {sec, nsec};
57 return get_jiffies_64() + timespec_to_jiffies(&ts);
63 * Set dentry and possibly attribute timeouts from the lookup/mk*
66 static void fuse_change_entry_timeout(struct dentry *entry,
67 struct fuse_entry_out *o)
69 fuse_dentry_settime(entry,
70 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
73 static u64 attr_timeout(struct fuse_attr_out *o)
75 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
78 static u64 entry_attr_timeout(struct fuse_entry_out *o)
80 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
84 * Mark the attributes as stale, so that at the next call to
85 * ->getattr() they will be fetched from userspace
87 void fuse_invalidate_attr(struct inode *inode)
89 get_fuse_inode(inode)->i_time = 0;
93 * Just mark the entry as stale, so that a next attempt to look it up
94 * will result in a new lookup call to userspace
96 * This is called when a dentry is about to become negative and the
97 * timeout is unknown (unlink, rmdir, rename and in some cases
100 static 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_req *req, struct inode *dir,
116 struct dentry *entry,
117 struct fuse_entry_out *outarg)
119 struct fuse_conn *fc = get_fuse_conn(dir);
121 memset(outarg, 0, sizeof(struct fuse_entry_out));
122 req->in.h.opcode = FUSE_LOOKUP;
123 req->in.h.nodeid = get_node_id(dir);
125 req->in.args[0].size = entry->d_name.len + 1;
126 req->in.args[0].value = entry->d_name.name;
127 req->out.numargs = 1;
129 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
131 req->out.args[0].size = sizeof(struct fuse_entry_out);
132 req->out.args[0].value = outarg;
135 static u64 fuse_get_attr_version(struct fuse_conn *fc)
140 * The spin lock isn't actually needed on 64bit archs, but we
141 * don't yet care too much about such optimizations.
143 spin_lock(&fc->lock);
144 curr_version = fc->attr_version;
145 spin_unlock(&fc->lock);
151 * Check whether the dentry is still valid
153 * If the entry validity timeout has expired and the dentry is
154 * positive, try to redo the lookup. If the lookup results in a
155 * different inode, then let the VFS invalidate the dentry and redo
156 * the lookup once more. If the lookup results in the same inode,
157 * then refresh the attributes, timeouts and mark the dentry valid.
159 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
161 struct inode *inode = entry->d_inode;
163 if (inode && is_bad_inode(inode))
165 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
167 struct fuse_entry_out outarg;
168 struct fuse_conn *fc;
169 struct fuse_req *req;
170 struct fuse_req *forget_req;
171 struct dentry *parent;
174 /* For negative dentries, always do a fresh lookup */
178 fc = get_fuse_conn(inode);
179 req = fuse_get_req(fc);
183 forget_req = fuse_get_req(fc);
184 if (IS_ERR(forget_req)) {
185 fuse_put_request(fc, req);
189 attr_version = fuse_get_attr_version(fc);
191 parent = dget_parent(entry);
192 fuse_lookup_init(req, parent->d_inode, entry, &outarg);
193 request_send(fc, req);
195 err = req->out.h.error;
196 fuse_put_request(fc, req);
197 /* Zero nodeid is same as -ENOENT */
198 if (!err && !outarg.nodeid)
201 struct fuse_inode *fi = get_fuse_inode(inode);
202 if (outarg.nodeid != get_node_id(inode)) {
203 fuse_send_forget(fc, forget_req,
207 spin_lock(&fc->lock);
209 spin_unlock(&fc->lock);
211 fuse_put_request(fc, forget_req);
212 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
215 fuse_change_attributes(inode, &outarg.attr,
216 entry_attr_timeout(&outarg),
218 fuse_change_entry_timeout(entry, &outarg);
223 static int invalid_nodeid(u64 nodeid)
225 return !nodeid || nodeid == FUSE_ROOT_ID;
228 static struct dentry_operations fuse_dentry_operations = {
229 .d_revalidate = fuse_dentry_revalidate,
232 int fuse_valid_type(int m)
234 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
235 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
239 * Add a directory inode to a dentry, ensuring that no other dentry
240 * refers to this inode. Called with fc->inst_mutex.
242 static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
244 struct dentry *alias = d_find_alias(inode);
246 /* This tries to shrink the subtree below alias */
247 fuse_invalidate_entry(alias);
249 if (!list_empty(&inode->i_dentry))
256 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
257 struct nameidata *nd)
260 struct fuse_entry_out outarg;
261 struct inode *inode = NULL;
262 struct fuse_conn *fc = get_fuse_conn(dir);
263 struct fuse_req *req;
264 struct fuse_req *forget_req;
267 if (entry->d_name.len > FUSE_NAME_MAX)
268 return ERR_PTR(-ENAMETOOLONG);
270 req = fuse_get_req(fc);
272 return ERR_PTR(PTR_ERR(req));
274 forget_req = fuse_get_req(fc);
275 if (IS_ERR(forget_req)) {
276 fuse_put_request(fc, req);
277 return ERR_PTR(PTR_ERR(forget_req));
280 attr_version = fuse_get_attr_version(fc);
282 fuse_lookup_init(req, dir, entry, &outarg);
283 request_send(fc, req);
284 err = req->out.h.error;
285 fuse_put_request(fc, req);
286 /* Zero nodeid is same as -ENOENT, but with valid timeout */
287 if (!err && outarg.nodeid &&
288 (invalid_nodeid(outarg.nodeid) ||
289 !fuse_valid_type(outarg.attr.mode)))
291 if (!err && outarg.nodeid) {
292 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
293 &outarg.attr, entry_attr_timeout(&outarg),
296 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
297 return ERR_PTR(-ENOMEM);
300 fuse_put_request(fc, forget_req);
301 if (err && err != -ENOENT)
304 if (inode && S_ISDIR(inode->i_mode)) {
305 mutex_lock(&fc->inst_mutex);
306 err = fuse_d_add_directory(entry, inode);
307 mutex_unlock(&fc->inst_mutex);
315 entry->d_op = &fuse_dentry_operations;
317 fuse_change_entry_timeout(entry, &outarg);
319 fuse_invalidate_entry_cache(entry);
324 * Synchronous release for the case when something goes wrong in CREATE_OPEN
326 static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
327 u64 nodeid, int flags)
329 fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
330 ff->reserved_req->force = 1;
331 request_send(fc, ff->reserved_req);
332 fuse_put_request(fc, ff->reserved_req);
337 * Atomic create+open operation
339 * If the filesystem doesn't support this, then fall back to separate
340 * 'mknod' + 'open' requests.
342 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
343 struct nameidata *nd)
347 struct fuse_conn *fc = get_fuse_conn(dir);
348 struct fuse_req *req;
349 struct fuse_req *forget_req;
350 struct fuse_open_in inarg;
351 struct fuse_open_out outopen;
352 struct fuse_entry_out outentry;
353 struct fuse_file *ff;
355 int flags = nd->intent.open.flags - 1;
360 forget_req = fuse_get_req(fc);
361 if (IS_ERR(forget_req))
362 return PTR_ERR(forget_req);
364 req = fuse_get_req(fc);
367 goto out_put_forget_req;
370 ff = fuse_file_alloc();
372 goto out_put_request;
375 memset(&inarg, 0, sizeof(inarg));
376 memset(&outentry, 0, sizeof(outentry));
379 req->in.h.opcode = FUSE_CREATE;
380 req->in.h.nodeid = get_node_id(dir);
382 req->in.args[0].size = sizeof(inarg);
383 req->in.args[0].value = &inarg;
384 req->in.args[1].size = entry->d_name.len + 1;
385 req->in.args[1].value = entry->d_name.name;
386 req->out.numargs = 2;
388 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
390 req->out.args[0].size = sizeof(outentry);
391 req->out.args[0].value = &outentry;
392 req->out.args[1].size = sizeof(outopen);
393 req->out.args[1].value = &outopen;
394 request_send(fc, req);
395 err = req->out.h.error;
403 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
406 fuse_put_request(fc, req);
407 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
408 &outentry.attr, entry_attr_timeout(&outentry), 0);
410 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
412 fuse_sync_release(fc, ff, outentry.nodeid, flags);
413 fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
416 fuse_put_request(fc, forget_req);
417 d_instantiate(entry, inode);
418 fuse_change_entry_timeout(entry, &outentry);
419 file = lookup_instantiate_filp(nd, entry, generic_file_open);
422 fuse_sync_release(fc, ff, outentry.nodeid, flags);
423 return PTR_ERR(file);
425 fuse_finish_open(inode, file, ff, &outopen);
431 fuse_put_request(fc, req);
433 fuse_put_request(fc, forget_req);
438 * Code shared between mknod, mkdir, symlink and link
440 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
441 struct inode *dir, struct dentry *entry,
444 struct fuse_entry_out outarg;
447 struct fuse_req *forget_req;
449 forget_req = fuse_get_req(fc);
450 if (IS_ERR(forget_req)) {
451 fuse_put_request(fc, req);
452 return PTR_ERR(forget_req);
455 memset(&outarg, 0, sizeof(outarg));
456 req->in.h.nodeid = get_node_id(dir);
457 req->out.numargs = 1;
459 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
461 req->out.args[0].size = sizeof(outarg);
462 req->out.args[0].value = &outarg;
463 request_send(fc, req);
464 err = req->out.h.error;
465 fuse_put_request(fc, req);
467 goto out_put_forget_req;
470 if (invalid_nodeid(outarg.nodeid))
471 goto out_put_forget_req;
473 if ((outarg.attr.mode ^ mode) & S_IFMT)
474 goto out_put_forget_req;
476 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
477 &outarg.attr, entry_attr_timeout(&outarg), 0);
479 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
482 fuse_put_request(fc, forget_req);
484 if (S_ISDIR(inode->i_mode)) {
485 struct dentry *alias;
486 mutex_lock(&fc->inst_mutex);
487 alias = d_find_alias(inode);
489 /* New directory must have moved since mkdir */
490 mutex_unlock(&fc->inst_mutex);
495 d_instantiate(entry, inode);
496 mutex_unlock(&fc->inst_mutex);
498 d_instantiate(entry, inode);
500 fuse_change_entry_timeout(entry, &outarg);
501 fuse_invalidate_attr(dir);
505 fuse_put_request(fc, forget_req);
509 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
512 struct fuse_mknod_in inarg;
513 struct fuse_conn *fc = get_fuse_conn(dir);
514 struct fuse_req *req = fuse_get_req(fc);
518 memset(&inarg, 0, sizeof(inarg));
520 inarg.rdev = new_encode_dev(rdev);
521 req->in.h.opcode = FUSE_MKNOD;
523 req->in.args[0].size = sizeof(inarg);
524 req->in.args[0].value = &inarg;
525 req->in.args[1].size = entry->d_name.len + 1;
526 req->in.args[1].value = entry->d_name.name;
527 return create_new_entry(fc, req, dir, entry, mode);
530 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
531 struct nameidata *nd)
533 if (nd && (nd->flags & LOOKUP_OPEN)) {
534 int err = fuse_create_open(dir, entry, mode, nd);
537 /* Fall back on mknod */
539 return fuse_mknod(dir, entry, mode, 0);
542 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
544 struct fuse_mkdir_in inarg;
545 struct fuse_conn *fc = get_fuse_conn(dir);
546 struct fuse_req *req = fuse_get_req(fc);
550 memset(&inarg, 0, sizeof(inarg));
552 req->in.h.opcode = FUSE_MKDIR;
554 req->in.args[0].size = sizeof(inarg);
555 req->in.args[0].value = &inarg;
556 req->in.args[1].size = entry->d_name.len + 1;
557 req->in.args[1].value = entry->d_name.name;
558 return create_new_entry(fc, req, dir, entry, S_IFDIR);
561 static int fuse_symlink(struct inode *dir, struct dentry *entry,
564 struct fuse_conn *fc = get_fuse_conn(dir);
565 unsigned len = strlen(link) + 1;
566 struct fuse_req *req = fuse_get_req(fc);
570 req->in.h.opcode = FUSE_SYMLINK;
572 req->in.args[0].size = entry->d_name.len + 1;
573 req->in.args[0].value = entry->d_name.name;
574 req->in.args[1].size = len;
575 req->in.args[1].value = link;
576 return create_new_entry(fc, req, dir, entry, S_IFLNK);
579 static int fuse_unlink(struct inode *dir, struct dentry *entry)
582 struct fuse_conn *fc = get_fuse_conn(dir);
583 struct fuse_req *req = fuse_get_req(fc);
587 req->in.h.opcode = FUSE_UNLINK;
588 req->in.h.nodeid = get_node_id(dir);
590 req->in.args[0].size = entry->d_name.len + 1;
591 req->in.args[0].value = entry->d_name.name;
592 request_send(fc, req);
593 err = req->out.h.error;
594 fuse_put_request(fc, req);
596 struct inode *inode = entry->d_inode;
598 /* Set nlink to zero so the inode can be cleared, if
599 the inode does have more links this will be
600 discovered at the next lookup/getattr */
602 fuse_invalidate_attr(inode);
603 fuse_invalidate_attr(dir);
604 fuse_invalidate_entry_cache(entry);
605 } else if (err == -EINTR)
606 fuse_invalidate_entry(entry);
610 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
613 struct fuse_conn *fc = get_fuse_conn(dir);
614 struct fuse_req *req = fuse_get_req(fc);
618 req->in.h.opcode = FUSE_RMDIR;
619 req->in.h.nodeid = get_node_id(dir);
621 req->in.args[0].size = entry->d_name.len + 1;
622 req->in.args[0].value = entry->d_name.name;
623 request_send(fc, req);
624 err = req->out.h.error;
625 fuse_put_request(fc, req);
627 clear_nlink(entry->d_inode);
628 fuse_invalidate_attr(dir);
629 fuse_invalidate_entry_cache(entry);
630 } else if (err == -EINTR)
631 fuse_invalidate_entry(entry);
635 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
636 struct inode *newdir, struct dentry *newent)
639 struct fuse_rename_in inarg;
640 struct fuse_conn *fc = get_fuse_conn(olddir);
641 struct fuse_req *req = fuse_get_req(fc);
645 memset(&inarg, 0, sizeof(inarg));
646 inarg.newdir = get_node_id(newdir);
647 req->in.h.opcode = FUSE_RENAME;
648 req->in.h.nodeid = get_node_id(olddir);
650 req->in.args[0].size = sizeof(inarg);
651 req->in.args[0].value = &inarg;
652 req->in.args[1].size = oldent->d_name.len + 1;
653 req->in.args[1].value = oldent->d_name.name;
654 req->in.args[2].size = newent->d_name.len + 1;
655 req->in.args[2].value = newent->d_name.name;
656 request_send(fc, req);
657 err = req->out.h.error;
658 fuse_put_request(fc, req);
660 fuse_invalidate_attr(olddir);
661 if (olddir != newdir)
662 fuse_invalidate_attr(newdir);
664 /* newent will end up negative */
666 fuse_invalidate_entry_cache(newent);
667 } else if (err == -EINTR) {
668 /* If request was interrupted, DEITY only knows if the
669 rename actually took place. If the invalidation
670 fails (e.g. some process has CWD under the renamed
671 directory), then there can be inconsistency between
672 the dcache and the real filesystem. Tough luck. */
673 fuse_invalidate_entry(oldent);
675 fuse_invalidate_entry(newent);
681 static int fuse_link(struct dentry *entry, struct inode *newdir,
682 struct dentry *newent)
685 struct fuse_link_in inarg;
686 struct inode *inode = entry->d_inode;
687 struct fuse_conn *fc = get_fuse_conn(inode);
688 struct fuse_req *req = fuse_get_req(fc);
692 memset(&inarg, 0, sizeof(inarg));
693 inarg.oldnodeid = get_node_id(inode);
694 req->in.h.opcode = FUSE_LINK;
696 req->in.args[0].size = sizeof(inarg);
697 req->in.args[0].value = &inarg;
698 req->in.args[1].size = newent->d_name.len + 1;
699 req->in.args[1].value = newent->d_name.name;
700 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
701 /* Contrary to "normal" filesystems it can happen that link
702 makes two "logical" inodes point to the same "physical"
703 inode. We invalidate the attributes of the old one, so it
704 will reflect changes in the backing inode (link count,
707 if (!err || err == -EINTR)
708 fuse_invalidate_attr(inode);
712 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
715 stat->dev = inode->i_sb->s_dev;
716 stat->ino = attr->ino;
717 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
718 stat->nlink = attr->nlink;
719 stat->uid = attr->uid;
720 stat->gid = attr->gid;
721 stat->rdev = inode->i_rdev;
722 stat->atime.tv_sec = attr->atime;
723 stat->atime.tv_nsec = attr->atimensec;
724 stat->mtime.tv_sec = attr->mtime;
725 stat->mtime.tv_nsec = attr->mtimensec;
726 stat->ctime.tv_sec = attr->ctime;
727 stat->ctime.tv_nsec = attr->ctimensec;
728 stat->size = attr->size;
729 stat->blocks = attr->blocks;
730 stat->blksize = (1 << inode->i_blkbits);
733 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
737 struct fuse_getattr_in inarg;
738 struct fuse_attr_out outarg;
739 struct fuse_conn *fc = get_fuse_conn(inode);
740 struct fuse_req *req;
743 req = fuse_get_req(fc);
747 attr_version = fuse_get_attr_version(fc);
749 memset(&inarg, 0, sizeof(inarg));
750 memset(&outarg, 0, sizeof(outarg));
751 /* Directories have separate file-handle space */
752 if (file && S_ISREG(inode->i_mode)) {
753 struct fuse_file *ff = file->private_data;
755 inarg.getattr_flags |= FUSE_GETATTR_FH;
758 req->in.h.opcode = FUSE_GETATTR;
759 req->in.h.nodeid = get_node_id(inode);
761 req->in.args[0].size = sizeof(inarg);
762 req->in.args[0].value = &inarg;
763 req->out.numargs = 1;
765 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
767 req->out.args[0].size = sizeof(outarg);
768 req->out.args[0].value = &outarg;
769 request_send(fc, req);
770 err = req->out.h.error;
771 fuse_put_request(fc, req);
773 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
774 make_bad_inode(inode);
777 fuse_change_attributes(inode, &outarg.attr,
778 attr_timeout(&outarg),
781 fuse_fillattr(inode, &outarg.attr, stat);
787 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
788 struct file *file, bool *refreshed)
790 struct fuse_inode *fi = get_fuse_inode(inode);
794 if (fi->i_time < get_jiffies_64()) {
796 err = fuse_do_getattr(inode, stat, file);
801 generic_fillattr(inode, stat);
802 stat->mode = fi->orig_i_mode;
806 if (refreshed != NULL)
813 * Calling into a user-controlled filesystem gives the filesystem
814 * daemon ptrace-like capabilities over the requester process. This
815 * means, that the filesystem daemon is able to record the exact
816 * filesystem operations performed, and can also control the behavior
817 * of the requester process in otherwise impossible ways. For example
818 * it can delay the operation for arbitrary length of time allowing
819 * DoS against the requester.
821 * For this reason only those processes can call into the filesystem,
822 * for which the owner of the mount has ptrace privilege. This
823 * excludes processes started by other users, suid or sgid processes.
825 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
827 if (fc->flags & FUSE_ALLOW_OTHER)
830 if (task->euid == fc->user_id &&
831 task->suid == fc->user_id &&
832 task->uid == fc->user_id &&
833 task->egid == fc->group_id &&
834 task->sgid == fc->group_id &&
835 task->gid == fc->group_id)
841 static int fuse_access(struct inode *inode, int mask)
843 struct fuse_conn *fc = get_fuse_conn(inode);
844 struct fuse_req *req;
845 struct fuse_access_in inarg;
851 req = fuse_get_req(fc);
855 memset(&inarg, 0, sizeof(inarg));
857 req->in.h.opcode = FUSE_ACCESS;
858 req->in.h.nodeid = get_node_id(inode);
860 req->in.args[0].size = sizeof(inarg);
861 req->in.args[0].value = &inarg;
862 request_send(fc, req);
863 err = req->out.h.error;
864 fuse_put_request(fc, req);
865 if (err == -ENOSYS) {
873 * Check permission. The two basic access models of FUSE are:
875 * 1) Local access checking ('default_permissions' mount option) based
876 * on file mode. This is the plain old disk filesystem permission
879 * 2) "Remote" access checking, where server is responsible for
880 * checking permission in each inode operation. An exception to this
881 * is if ->permission() was invoked from sys_access() in which case an
882 * access request is sent. Execute permission is still checked
883 * locally based on file mode.
885 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
887 struct fuse_conn *fc = get_fuse_conn(inode);
888 bool refreshed = false;
891 if (!fuse_allow_task(fc, current))
895 * If attributes are needed, refresh them before proceeding
897 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
898 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
899 err = fuse_update_attributes(inode, NULL, NULL, &refreshed);
904 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
905 int err = generic_permission(inode, mask, NULL);
907 /* If permission is denied, try to refresh file
908 attributes. This is also needed, because the root
909 node will at first have no permissions */
910 if (err == -EACCES && !refreshed) {
911 err = fuse_do_getattr(inode, NULL, NULL);
913 err = generic_permission(inode, mask, NULL);
916 /* Note: the opposite of the above test does not
917 exist. So if permissions are revoked this won't be
918 noticed immediately, only after the attribute
919 timeout has expired */
920 } else if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR))) {
921 err = fuse_access(inode, mask);
922 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
923 if (!(inode->i_mode & S_IXUGO)) {
927 err = fuse_do_getattr(inode, NULL, NULL);
928 if (!err && !(inode->i_mode & S_IXUGO))
935 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
936 void *dstbuf, filldir_t filldir)
938 while (nbytes >= FUSE_NAME_OFFSET) {
939 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
940 size_t reclen = FUSE_DIRENT_SIZE(dirent);
942 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
947 over = filldir(dstbuf, dirent->name, dirent->namelen,
948 file->f_pos, dirent->ino, dirent->type);
954 file->f_pos = dirent->off;
960 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
965 struct inode *inode = file->f_path.dentry->d_inode;
966 struct fuse_conn *fc = get_fuse_conn(inode);
967 struct fuse_file *ff = file->private_data;
968 struct fuse_req *req;
970 if (is_bad_inode(inode))
973 req = fuse_get_req(fc);
977 page = alloc_page(GFP_KERNEL);
979 fuse_put_request(fc, req);
983 req->pages[0] = page;
984 fuse_read_fill(req, ff, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
985 request_send(fc, req);
986 nbytes = req->out.args[0].size;
987 err = req->out.h.error;
988 fuse_put_request(fc, req);
990 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
994 fuse_invalidate_attr(inode); /* atime changed */
998 static char *read_link(struct dentry *dentry)
1000 struct inode *inode = dentry->d_inode;
1001 struct fuse_conn *fc = get_fuse_conn(inode);
1002 struct fuse_req *req = fuse_get_req(fc);
1006 return ERR_PTR(PTR_ERR(req));
1008 link = (char *) __get_free_page(GFP_KERNEL);
1010 link = ERR_PTR(-ENOMEM);
1013 req->in.h.opcode = FUSE_READLINK;
1014 req->in.h.nodeid = get_node_id(inode);
1015 req->out.argvar = 1;
1016 req->out.numargs = 1;
1017 req->out.args[0].size = PAGE_SIZE - 1;
1018 req->out.args[0].value = link;
1019 request_send(fc, req);
1020 if (req->out.h.error) {
1021 free_page((unsigned long) link);
1022 link = ERR_PTR(req->out.h.error);
1024 link[req->out.args[0].size] = '\0';
1026 fuse_put_request(fc, req);
1027 fuse_invalidate_attr(inode); /* atime changed */
1031 static void free_link(char *link)
1034 free_page((unsigned long) link);
1037 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1039 nd_set_link(nd, read_link(dentry));
1043 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1045 free_link(nd_get_link(nd));
1048 static int fuse_dir_open(struct inode *inode, struct file *file)
1050 return fuse_open_common(inode, file, 1);
1053 static int fuse_dir_release(struct inode *inode, struct file *file)
1055 return fuse_release_common(inode, file, 1);
1058 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
1060 /* nfsd can call this with no file */
1061 return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
1064 static bool update_mtime(unsigned ivalid)
1066 /* Always update if mtime is explicitly set */
1067 if (ivalid & ATTR_MTIME_SET)
1070 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1071 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1074 /* In all other cases update */
1078 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1080 unsigned ivalid = iattr->ia_valid;
1082 if (ivalid & ATTR_MODE)
1083 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1084 if (ivalid & ATTR_UID)
1085 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
1086 if (ivalid & ATTR_GID)
1087 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
1088 if (ivalid & ATTR_SIZE)
1089 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1090 if (ivalid & ATTR_ATIME) {
1091 arg->valid |= FATTR_ATIME;
1092 arg->atime = iattr->ia_atime.tv_sec;
1093 arg->atimensec = iattr->ia_atime.tv_nsec;
1094 if (!(ivalid & ATTR_ATIME_SET))
1095 arg->valid |= FATTR_ATIME_NOW;
1097 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1098 arg->valid |= FATTR_MTIME;
1099 arg->mtime = iattr->ia_mtime.tv_sec;
1100 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1101 if (!(ivalid & ATTR_MTIME_SET))
1102 arg->valid |= FATTR_MTIME_NOW;
1107 * Set attributes, and at the same time refresh them.
1109 * Truncation is slightly complicated, because the 'truncate' request
1110 * may fail, in which case we don't want to touch the mapping.
1111 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1112 * and the actual truncation by hand.
1114 static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1117 struct inode *inode = entry->d_inode;
1118 struct fuse_conn *fc = get_fuse_conn(inode);
1119 struct fuse_req *req;
1120 struct fuse_setattr_in inarg;
1121 struct fuse_attr_out outarg;
1124 if (!fuse_allow_task(fc, current))
1127 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1128 err = inode_change_ok(inode, attr);
1133 if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
1136 if (attr->ia_valid & ATTR_SIZE) {
1137 unsigned long limit;
1138 if (IS_SWAPFILE(inode))
1140 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1141 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1142 send_sig(SIGXFSZ, current, 0);
1147 req = fuse_get_req(fc);
1149 return PTR_ERR(req);
1151 memset(&inarg, 0, sizeof(inarg));
1152 memset(&outarg, 0, sizeof(outarg));
1153 iattr_to_fattr(attr, &inarg);
1155 struct fuse_file *ff = file->private_data;
1156 inarg.valid |= FATTR_FH;
1159 if (attr->ia_valid & ATTR_SIZE) {
1160 /* For mandatory locking in truncate */
1161 inarg.valid |= FATTR_LOCKOWNER;
1162 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1164 req->in.h.opcode = FUSE_SETATTR;
1165 req->in.h.nodeid = get_node_id(inode);
1166 req->in.numargs = 1;
1167 req->in.args[0].size = sizeof(inarg);
1168 req->in.args[0].value = &inarg;
1169 req->out.numargs = 1;
1171 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1173 req->out.args[0].size = sizeof(outarg);
1174 req->out.args[0].value = &outarg;
1175 request_send(fc, req);
1176 err = req->out.h.error;
1177 fuse_put_request(fc, req);
1180 fuse_invalidate_attr(inode);
1184 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1185 make_bad_inode(inode);
1189 fuse_change_attributes(inode, &outarg.attr, attr_timeout(&outarg), 0);
1193 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1195 if (attr->ia_valid & ATTR_FILE)
1196 return fuse_do_setattr(entry, attr, attr->ia_file);
1198 return fuse_do_setattr(entry, attr, NULL);
1201 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1204 struct inode *inode = entry->d_inode;
1205 struct fuse_conn *fc = get_fuse_conn(inode);
1207 if (!fuse_allow_task(fc, current))
1210 return fuse_update_attributes(inode, stat, NULL, NULL);
1213 static int fuse_setxattr(struct dentry *entry, const char *name,
1214 const void *value, size_t size, int flags)
1216 struct inode *inode = entry->d_inode;
1217 struct fuse_conn *fc = get_fuse_conn(inode);
1218 struct fuse_req *req;
1219 struct fuse_setxattr_in inarg;
1222 if (fc->no_setxattr)
1225 req = fuse_get_req(fc);
1227 return PTR_ERR(req);
1229 memset(&inarg, 0, sizeof(inarg));
1231 inarg.flags = flags;
1232 req->in.h.opcode = FUSE_SETXATTR;
1233 req->in.h.nodeid = get_node_id(inode);
1234 req->in.numargs = 3;
1235 req->in.args[0].size = sizeof(inarg);
1236 req->in.args[0].value = &inarg;
1237 req->in.args[1].size = strlen(name) + 1;
1238 req->in.args[1].value = name;
1239 req->in.args[2].size = size;
1240 req->in.args[2].value = value;
1241 request_send(fc, req);
1242 err = req->out.h.error;
1243 fuse_put_request(fc, req);
1244 if (err == -ENOSYS) {
1245 fc->no_setxattr = 1;
1251 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1252 void *value, size_t size)
1254 struct inode *inode = entry->d_inode;
1255 struct fuse_conn *fc = get_fuse_conn(inode);
1256 struct fuse_req *req;
1257 struct fuse_getxattr_in inarg;
1258 struct fuse_getxattr_out outarg;
1261 if (fc->no_getxattr)
1264 req = fuse_get_req(fc);
1266 return PTR_ERR(req);
1268 memset(&inarg, 0, sizeof(inarg));
1270 req->in.h.opcode = FUSE_GETXATTR;
1271 req->in.h.nodeid = get_node_id(inode);
1272 req->in.numargs = 2;
1273 req->in.args[0].size = sizeof(inarg);
1274 req->in.args[0].value = &inarg;
1275 req->in.args[1].size = strlen(name) + 1;
1276 req->in.args[1].value = name;
1277 /* This is really two different operations rolled into one */
1278 req->out.numargs = 1;
1280 req->out.argvar = 1;
1281 req->out.args[0].size = size;
1282 req->out.args[0].value = value;
1284 req->out.args[0].size = sizeof(outarg);
1285 req->out.args[0].value = &outarg;
1287 request_send(fc, req);
1288 ret = req->out.h.error;
1290 ret = size ? req->out.args[0].size : outarg.size;
1292 if (ret == -ENOSYS) {
1293 fc->no_getxattr = 1;
1297 fuse_put_request(fc, req);
1301 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1303 struct inode *inode = entry->d_inode;
1304 struct fuse_conn *fc = get_fuse_conn(inode);
1305 struct fuse_req *req;
1306 struct fuse_getxattr_in inarg;
1307 struct fuse_getxattr_out outarg;
1310 if (!fuse_allow_task(fc, current))
1313 if (fc->no_listxattr)
1316 req = fuse_get_req(fc);
1318 return PTR_ERR(req);
1320 memset(&inarg, 0, sizeof(inarg));
1322 req->in.h.opcode = FUSE_LISTXATTR;
1323 req->in.h.nodeid = get_node_id(inode);
1324 req->in.numargs = 1;
1325 req->in.args[0].size = sizeof(inarg);
1326 req->in.args[0].value = &inarg;
1327 /* This is really two different operations rolled into one */
1328 req->out.numargs = 1;
1330 req->out.argvar = 1;
1331 req->out.args[0].size = size;
1332 req->out.args[0].value = list;
1334 req->out.args[0].size = sizeof(outarg);
1335 req->out.args[0].value = &outarg;
1337 request_send(fc, req);
1338 ret = req->out.h.error;
1340 ret = size ? req->out.args[0].size : outarg.size;
1342 if (ret == -ENOSYS) {
1343 fc->no_listxattr = 1;
1347 fuse_put_request(fc, req);
1351 static int fuse_removexattr(struct dentry *entry, const char *name)
1353 struct inode *inode = entry->d_inode;
1354 struct fuse_conn *fc = get_fuse_conn(inode);
1355 struct fuse_req *req;
1358 if (fc->no_removexattr)
1361 req = fuse_get_req(fc);
1363 return PTR_ERR(req);
1365 req->in.h.opcode = FUSE_REMOVEXATTR;
1366 req->in.h.nodeid = get_node_id(inode);
1367 req->in.numargs = 1;
1368 req->in.args[0].size = strlen(name) + 1;
1369 req->in.args[0].value = name;
1370 request_send(fc, req);
1371 err = req->out.h.error;
1372 fuse_put_request(fc, req);
1373 if (err == -ENOSYS) {
1374 fc->no_removexattr = 1;
1380 static const struct inode_operations fuse_dir_inode_operations = {
1381 .lookup = fuse_lookup,
1382 .mkdir = fuse_mkdir,
1383 .symlink = fuse_symlink,
1384 .unlink = fuse_unlink,
1385 .rmdir = fuse_rmdir,
1386 .rename = fuse_rename,
1388 .setattr = fuse_setattr,
1389 .create = fuse_create,
1390 .mknod = fuse_mknod,
1391 .permission = fuse_permission,
1392 .getattr = fuse_getattr,
1393 .setxattr = fuse_setxattr,
1394 .getxattr = fuse_getxattr,
1395 .listxattr = fuse_listxattr,
1396 .removexattr = fuse_removexattr,
1399 static const struct file_operations fuse_dir_operations = {
1400 .llseek = generic_file_llseek,
1401 .read = generic_read_dir,
1402 .readdir = fuse_readdir,
1403 .open = fuse_dir_open,
1404 .release = fuse_dir_release,
1405 .fsync = fuse_dir_fsync,
1408 static const struct inode_operations fuse_common_inode_operations = {
1409 .setattr = fuse_setattr,
1410 .permission = fuse_permission,
1411 .getattr = fuse_getattr,
1412 .setxattr = fuse_setxattr,
1413 .getxattr = fuse_getxattr,
1414 .listxattr = fuse_listxattr,
1415 .removexattr = fuse_removexattr,
1418 static const struct inode_operations fuse_symlink_inode_operations = {
1419 .setattr = fuse_setattr,
1420 .follow_link = fuse_follow_link,
1421 .put_link = fuse_put_link,
1422 .readlink = generic_readlink,
1423 .getattr = fuse_getattr,
1424 .setxattr = fuse_setxattr,
1425 .getxattr = fuse_getxattr,
1426 .listxattr = fuse_listxattr,
1427 .removexattr = fuse_removexattr,
1430 void fuse_init_common(struct inode *inode)
1432 inode->i_op = &fuse_common_inode_operations;
1435 void fuse_init_dir(struct inode *inode)
1437 inode->i_op = &fuse_dir_inode_operations;
1438 inode->i_fop = &fuse_dir_operations;
1441 void fuse_init_symlink(struct inode *inode)
1443 inode->i_op = &fuse_symlink_inode_operations;