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 req->in.h.opcode = FUSE_LOOKUP;
120 req->in.h.nodeid = get_node_id(dir);
122 req->in.args[0].size = entry->d_name.len + 1;
123 req->in.args[0].value = entry->d_name.name;
124 req->out.numargs = 1;
125 req->out.args[0].size = sizeof(struct fuse_entry_out);
126 req->out.args[0].value = outarg;
130 * Check whether the dentry is still valid
132 * If the entry validity timeout has expired and the dentry is
133 * positive, try to redo the lookup. If the lookup results in a
134 * different inode, then let the VFS invalidate the dentry and redo
135 * the lookup once more. If the lookup results in the same inode,
136 * then refresh the attributes, timeouts and mark the dentry valid.
138 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
140 struct inode *inode = entry->d_inode;
142 if (inode && is_bad_inode(inode))
144 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
146 struct fuse_entry_out outarg;
147 struct fuse_conn *fc;
148 struct fuse_req *req;
149 struct fuse_req *forget_req;
150 struct dentry *parent;
153 /* For negative dentries, always do a fresh lookup */
157 fc = get_fuse_conn(inode);
158 req = fuse_get_req(fc);
162 forget_req = fuse_get_req(fc);
163 if (IS_ERR(forget_req)) {
164 fuse_put_request(fc, req);
168 spin_lock(&fc->lock);
169 attr_version = fc->attr_version;
170 spin_unlock(&fc->lock);
172 parent = dget_parent(entry);
173 fuse_lookup_init(req, parent->d_inode, entry, &outarg);
174 request_send(fc, req);
176 err = req->out.h.error;
177 fuse_put_request(fc, req);
178 /* Zero nodeid is same as -ENOENT */
179 if (!err && !outarg.nodeid)
182 struct fuse_inode *fi = get_fuse_inode(inode);
183 if (outarg.nodeid != get_node_id(inode)) {
184 fuse_send_forget(fc, forget_req,
188 spin_lock(&fc->lock);
190 spin_unlock(&fc->lock);
192 fuse_put_request(fc, forget_req);
193 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
196 fuse_change_attributes(inode, &outarg.attr,
197 entry_attr_timeout(&outarg),
199 fuse_change_entry_timeout(entry, &outarg);
204 static int invalid_nodeid(u64 nodeid)
206 return !nodeid || nodeid == FUSE_ROOT_ID;
209 static struct dentry_operations fuse_dentry_operations = {
210 .d_revalidate = fuse_dentry_revalidate,
213 int fuse_valid_type(int m)
215 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
216 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
220 * Add a directory inode to a dentry, ensuring that no other dentry
221 * refers to this inode. Called with fc->inst_mutex.
223 static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
225 struct dentry *alias = d_find_alias(inode);
227 /* This tries to shrink the subtree below alias */
228 fuse_invalidate_entry(alias);
230 if (!list_empty(&inode->i_dentry))
237 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
238 struct nameidata *nd)
241 struct fuse_entry_out outarg;
242 struct inode *inode = NULL;
243 struct fuse_conn *fc = get_fuse_conn(dir);
244 struct fuse_req *req;
245 struct fuse_req *forget_req;
248 if (entry->d_name.len > FUSE_NAME_MAX)
249 return ERR_PTR(-ENAMETOOLONG);
251 req = fuse_get_req(fc);
253 return ERR_PTR(PTR_ERR(req));
255 forget_req = fuse_get_req(fc);
256 if (IS_ERR(forget_req)) {
257 fuse_put_request(fc, req);
258 return ERR_PTR(PTR_ERR(forget_req));
261 spin_lock(&fc->lock);
262 attr_version = fc->attr_version;
263 spin_unlock(&fc->lock);
265 fuse_lookup_init(req, dir, entry, &outarg);
266 request_send(fc, req);
267 err = req->out.h.error;
268 fuse_put_request(fc, req);
269 /* Zero nodeid is same as -ENOENT, but with valid timeout */
270 if (!err && outarg.nodeid &&
271 (invalid_nodeid(outarg.nodeid) ||
272 !fuse_valid_type(outarg.attr.mode)))
274 if (!err && outarg.nodeid) {
275 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
276 &outarg.attr, entry_attr_timeout(&outarg),
279 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
280 return ERR_PTR(-ENOMEM);
283 fuse_put_request(fc, forget_req);
284 if (err && err != -ENOENT)
287 if (inode && S_ISDIR(inode->i_mode)) {
288 mutex_lock(&fc->inst_mutex);
289 err = fuse_d_add_directory(entry, inode);
290 mutex_unlock(&fc->inst_mutex);
298 entry->d_op = &fuse_dentry_operations;
300 fuse_change_entry_timeout(entry, &outarg);
302 fuse_invalidate_entry_cache(entry);
307 * Synchronous release for the case when something goes wrong in CREATE_OPEN
309 static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
310 u64 nodeid, int flags)
312 fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
313 ff->reserved_req->force = 1;
314 request_send(fc, ff->reserved_req);
315 fuse_put_request(fc, ff->reserved_req);
320 * Atomic create+open operation
322 * If the filesystem doesn't support this, then fall back to separate
323 * 'mknod' + 'open' requests.
325 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
326 struct nameidata *nd)
330 struct fuse_conn *fc = get_fuse_conn(dir);
331 struct fuse_req *req;
332 struct fuse_req *forget_req;
333 struct fuse_open_in inarg;
334 struct fuse_open_out outopen;
335 struct fuse_entry_out outentry;
336 struct fuse_file *ff;
338 int flags = nd->intent.open.flags - 1;
343 forget_req = fuse_get_req(fc);
344 if (IS_ERR(forget_req))
345 return PTR_ERR(forget_req);
347 req = fuse_get_req(fc);
350 goto out_put_forget_req;
353 ff = fuse_file_alloc();
355 goto out_put_request;
358 memset(&inarg, 0, sizeof(inarg));
361 req->in.h.opcode = FUSE_CREATE;
362 req->in.h.nodeid = get_node_id(dir);
364 req->in.args[0].size = sizeof(inarg);
365 req->in.args[0].value = &inarg;
366 req->in.args[1].size = entry->d_name.len + 1;
367 req->in.args[1].value = entry->d_name.name;
368 req->out.numargs = 2;
369 req->out.args[0].size = sizeof(outentry);
370 req->out.args[0].value = &outentry;
371 req->out.args[1].size = sizeof(outopen);
372 req->out.args[1].value = &outopen;
373 request_send(fc, req);
374 err = req->out.h.error;
382 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
385 fuse_put_request(fc, req);
386 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
387 &outentry.attr, entry_attr_timeout(&outentry), 0);
389 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
391 fuse_sync_release(fc, ff, outentry.nodeid, flags);
392 fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
395 fuse_put_request(fc, forget_req);
396 d_instantiate(entry, inode);
397 fuse_change_entry_timeout(entry, &outentry);
398 file = lookup_instantiate_filp(nd, entry, generic_file_open);
401 fuse_sync_release(fc, ff, outentry.nodeid, flags);
402 return PTR_ERR(file);
404 fuse_finish_open(inode, file, ff, &outopen);
410 fuse_put_request(fc, req);
412 fuse_put_request(fc, forget_req);
417 * Code shared between mknod, mkdir, symlink and link
419 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
420 struct inode *dir, struct dentry *entry,
423 struct fuse_entry_out outarg;
426 struct fuse_req *forget_req;
428 forget_req = fuse_get_req(fc);
429 if (IS_ERR(forget_req)) {
430 fuse_put_request(fc, req);
431 return PTR_ERR(forget_req);
434 req->in.h.nodeid = get_node_id(dir);
435 req->out.numargs = 1;
436 req->out.args[0].size = sizeof(outarg);
437 req->out.args[0].value = &outarg;
438 request_send(fc, req);
439 err = req->out.h.error;
440 fuse_put_request(fc, req);
442 goto out_put_forget_req;
445 if (invalid_nodeid(outarg.nodeid))
446 goto out_put_forget_req;
448 if ((outarg.attr.mode ^ mode) & S_IFMT)
449 goto out_put_forget_req;
451 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
452 &outarg.attr, entry_attr_timeout(&outarg), 0);
454 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
457 fuse_put_request(fc, forget_req);
459 if (S_ISDIR(inode->i_mode)) {
460 struct dentry *alias;
461 mutex_lock(&fc->inst_mutex);
462 alias = d_find_alias(inode);
464 /* New directory must have moved since mkdir */
465 mutex_unlock(&fc->inst_mutex);
470 d_instantiate(entry, inode);
471 mutex_unlock(&fc->inst_mutex);
473 d_instantiate(entry, inode);
475 fuse_change_entry_timeout(entry, &outarg);
476 fuse_invalidate_attr(dir);
480 fuse_put_request(fc, forget_req);
484 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
487 struct fuse_mknod_in inarg;
488 struct fuse_conn *fc = get_fuse_conn(dir);
489 struct fuse_req *req = fuse_get_req(fc);
493 memset(&inarg, 0, sizeof(inarg));
495 inarg.rdev = new_encode_dev(rdev);
496 req->in.h.opcode = FUSE_MKNOD;
498 req->in.args[0].size = sizeof(inarg);
499 req->in.args[0].value = &inarg;
500 req->in.args[1].size = entry->d_name.len + 1;
501 req->in.args[1].value = entry->d_name.name;
502 return create_new_entry(fc, req, dir, entry, mode);
505 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
506 struct nameidata *nd)
508 if (nd && (nd->flags & LOOKUP_OPEN)) {
509 int err = fuse_create_open(dir, entry, mode, nd);
512 /* Fall back on mknod */
514 return fuse_mknod(dir, entry, mode, 0);
517 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
519 struct fuse_mkdir_in inarg;
520 struct fuse_conn *fc = get_fuse_conn(dir);
521 struct fuse_req *req = fuse_get_req(fc);
525 memset(&inarg, 0, sizeof(inarg));
527 req->in.h.opcode = FUSE_MKDIR;
529 req->in.args[0].size = sizeof(inarg);
530 req->in.args[0].value = &inarg;
531 req->in.args[1].size = entry->d_name.len + 1;
532 req->in.args[1].value = entry->d_name.name;
533 return create_new_entry(fc, req, dir, entry, S_IFDIR);
536 static int fuse_symlink(struct inode *dir, struct dentry *entry,
539 struct fuse_conn *fc = get_fuse_conn(dir);
540 unsigned len = strlen(link) + 1;
541 struct fuse_req *req = fuse_get_req(fc);
545 req->in.h.opcode = FUSE_SYMLINK;
547 req->in.args[0].size = entry->d_name.len + 1;
548 req->in.args[0].value = entry->d_name.name;
549 req->in.args[1].size = len;
550 req->in.args[1].value = link;
551 return create_new_entry(fc, req, dir, entry, S_IFLNK);
554 static int fuse_unlink(struct inode *dir, struct dentry *entry)
557 struct fuse_conn *fc = get_fuse_conn(dir);
558 struct fuse_req *req = fuse_get_req(fc);
562 req->in.h.opcode = FUSE_UNLINK;
563 req->in.h.nodeid = get_node_id(dir);
565 req->in.args[0].size = entry->d_name.len + 1;
566 req->in.args[0].value = entry->d_name.name;
567 request_send(fc, req);
568 err = req->out.h.error;
569 fuse_put_request(fc, req);
571 struct inode *inode = entry->d_inode;
573 /* Set nlink to zero so the inode can be cleared, if
574 the inode does have more links this will be
575 discovered at the next lookup/getattr */
577 fuse_invalidate_attr(inode);
578 fuse_invalidate_attr(dir);
579 fuse_invalidate_entry_cache(entry);
580 } else if (err == -EINTR)
581 fuse_invalidate_entry(entry);
585 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
588 struct fuse_conn *fc = get_fuse_conn(dir);
589 struct fuse_req *req = fuse_get_req(fc);
593 req->in.h.opcode = FUSE_RMDIR;
594 req->in.h.nodeid = get_node_id(dir);
596 req->in.args[0].size = entry->d_name.len + 1;
597 req->in.args[0].value = entry->d_name.name;
598 request_send(fc, req);
599 err = req->out.h.error;
600 fuse_put_request(fc, req);
602 clear_nlink(entry->d_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_rename(struct inode *olddir, struct dentry *oldent,
611 struct inode *newdir, struct dentry *newent)
614 struct fuse_rename_in inarg;
615 struct fuse_conn *fc = get_fuse_conn(olddir);
616 struct fuse_req *req = fuse_get_req(fc);
620 memset(&inarg, 0, sizeof(inarg));
621 inarg.newdir = get_node_id(newdir);
622 req->in.h.opcode = FUSE_RENAME;
623 req->in.h.nodeid = get_node_id(olddir);
625 req->in.args[0].size = sizeof(inarg);
626 req->in.args[0].value = &inarg;
627 req->in.args[1].size = oldent->d_name.len + 1;
628 req->in.args[1].value = oldent->d_name.name;
629 req->in.args[2].size = newent->d_name.len + 1;
630 req->in.args[2].value = newent->d_name.name;
631 request_send(fc, req);
632 err = req->out.h.error;
633 fuse_put_request(fc, req);
635 fuse_invalidate_attr(olddir);
636 if (olddir != newdir)
637 fuse_invalidate_attr(newdir);
639 /* newent will end up negative */
641 fuse_invalidate_entry_cache(newent);
642 } else if (err == -EINTR) {
643 /* If request was interrupted, DEITY only knows if the
644 rename actually took place. If the invalidation
645 fails (e.g. some process has CWD under the renamed
646 directory), then there can be inconsistency between
647 the dcache and the real filesystem. Tough luck. */
648 fuse_invalidate_entry(oldent);
650 fuse_invalidate_entry(newent);
656 static int fuse_link(struct dentry *entry, struct inode *newdir,
657 struct dentry *newent)
660 struct fuse_link_in inarg;
661 struct inode *inode = entry->d_inode;
662 struct fuse_conn *fc = get_fuse_conn(inode);
663 struct fuse_req *req = fuse_get_req(fc);
667 memset(&inarg, 0, sizeof(inarg));
668 inarg.oldnodeid = get_node_id(inode);
669 req->in.h.opcode = FUSE_LINK;
671 req->in.args[0].size = sizeof(inarg);
672 req->in.args[0].value = &inarg;
673 req->in.args[1].size = newent->d_name.len + 1;
674 req->in.args[1].value = newent->d_name.name;
675 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
676 /* Contrary to "normal" filesystems it can happen that link
677 makes two "logical" inodes point to the same "physical"
678 inode. We invalidate the attributes of the old one, so it
679 will reflect changes in the backing inode (link count,
682 if (!err || err == -EINTR)
683 fuse_invalidate_attr(inode);
687 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
690 stat->dev = inode->i_sb->s_dev;
691 stat->ino = attr->ino;
692 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
693 stat->nlink = attr->nlink;
694 stat->uid = attr->uid;
695 stat->gid = attr->gid;
696 stat->rdev = inode->i_rdev;
697 stat->atime.tv_sec = attr->atime;
698 stat->atime.tv_nsec = attr->atimensec;
699 stat->mtime.tv_sec = attr->mtime;
700 stat->mtime.tv_nsec = attr->mtimensec;
701 stat->ctime.tv_sec = attr->ctime;
702 stat->ctime.tv_nsec = attr->ctimensec;
703 stat->size = attr->size;
704 stat->blocks = attr->blocks;
705 stat->blksize = (1 << inode->i_blkbits);
708 static int fuse_do_getattr(struct inode *inode, struct kstat *stat)
711 struct fuse_attr_out arg;
712 struct fuse_conn *fc = get_fuse_conn(inode);
713 struct fuse_req *req;
716 req = fuse_get_req(fc);
720 spin_lock(&fc->lock);
721 attr_version = fc->attr_version;
722 spin_unlock(&fc->lock);
724 req->in.h.opcode = FUSE_GETATTR;
725 req->in.h.nodeid = get_node_id(inode);
726 req->out.numargs = 1;
727 req->out.args[0].size = sizeof(arg);
728 req->out.args[0].value = &arg;
729 request_send(fc, req);
730 err = req->out.h.error;
731 fuse_put_request(fc, req);
733 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
734 make_bad_inode(inode);
737 fuse_change_attributes(inode, &arg.attr,
741 fuse_fillattr(inode, &arg.attr, stat);
748 * Calling into a user-controlled filesystem gives the filesystem
749 * daemon ptrace-like capabilities over the requester process. This
750 * means, that the filesystem daemon is able to record the exact
751 * filesystem operations performed, and can also control the behavior
752 * of the requester process in otherwise impossible ways. For example
753 * it can delay the operation for arbitrary length of time allowing
754 * DoS against the requester.
756 * For this reason only those processes can call into the filesystem,
757 * for which the owner of the mount has ptrace privilege. This
758 * excludes processes started by other users, suid or sgid processes.
760 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
762 if (fc->flags & FUSE_ALLOW_OTHER)
765 if (task->euid == fc->user_id &&
766 task->suid == fc->user_id &&
767 task->uid == fc->user_id &&
768 task->egid == fc->group_id &&
769 task->sgid == fc->group_id &&
770 task->gid == fc->group_id)
776 static int fuse_access(struct inode *inode, int mask)
778 struct fuse_conn *fc = get_fuse_conn(inode);
779 struct fuse_req *req;
780 struct fuse_access_in inarg;
786 req = fuse_get_req(fc);
790 memset(&inarg, 0, sizeof(inarg));
792 req->in.h.opcode = FUSE_ACCESS;
793 req->in.h.nodeid = get_node_id(inode);
795 req->in.args[0].size = sizeof(inarg);
796 req->in.args[0].value = &inarg;
797 request_send(fc, req);
798 err = req->out.h.error;
799 fuse_put_request(fc, req);
800 if (err == -ENOSYS) {
808 * Check permission. The two basic access models of FUSE are:
810 * 1) Local access checking ('default_permissions' mount option) based
811 * on file mode. This is the plain old disk filesystem permission
814 * 2) "Remote" access checking, where server is responsible for
815 * checking permission in each inode operation. An exception to this
816 * is if ->permission() was invoked from sys_access() in which case an
817 * access request is sent. Execute permission is still checked
818 * locally based on file mode.
820 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
822 struct fuse_conn *fc = get_fuse_conn(inode);
823 bool refreshed = false;
826 if (!fuse_allow_task(fc, current))
830 * If attributes are needed, refresh them before proceeding
832 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
833 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
834 struct fuse_inode *fi = get_fuse_inode(inode);
835 if (fi->i_time < get_jiffies_64()) {
836 err = fuse_do_getattr(inode, NULL);
844 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
845 int err = generic_permission(inode, mask, NULL);
847 /* If permission is denied, try to refresh file
848 attributes. This is also needed, because the root
849 node will at first have no permissions */
850 if (err == -EACCES && !refreshed) {
851 err = fuse_do_getattr(inode, NULL);
853 err = generic_permission(inode, mask, NULL);
856 /* Note: the opposite of the above test does not
857 exist. So if permissions are revoked this won't be
858 noticed immediately, only after the attribute
859 timeout has expired */
860 } else if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR))) {
861 err = fuse_access(inode, mask);
862 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
863 if (!(inode->i_mode & S_IXUGO)) {
867 err = fuse_do_getattr(inode, NULL);
868 if (!err && !(inode->i_mode & S_IXUGO))
875 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
876 void *dstbuf, filldir_t filldir)
878 while (nbytes >= FUSE_NAME_OFFSET) {
879 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
880 size_t reclen = FUSE_DIRENT_SIZE(dirent);
882 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
887 over = filldir(dstbuf, dirent->name, dirent->namelen,
888 file->f_pos, dirent->ino, dirent->type);
894 file->f_pos = dirent->off;
900 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
905 struct inode *inode = file->f_path.dentry->d_inode;
906 struct fuse_conn *fc = get_fuse_conn(inode);
907 struct fuse_file *ff = file->private_data;
908 struct fuse_req *req;
910 if (is_bad_inode(inode))
913 req = fuse_get_req(fc);
917 page = alloc_page(GFP_KERNEL);
919 fuse_put_request(fc, req);
923 req->pages[0] = page;
924 fuse_read_fill(req, ff, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
925 request_send(fc, req);
926 nbytes = req->out.args[0].size;
927 err = req->out.h.error;
928 fuse_put_request(fc, req);
930 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
934 fuse_invalidate_attr(inode); /* atime changed */
938 static char *read_link(struct dentry *dentry)
940 struct inode *inode = dentry->d_inode;
941 struct fuse_conn *fc = get_fuse_conn(inode);
942 struct fuse_req *req = fuse_get_req(fc);
946 return ERR_PTR(PTR_ERR(req));
948 link = (char *) __get_free_page(GFP_KERNEL);
950 link = ERR_PTR(-ENOMEM);
953 req->in.h.opcode = FUSE_READLINK;
954 req->in.h.nodeid = get_node_id(inode);
956 req->out.numargs = 1;
957 req->out.args[0].size = PAGE_SIZE - 1;
958 req->out.args[0].value = link;
959 request_send(fc, req);
960 if (req->out.h.error) {
961 free_page((unsigned long) link);
962 link = ERR_PTR(req->out.h.error);
964 link[req->out.args[0].size] = '\0';
966 fuse_put_request(fc, req);
967 fuse_invalidate_attr(inode); /* atime changed */
971 static void free_link(char *link)
974 free_page((unsigned long) link);
977 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
979 nd_set_link(nd, read_link(dentry));
983 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
985 free_link(nd_get_link(nd));
988 static int fuse_dir_open(struct inode *inode, struct file *file)
990 return fuse_open_common(inode, file, 1);
993 static int fuse_dir_release(struct inode *inode, struct file *file)
995 return fuse_release_common(inode, file, 1);
998 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
1000 /* nfsd can call this with no file */
1001 return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
1004 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1006 unsigned ivalid = iattr->ia_valid;
1008 if (ivalid & ATTR_MODE)
1009 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1010 if (ivalid & ATTR_UID)
1011 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
1012 if (ivalid & ATTR_GID)
1013 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
1014 if (ivalid & ATTR_SIZE)
1015 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1016 /* You can only _set_ these together (they may change by themselves) */
1017 if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
1018 arg->valid |= FATTR_ATIME | FATTR_MTIME;
1019 arg->atime = iattr->ia_atime.tv_sec;
1020 arg->mtime = iattr->ia_mtime.tv_sec;
1022 if (ivalid & ATTR_FILE) {
1023 struct fuse_file *ff = iattr->ia_file->private_data;
1024 arg->valid |= FATTR_FH;
1030 * Set attributes, and at the same time refresh them.
1032 * Truncation is slightly complicated, because the 'truncate' request
1033 * may fail, in which case we don't want to touch the mapping.
1034 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1035 * and the actual truncation by hand.
1037 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1039 struct inode *inode = entry->d_inode;
1040 struct fuse_conn *fc = get_fuse_conn(inode);
1041 struct fuse_req *req;
1042 struct fuse_setattr_in inarg;
1043 struct fuse_attr_out outarg;
1046 if (!fuse_allow_task(fc, current))
1049 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1050 err = inode_change_ok(inode, attr);
1055 if (attr->ia_valid & ATTR_SIZE) {
1056 unsigned long limit;
1057 if (IS_SWAPFILE(inode))
1059 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1060 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1061 send_sig(SIGXFSZ, current, 0);
1066 req = fuse_get_req(fc);
1068 return PTR_ERR(req);
1070 memset(&inarg, 0, sizeof(inarg));
1071 iattr_to_fattr(attr, &inarg);
1072 req->in.h.opcode = FUSE_SETATTR;
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 req->out.numargs = 1;
1078 req->out.args[0].size = sizeof(outarg);
1079 req->out.args[0].value = &outarg;
1080 request_send(fc, req);
1081 err = req->out.h.error;
1082 fuse_put_request(fc, req);
1085 fuse_invalidate_attr(inode);
1089 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1090 make_bad_inode(inode);
1094 fuse_change_attributes(inode, &outarg.attr, attr_timeout(&outarg), 0);
1098 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1101 struct inode *inode = entry->d_inode;
1102 struct fuse_inode *fi = get_fuse_inode(inode);
1103 struct fuse_conn *fc = get_fuse_conn(inode);
1106 if (!fuse_allow_task(fc, current))
1109 if (fi->i_time < get_jiffies_64())
1110 err = fuse_do_getattr(inode, stat);
1113 generic_fillattr(inode, stat);
1114 stat->mode = fi->orig_i_mode;
1120 static int fuse_setxattr(struct dentry *entry, const char *name,
1121 const void *value, size_t size, int flags)
1123 struct inode *inode = entry->d_inode;
1124 struct fuse_conn *fc = get_fuse_conn(inode);
1125 struct fuse_req *req;
1126 struct fuse_setxattr_in inarg;
1129 if (fc->no_setxattr)
1132 req = fuse_get_req(fc);
1134 return PTR_ERR(req);
1136 memset(&inarg, 0, sizeof(inarg));
1138 inarg.flags = flags;
1139 req->in.h.opcode = FUSE_SETXATTR;
1140 req->in.h.nodeid = get_node_id(inode);
1141 req->in.numargs = 3;
1142 req->in.args[0].size = sizeof(inarg);
1143 req->in.args[0].value = &inarg;
1144 req->in.args[1].size = strlen(name) + 1;
1145 req->in.args[1].value = name;
1146 req->in.args[2].size = size;
1147 req->in.args[2].value = value;
1148 request_send(fc, req);
1149 err = req->out.h.error;
1150 fuse_put_request(fc, req);
1151 if (err == -ENOSYS) {
1152 fc->no_setxattr = 1;
1158 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1159 void *value, size_t size)
1161 struct inode *inode = entry->d_inode;
1162 struct fuse_conn *fc = get_fuse_conn(inode);
1163 struct fuse_req *req;
1164 struct fuse_getxattr_in inarg;
1165 struct fuse_getxattr_out outarg;
1168 if (fc->no_getxattr)
1171 req = fuse_get_req(fc);
1173 return PTR_ERR(req);
1175 memset(&inarg, 0, sizeof(inarg));
1177 req->in.h.opcode = FUSE_GETXATTR;
1178 req->in.h.nodeid = get_node_id(inode);
1179 req->in.numargs = 2;
1180 req->in.args[0].size = sizeof(inarg);
1181 req->in.args[0].value = &inarg;
1182 req->in.args[1].size = strlen(name) + 1;
1183 req->in.args[1].value = name;
1184 /* This is really two different operations rolled into one */
1185 req->out.numargs = 1;
1187 req->out.argvar = 1;
1188 req->out.args[0].size = size;
1189 req->out.args[0].value = value;
1191 req->out.args[0].size = sizeof(outarg);
1192 req->out.args[0].value = &outarg;
1194 request_send(fc, req);
1195 ret = req->out.h.error;
1197 ret = size ? req->out.args[0].size : outarg.size;
1199 if (ret == -ENOSYS) {
1200 fc->no_getxattr = 1;
1204 fuse_put_request(fc, req);
1208 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1210 struct inode *inode = entry->d_inode;
1211 struct fuse_conn *fc = get_fuse_conn(inode);
1212 struct fuse_req *req;
1213 struct fuse_getxattr_in inarg;
1214 struct fuse_getxattr_out outarg;
1217 if (!fuse_allow_task(fc, current))
1220 if (fc->no_listxattr)
1223 req = fuse_get_req(fc);
1225 return PTR_ERR(req);
1227 memset(&inarg, 0, sizeof(inarg));
1229 req->in.h.opcode = FUSE_LISTXATTR;
1230 req->in.h.nodeid = get_node_id(inode);
1231 req->in.numargs = 1;
1232 req->in.args[0].size = sizeof(inarg);
1233 req->in.args[0].value = &inarg;
1234 /* This is really two different operations rolled into one */
1235 req->out.numargs = 1;
1237 req->out.argvar = 1;
1238 req->out.args[0].size = size;
1239 req->out.args[0].value = list;
1241 req->out.args[0].size = sizeof(outarg);
1242 req->out.args[0].value = &outarg;
1244 request_send(fc, req);
1245 ret = req->out.h.error;
1247 ret = size ? req->out.args[0].size : outarg.size;
1249 if (ret == -ENOSYS) {
1250 fc->no_listxattr = 1;
1254 fuse_put_request(fc, req);
1258 static int fuse_removexattr(struct dentry *entry, const char *name)
1260 struct inode *inode = entry->d_inode;
1261 struct fuse_conn *fc = get_fuse_conn(inode);
1262 struct fuse_req *req;
1265 if (fc->no_removexattr)
1268 req = fuse_get_req(fc);
1270 return PTR_ERR(req);
1272 req->in.h.opcode = FUSE_REMOVEXATTR;
1273 req->in.h.nodeid = get_node_id(inode);
1274 req->in.numargs = 1;
1275 req->in.args[0].size = strlen(name) + 1;
1276 req->in.args[0].value = name;
1277 request_send(fc, req);
1278 err = req->out.h.error;
1279 fuse_put_request(fc, req);
1280 if (err == -ENOSYS) {
1281 fc->no_removexattr = 1;
1287 static const struct inode_operations fuse_dir_inode_operations = {
1288 .lookup = fuse_lookup,
1289 .mkdir = fuse_mkdir,
1290 .symlink = fuse_symlink,
1291 .unlink = fuse_unlink,
1292 .rmdir = fuse_rmdir,
1293 .rename = fuse_rename,
1295 .setattr = fuse_setattr,
1296 .create = fuse_create,
1297 .mknod = fuse_mknod,
1298 .permission = fuse_permission,
1299 .getattr = fuse_getattr,
1300 .setxattr = fuse_setxattr,
1301 .getxattr = fuse_getxattr,
1302 .listxattr = fuse_listxattr,
1303 .removexattr = fuse_removexattr,
1306 static const struct file_operations fuse_dir_operations = {
1307 .llseek = generic_file_llseek,
1308 .read = generic_read_dir,
1309 .readdir = fuse_readdir,
1310 .open = fuse_dir_open,
1311 .release = fuse_dir_release,
1312 .fsync = fuse_dir_fsync,
1315 static const struct inode_operations fuse_common_inode_operations = {
1316 .setattr = fuse_setattr,
1317 .permission = fuse_permission,
1318 .getattr = fuse_getattr,
1319 .setxattr = fuse_setxattr,
1320 .getxattr = fuse_getxattr,
1321 .listxattr = fuse_listxattr,
1322 .removexattr = fuse_removexattr,
1325 static const struct inode_operations fuse_symlink_inode_operations = {
1326 .setattr = fuse_setattr,
1327 .follow_link = fuse_follow_link,
1328 .put_link = fuse_put_link,
1329 .readlink = generic_readlink,
1330 .getattr = fuse_getattr,
1331 .setxattr = fuse_setxattr,
1332 .getxattr = fuse_getxattr,
1333 .listxattr = fuse_listxattr,
1334 .removexattr = fuse_removexattr,
1337 void fuse_init_common(struct inode *inode)
1339 inode->i_op = &fuse_common_inode_operations;
1342 void fuse_init_dir(struct inode *inode)
1344 inode->i_op = &fuse_dir_inode_operations;
1345 inode->i_fop = &fuse_dir_operations;
1348 void fuse_init_symlink(struct inode *inode)
1350 inode->i_op = &fuse_symlink_inode_operations;