2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2005 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>
18 * FUSE caches dentries and attributes with separate timeout. The
19 * time in jiffies until the dentry/attributes are valid is stored in
20 * dentry->d_time and fuse_inode->i_time respectively.
24 * Calculate the time in jiffies until a dentry/attributes are valid
26 static inline unsigned long time_to_jiffies(unsigned long sec,
29 struct timespec ts = {sec, nsec};
30 return jiffies + timespec_to_jiffies(&ts);
34 * Set dentry and possibly attribute timeouts from the lookup/mk*
37 static void fuse_change_timeout(struct dentry *entry, struct fuse_entry_out *o)
39 entry->d_time = time_to_jiffies(o->entry_valid, o->entry_valid_nsec);
41 get_fuse_inode(entry->d_inode)->i_time =
42 time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
46 * Mark the attributes as stale, so that at the next call to
47 * ->getattr() they will be fetched from userspace
49 void fuse_invalidate_attr(struct inode *inode)
51 get_fuse_inode(inode)->i_time = jiffies - 1;
55 * Just mark the entry as stale, so that a next attempt to look it up
56 * will result in a new lookup call to userspace
58 * This is called when a dentry is about to become negative and the
59 * timeout is unknown (unlink, rmdir, rename and in some cases
62 static void fuse_invalidate_entry_cache(struct dentry *entry)
64 entry->d_time = jiffies - 1;
68 * Same as fuse_invalidate_entry_cache(), but also try to remove the
69 * dentry from the hash
71 static void fuse_invalidate_entry(struct dentry *entry)
74 fuse_invalidate_entry_cache(entry);
77 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
79 struct fuse_entry_out *outarg)
81 req->in.h.opcode = FUSE_LOOKUP;
82 req->in.h.nodeid = get_node_id(dir);
85 req->in.args[0].size = entry->d_name.len + 1;
86 req->in.args[0].value = entry->d_name.name;
88 req->out.args[0].size = sizeof(struct fuse_entry_out);
89 req->out.args[0].value = outarg;
93 * Check whether the dentry is still valid
95 * If the entry validity timeout has expired and the dentry is
96 * positive, try to redo the lookup. If the lookup results in a
97 * different inode, then let the VFS invalidate the dentry and redo
98 * the lookup once more. If the lookup results in the same inode,
99 * then refresh the attributes, timeouts and mark the dentry valid.
101 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
103 struct inode *inode = entry->d_inode;
105 if (inode && is_bad_inode(inode))
107 else if (time_after(jiffies, entry->d_time)) {
109 struct fuse_entry_out outarg;
110 struct fuse_conn *fc;
111 struct fuse_req *req;
113 /* Doesn't hurt to "reset" the validity timeout */
114 fuse_invalidate_entry_cache(entry);
118 fc = get_fuse_conn(inode);
119 req = fuse_get_request(fc);
123 fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
124 request_send(fc, req);
125 err = req->out.h.error;
127 struct fuse_inode *fi = get_fuse_inode(inode);
128 if (outarg.nodeid != get_node_id(inode)) {
129 fuse_send_forget(fc, req, outarg.nodeid, 1);
134 fuse_put_request(fc, req);
135 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
138 fuse_change_attributes(inode, &outarg.attr);
139 fuse_change_timeout(entry, &outarg);
145 * Check if there's already a hashed alias of this directory inode.
146 * If yes, then lookup and mkdir must not create a new alias.
148 static int dir_alias(struct inode *inode)
150 if (S_ISDIR(inode->i_mode)) {
151 struct dentry *alias = d_find_alias(inode);
160 static inline int invalid_nodeid(u64 nodeid)
162 return !nodeid || nodeid == FUSE_ROOT_ID;
165 static struct dentry_operations fuse_dentry_operations = {
166 .d_revalidate = fuse_dentry_revalidate,
169 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
170 struct nameidata *nd)
173 struct fuse_entry_out outarg;
174 struct inode *inode = NULL;
175 struct fuse_conn *fc = get_fuse_conn(dir);
176 struct fuse_req *req;
178 if (entry->d_name.len > FUSE_NAME_MAX)
179 return ERR_PTR(-ENAMETOOLONG);
181 req = fuse_get_request(fc);
183 return ERR_PTR(-EINTR);
185 fuse_lookup_init(req, dir, entry, &outarg);
186 request_send(fc, req);
187 err = req->out.h.error;
188 if (!err && outarg.nodeid && invalid_nodeid(outarg.nodeid))
190 if (!err && outarg.nodeid) {
191 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
194 fuse_send_forget(fc, req, outarg.nodeid, 1);
195 return ERR_PTR(-ENOMEM);
198 fuse_put_request(fc, req);
199 if (err && err != -ENOENT)
202 if (inode && dir_alias(inode)) {
204 return ERR_PTR(-EIO);
207 entry->d_op = &fuse_dentry_operations;
209 fuse_change_timeout(entry, &outarg);
211 fuse_invalidate_entry_cache(entry);
216 * Atomic create+open operation
218 * If the filesystem doesn't support this, then fall back to separate
219 * 'mknod' + 'open' requests.
221 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
222 struct nameidata *nd)
226 struct fuse_conn *fc = get_fuse_conn(dir);
227 struct fuse_req *req;
228 struct fuse_open_in inarg;
229 struct fuse_open_out outopen;
230 struct fuse_entry_out outentry;
231 struct fuse_file *ff;
233 int flags = nd->intent.open.flags - 1;
240 if (entry->d_name.len > FUSE_NAME_MAX)
244 req = fuse_get_request(fc);
248 ff = fuse_file_alloc();
250 goto out_put_request;
253 memset(&inarg, 0, sizeof(inarg));
256 req->in.h.opcode = FUSE_CREATE;
257 req->in.h.nodeid = get_node_id(dir);
260 req->in.args[0].size = sizeof(inarg);
261 req->in.args[0].value = &inarg;
262 req->in.args[1].size = entry->d_name.len + 1;
263 req->in.args[1].value = entry->d_name.name;
264 req->out.numargs = 2;
265 req->out.args[0].size = sizeof(outentry);
266 req->out.args[0].value = &outentry;
267 req->out.args[1].size = sizeof(outopen);
268 req->out.args[1].value = &outopen;
269 request_send(fc, req);
270 err = req->out.h.error;
278 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
281 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
285 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
287 /* Special release, with inode = NULL, this will
288 trigger a 'forget' request when the release is
290 fuse_send_release(fc, ff, outentry.nodeid, NULL, flags, 0);
291 goto out_put_request;
293 fuse_put_request(fc, req);
294 d_instantiate(entry, inode);
295 fuse_change_timeout(entry, &outentry);
296 file = lookup_instantiate_filp(nd, entry, generic_file_open);
299 fuse_send_release(fc, ff, outentry.nodeid, inode, flags, 0);
300 return PTR_ERR(file);
302 fuse_finish_open(inode, file, ff, &outopen);
308 fuse_put_request(fc, req);
314 * Code shared between mknod, mkdir, symlink and link
316 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
317 struct inode *dir, struct dentry *entry,
320 struct fuse_entry_out outarg;
324 req->in.h.nodeid = get_node_id(dir);
326 req->out.numargs = 1;
327 req->out.args[0].size = sizeof(outarg);
328 req->out.args[0].value = &outarg;
329 request_send(fc, req);
330 err = req->out.h.error;
332 fuse_put_request(fc, req);
335 if (invalid_nodeid(outarg.nodeid)) {
336 fuse_put_request(fc, req);
339 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
342 fuse_send_forget(fc, req, outarg.nodeid, 1);
345 fuse_put_request(fc, req);
347 /* Don't allow userspace to do really stupid things... */
348 if (((inode->i_mode ^ mode) & S_IFMT) || dir_alias(inode)) {
353 d_instantiate(entry, inode);
354 fuse_change_timeout(entry, &outarg);
355 fuse_invalidate_attr(dir);
359 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
362 struct fuse_mknod_in inarg;
363 struct fuse_conn *fc = get_fuse_conn(dir);
364 struct fuse_req *req = fuse_get_request(fc);
368 memset(&inarg, 0, sizeof(inarg));
370 inarg.rdev = new_encode_dev(rdev);
371 req->in.h.opcode = FUSE_MKNOD;
373 req->in.args[0].size = sizeof(inarg);
374 req->in.args[0].value = &inarg;
375 req->in.args[1].size = entry->d_name.len + 1;
376 req->in.args[1].value = entry->d_name.name;
377 return create_new_entry(fc, req, dir, entry, mode);
380 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
381 struct nameidata *nd)
383 if (nd && (nd->flags & LOOKUP_CREATE)) {
384 int err = fuse_create_open(dir, entry, mode, nd);
387 /* Fall back on mknod */
389 return fuse_mknod(dir, entry, mode, 0);
392 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
394 struct fuse_mkdir_in inarg;
395 struct fuse_conn *fc = get_fuse_conn(dir);
396 struct fuse_req *req = fuse_get_request(fc);
400 memset(&inarg, 0, sizeof(inarg));
402 req->in.h.opcode = FUSE_MKDIR;
404 req->in.args[0].size = sizeof(inarg);
405 req->in.args[0].value = &inarg;
406 req->in.args[1].size = entry->d_name.len + 1;
407 req->in.args[1].value = entry->d_name.name;
408 return create_new_entry(fc, req, dir, entry, S_IFDIR);
411 static int fuse_symlink(struct inode *dir, struct dentry *entry,
414 struct fuse_conn *fc = get_fuse_conn(dir);
415 unsigned len = strlen(link) + 1;
416 struct fuse_req *req;
418 if (len > FUSE_SYMLINK_MAX)
419 return -ENAMETOOLONG;
421 req = fuse_get_request(fc);
425 req->in.h.opcode = FUSE_SYMLINK;
427 req->in.args[0].size = entry->d_name.len + 1;
428 req->in.args[0].value = entry->d_name.name;
429 req->in.args[1].size = len;
430 req->in.args[1].value = link;
431 return create_new_entry(fc, req, dir, entry, S_IFLNK);
434 static int fuse_unlink(struct inode *dir, struct dentry *entry)
437 struct fuse_conn *fc = get_fuse_conn(dir);
438 struct fuse_req *req = fuse_get_request(fc);
442 req->in.h.opcode = FUSE_UNLINK;
443 req->in.h.nodeid = get_node_id(dir);
446 req->in.args[0].size = entry->d_name.len + 1;
447 req->in.args[0].value = entry->d_name.name;
448 request_send(fc, req);
449 err = req->out.h.error;
450 fuse_put_request(fc, req);
452 struct inode *inode = entry->d_inode;
454 /* Set nlink to zero so the inode can be cleared, if
455 the inode does have more links this will be
456 discovered at the next lookup/getattr */
458 fuse_invalidate_attr(inode);
459 fuse_invalidate_attr(dir);
460 fuse_invalidate_entry_cache(entry);
461 } else if (err == -EINTR)
462 fuse_invalidate_entry(entry);
466 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
469 struct fuse_conn *fc = get_fuse_conn(dir);
470 struct fuse_req *req = fuse_get_request(fc);
474 req->in.h.opcode = FUSE_RMDIR;
475 req->in.h.nodeid = get_node_id(dir);
478 req->in.args[0].size = entry->d_name.len + 1;
479 req->in.args[0].value = entry->d_name.name;
480 request_send(fc, req);
481 err = req->out.h.error;
482 fuse_put_request(fc, req);
484 entry->d_inode->i_nlink = 0;
485 fuse_invalidate_attr(dir);
486 fuse_invalidate_entry_cache(entry);
487 } else if (err == -EINTR)
488 fuse_invalidate_entry(entry);
492 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
493 struct inode *newdir, struct dentry *newent)
496 struct fuse_rename_in inarg;
497 struct fuse_conn *fc = get_fuse_conn(olddir);
498 struct fuse_req *req = fuse_get_request(fc);
502 memset(&inarg, 0, sizeof(inarg));
503 inarg.newdir = get_node_id(newdir);
504 req->in.h.opcode = FUSE_RENAME;
505 req->in.h.nodeid = get_node_id(olddir);
507 req->inode2 = newdir;
509 req->in.args[0].size = sizeof(inarg);
510 req->in.args[0].value = &inarg;
511 req->in.args[1].size = oldent->d_name.len + 1;
512 req->in.args[1].value = oldent->d_name.name;
513 req->in.args[2].size = newent->d_name.len + 1;
514 req->in.args[2].value = newent->d_name.name;
515 request_send(fc, req);
516 err = req->out.h.error;
517 fuse_put_request(fc, req);
519 fuse_invalidate_attr(olddir);
520 if (olddir != newdir)
521 fuse_invalidate_attr(newdir);
523 /* newent will end up negative */
525 fuse_invalidate_entry_cache(newent);
526 } else if (err == -EINTR) {
527 /* If request was interrupted, DEITY only knows if the
528 rename actually took place. If the invalidation
529 fails (e.g. some process has CWD under the renamed
530 directory), then there can be inconsistency between
531 the dcache and the real filesystem. Tough luck. */
532 fuse_invalidate_entry(oldent);
534 fuse_invalidate_entry(newent);
540 static int fuse_link(struct dentry *entry, struct inode *newdir,
541 struct dentry *newent)
544 struct fuse_link_in inarg;
545 struct inode *inode = entry->d_inode;
546 struct fuse_conn *fc = get_fuse_conn(inode);
547 struct fuse_req *req = fuse_get_request(fc);
551 memset(&inarg, 0, sizeof(inarg));
552 inarg.oldnodeid = get_node_id(inode);
553 req->in.h.opcode = FUSE_LINK;
556 req->in.args[0].size = sizeof(inarg);
557 req->in.args[0].value = &inarg;
558 req->in.args[1].size = newent->d_name.len + 1;
559 req->in.args[1].value = newent->d_name.name;
560 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
561 /* Contrary to "normal" filesystems it can happen that link
562 makes two "logical" inodes point to the same "physical"
563 inode. We invalidate the attributes of the old one, so it
564 will reflect changes in the backing inode (link count,
567 if (!err || err == -EINTR)
568 fuse_invalidate_attr(inode);
572 int fuse_do_getattr(struct inode *inode)
575 struct fuse_attr_out arg;
576 struct fuse_conn *fc = get_fuse_conn(inode);
577 struct fuse_req *req = fuse_get_request(fc);
581 req->in.h.opcode = FUSE_GETATTR;
582 req->in.h.nodeid = get_node_id(inode);
584 req->out.numargs = 1;
585 req->out.args[0].size = sizeof(arg);
586 req->out.args[0].value = &arg;
587 request_send(fc, req);
588 err = req->out.h.error;
589 fuse_put_request(fc, req);
591 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
592 make_bad_inode(inode);
595 struct fuse_inode *fi = get_fuse_inode(inode);
596 fuse_change_attributes(inode, &arg.attr);
597 fi->i_time = time_to_jiffies(arg.attr_valid,
598 arg.attr_valid_nsec);
605 * Calling into a user-controlled filesystem gives the filesystem
606 * daemon ptrace-like capabilities over the requester process. This
607 * means, that the filesystem daemon is able to record the exact
608 * filesystem operations performed, and can also control the behavior
609 * of the requester process in otherwise impossible ways. For example
610 * it can delay the operation for arbitrary length of time allowing
611 * DoS against the requester.
613 * For this reason only those processes can call into the filesystem,
614 * for which the owner of the mount has ptrace privilege. This
615 * excludes processes started by other users, suid or sgid processes.
617 static int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
619 if (fc->flags & FUSE_ALLOW_OTHER)
622 if (task->euid == fc->user_id &&
623 task->suid == fc->user_id &&
624 task->uid == fc->user_id &&
625 task->egid == fc->group_id &&
626 task->sgid == fc->group_id &&
627 task->gid == fc->group_id)
634 * Check whether the inode attributes are still valid
636 * If the attribute validity timeout has expired, then fetch the fresh
637 * attributes with a 'getattr' request
639 * I'm not sure why cached attributes are never returned for the root
640 * inode, this is probably being too cautious.
642 static int fuse_revalidate(struct dentry *entry)
644 struct inode *inode = entry->d_inode;
645 struct fuse_inode *fi = get_fuse_inode(inode);
646 struct fuse_conn *fc = get_fuse_conn(inode);
648 if (!fuse_allow_task(fc, current))
650 if (get_node_id(inode) != FUSE_ROOT_ID &&
651 time_before_eq(jiffies, fi->i_time))
654 return fuse_do_getattr(inode);
657 static int fuse_access(struct inode *inode, int mask)
659 struct fuse_conn *fc = get_fuse_conn(inode);
660 struct fuse_req *req;
661 struct fuse_access_in inarg;
667 req = fuse_get_request(fc);
671 memset(&inarg, 0, sizeof(inarg));
673 req->in.h.opcode = FUSE_ACCESS;
674 req->in.h.nodeid = get_node_id(inode);
677 req->in.args[0].size = sizeof(inarg);
678 req->in.args[0].value = &inarg;
679 request_send(fc, req);
680 err = req->out.h.error;
681 fuse_put_request(fc, req);
682 if (err == -ENOSYS) {
690 * Check permission. The two basic access models of FUSE are:
692 * 1) Local access checking ('default_permissions' mount option) based
693 * on file mode. This is the plain old disk filesystem permission
696 * 2) "Remote" access checking, where server is responsible for
697 * checking permission in each inode operation. An exception to this
698 * is if ->permission() was invoked from sys_access() in which case an
699 * access request is sent. Execute permission is still checked
700 * locally based on file mode.
702 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
704 struct fuse_conn *fc = get_fuse_conn(inode);
706 if (!fuse_allow_task(fc, current))
708 else if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
709 int err = generic_permission(inode, mask, NULL);
711 /* If permission is denied, try to refresh file
712 attributes. This is also needed, because the root
713 node will at first have no permissions */
714 if (err == -EACCES) {
715 err = fuse_do_getattr(inode);
717 err = generic_permission(inode, mask, NULL);
720 /* Note: the opposite of the above test does not
721 exist. So if permissions are revoked this won't be
722 noticed immediately, only after the attribute
723 timeout has expired */
727 int mode = inode->i_mode;
728 if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
731 if (nd && (nd->flags & LOOKUP_ACCESS))
732 return fuse_access(inode, mask);
737 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
738 void *dstbuf, filldir_t filldir)
740 while (nbytes >= FUSE_NAME_OFFSET) {
741 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
742 size_t reclen = FUSE_DIRENT_SIZE(dirent);
744 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
749 over = filldir(dstbuf, dirent->name, dirent->namelen,
750 file->f_pos, dirent->ino, dirent->type);
756 file->f_pos = dirent->off;
762 static inline size_t fuse_send_readdir(struct fuse_req *req, struct file *file,
763 struct inode *inode, loff_t pos,
766 return fuse_send_read_common(req, file, inode, pos, count, 1);
769 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
774 struct inode *inode = file->f_dentry->d_inode;
775 struct fuse_conn *fc = get_fuse_conn(inode);
776 struct fuse_req *req = fuse_get_request(fc);
780 page = alloc_page(GFP_KERNEL);
782 fuse_put_request(fc, req);
786 req->pages[0] = page;
787 nbytes = fuse_send_readdir(req, file, inode, file->f_pos, PAGE_SIZE);
788 err = req->out.h.error;
789 fuse_put_request(fc, req);
791 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
795 fuse_invalidate_attr(inode); /* atime changed */
799 static char *read_link(struct dentry *dentry)
801 struct inode *inode = dentry->d_inode;
802 struct fuse_conn *fc = get_fuse_conn(inode);
803 struct fuse_req *req = fuse_get_request(fc);
807 return ERR_PTR(-EINTR);
809 link = (char *) __get_free_page(GFP_KERNEL);
811 link = ERR_PTR(-ENOMEM);
814 req->in.h.opcode = FUSE_READLINK;
815 req->in.h.nodeid = get_node_id(inode);
818 req->out.numargs = 1;
819 req->out.args[0].size = PAGE_SIZE - 1;
820 req->out.args[0].value = link;
821 request_send(fc, req);
822 if (req->out.h.error) {
823 free_page((unsigned long) link);
824 link = ERR_PTR(req->out.h.error);
826 link[req->out.args[0].size] = '\0';
828 fuse_put_request(fc, req);
829 fuse_invalidate_attr(inode); /* atime changed */
833 static void free_link(char *link)
836 free_page((unsigned long) link);
839 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
841 nd_set_link(nd, read_link(dentry));
845 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
847 free_link(nd_get_link(nd));
850 static int fuse_dir_open(struct inode *inode, struct file *file)
852 return fuse_open_common(inode, file, 1);
855 static int fuse_dir_release(struct inode *inode, struct file *file)
857 return fuse_release_common(inode, file, 1);
860 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
862 /* nfsd can call this with no file */
863 return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
866 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
868 unsigned ivalid = iattr->ia_valid;
870 if (ivalid & ATTR_MODE)
871 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
872 if (ivalid & ATTR_UID)
873 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
874 if (ivalid & ATTR_GID)
875 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
876 if (ivalid & ATTR_SIZE)
877 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
878 /* You can only _set_ these together (they may change by themselves) */
879 if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
880 arg->valid |= FATTR_ATIME | FATTR_MTIME;
881 arg->atime = iattr->ia_atime.tv_sec;
882 arg->mtime = iattr->ia_mtime.tv_sec;
884 if (ivalid & ATTR_FILE) {
885 struct fuse_file *ff = iattr->ia_file->private_data;
886 arg->valid |= FATTR_FH;
892 * Set attributes, and at the same time refresh them.
894 * Truncation is slightly complicated, because the 'truncate' request
895 * may fail, in which case we don't want to touch the mapping.
896 * vmtruncate() doesn't allow for this case. So do the rlimit
897 * checking by hand and call vmtruncate() only after the file has
898 * actually been truncated.
900 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
902 struct inode *inode = entry->d_inode;
903 struct fuse_conn *fc = get_fuse_conn(inode);
904 struct fuse_inode *fi = get_fuse_inode(inode);
905 struct fuse_req *req;
906 struct fuse_setattr_in inarg;
907 struct fuse_attr_out outarg;
911 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
912 err = inode_change_ok(inode, attr);
917 if (attr->ia_valid & ATTR_SIZE) {
920 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
921 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
922 send_sig(SIGXFSZ, current, 0);
927 req = fuse_get_request(fc);
931 memset(&inarg, 0, sizeof(inarg));
932 iattr_to_fattr(attr, &inarg);
933 req->in.h.opcode = FUSE_SETATTR;
934 req->in.h.nodeid = get_node_id(inode);
937 req->in.args[0].size = sizeof(inarg);
938 req->in.args[0].value = &inarg;
939 req->out.numargs = 1;
940 req->out.args[0].size = sizeof(outarg);
941 req->out.args[0].value = &outarg;
942 request_send(fc, req);
943 err = req->out.h.error;
944 fuse_put_request(fc, req);
946 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
947 make_bad_inode(inode);
951 loff_t origsize = i_size_read(inode);
952 i_size_write(inode, outarg.attr.size);
953 if (origsize > outarg.attr.size)
954 vmtruncate(inode, outarg.attr.size);
956 fuse_change_attributes(inode, &outarg.attr);
957 fi->i_time = time_to_jiffies(outarg.attr_valid,
958 outarg.attr_valid_nsec);
960 } else if (err == -EINTR)
961 fuse_invalidate_attr(inode);
966 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
969 struct inode *inode = entry->d_inode;
970 int err = fuse_revalidate(entry);
972 generic_fillattr(inode, stat);
977 static int fuse_setxattr(struct dentry *entry, const char *name,
978 const void *value, size_t size, int flags)
980 struct inode *inode = entry->d_inode;
981 struct fuse_conn *fc = get_fuse_conn(inode);
982 struct fuse_req *req;
983 struct fuse_setxattr_in inarg;
986 if (size > FUSE_XATTR_SIZE_MAX)
992 req = fuse_get_request(fc);
996 memset(&inarg, 0, sizeof(inarg));
999 req->in.h.opcode = FUSE_SETXATTR;
1000 req->in.h.nodeid = get_node_id(inode);
1002 req->in.numargs = 3;
1003 req->in.args[0].size = sizeof(inarg);
1004 req->in.args[0].value = &inarg;
1005 req->in.args[1].size = strlen(name) + 1;
1006 req->in.args[1].value = name;
1007 req->in.args[2].size = size;
1008 req->in.args[2].value = value;
1009 request_send(fc, req);
1010 err = req->out.h.error;
1011 fuse_put_request(fc, req);
1012 if (err == -ENOSYS) {
1013 fc->no_setxattr = 1;
1019 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1020 void *value, size_t size)
1022 struct inode *inode = entry->d_inode;
1023 struct fuse_conn *fc = get_fuse_conn(inode);
1024 struct fuse_req *req;
1025 struct fuse_getxattr_in inarg;
1026 struct fuse_getxattr_out outarg;
1029 if (fc->no_getxattr)
1032 req = fuse_get_request(fc);
1036 memset(&inarg, 0, sizeof(inarg));
1038 req->in.h.opcode = FUSE_GETXATTR;
1039 req->in.h.nodeid = get_node_id(inode);
1041 req->in.numargs = 2;
1042 req->in.args[0].size = sizeof(inarg);
1043 req->in.args[0].value = &inarg;
1044 req->in.args[1].size = strlen(name) + 1;
1045 req->in.args[1].value = name;
1046 /* This is really two different operations rolled into one */
1047 req->out.numargs = 1;
1049 req->out.argvar = 1;
1050 req->out.args[0].size = size;
1051 req->out.args[0].value = value;
1053 req->out.args[0].size = sizeof(outarg);
1054 req->out.args[0].value = &outarg;
1056 request_send(fc, req);
1057 ret = req->out.h.error;
1059 ret = size ? req->out.args[0].size : outarg.size;
1061 if (ret == -ENOSYS) {
1062 fc->no_getxattr = 1;
1066 fuse_put_request(fc, req);
1070 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1072 struct inode *inode = entry->d_inode;
1073 struct fuse_conn *fc = get_fuse_conn(inode);
1074 struct fuse_req *req;
1075 struct fuse_getxattr_in inarg;
1076 struct fuse_getxattr_out outarg;
1079 if (fc->no_listxattr)
1082 req = fuse_get_request(fc);
1086 memset(&inarg, 0, sizeof(inarg));
1088 req->in.h.opcode = FUSE_LISTXATTR;
1089 req->in.h.nodeid = get_node_id(inode);
1091 req->in.numargs = 1;
1092 req->in.args[0].size = sizeof(inarg);
1093 req->in.args[0].value = &inarg;
1094 /* This is really two different operations rolled into one */
1095 req->out.numargs = 1;
1097 req->out.argvar = 1;
1098 req->out.args[0].size = size;
1099 req->out.args[0].value = list;
1101 req->out.args[0].size = sizeof(outarg);
1102 req->out.args[0].value = &outarg;
1104 request_send(fc, req);
1105 ret = req->out.h.error;
1107 ret = size ? req->out.args[0].size : outarg.size;
1109 if (ret == -ENOSYS) {
1110 fc->no_listxattr = 1;
1114 fuse_put_request(fc, req);
1118 static int fuse_removexattr(struct dentry *entry, const char *name)
1120 struct inode *inode = entry->d_inode;
1121 struct fuse_conn *fc = get_fuse_conn(inode);
1122 struct fuse_req *req;
1125 if (fc->no_removexattr)
1128 req = fuse_get_request(fc);
1132 req->in.h.opcode = FUSE_REMOVEXATTR;
1133 req->in.h.nodeid = get_node_id(inode);
1135 req->in.numargs = 1;
1136 req->in.args[0].size = strlen(name) + 1;
1137 req->in.args[0].value = name;
1138 request_send(fc, req);
1139 err = req->out.h.error;
1140 fuse_put_request(fc, req);
1141 if (err == -ENOSYS) {
1142 fc->no_removexattr = 1;
1148 static struct inode_operations fuse_dir_inode_operations = {
1149 .lookup = fuse_lookup,
1150 .mkdir = fuse_mkdir,
1151 .symlink = fuse_symlink,
1152 .unlink = fuse_unlink,
1153 .rmdir = fuse_rmdir,
1154 .rename = fuse_rename,
1156 .setattr = fuse_setattr,
1157 .create = fuse_create,
1158 .mknod = fuse_mknod,
1159 .permission = fuse_permission,
1160 .getattr = fuse_getattr,
1161 .setxattr = fuse_setxattr,
1162 .getxattr = fuse_getxattr,
1163 .listxattr = fuse_listxattr,
1164 .removexattr = fuse_removexattr,
1167 static struct file_operations fuse_dir_operations = {
1168 .llseek = generic_file_llseek,
1169 .read = generic_read_dir,
1170 .readdir = fuse_readdir,
1171 .open = fuse_dir_open,
1172 .release = fuse_dir_release,
1173 .fsync = fuse_dir_fsync,
1176 static struct inode_operations fuse_common_inode_operations = {
1177 .setattr = fuse_setattr,
1178 .permission = fuse_permission,
1179 .getattr = fuse_getattr,
1180 .setxattr = fuse_setxattr,
1181 .getxattr = fuse_getxattr,
1182 .listxattr = fuse_listxattr,
1183 .removexattr = fuse_removexattr,
1186 static struct inode_operations fuse_symlink_inode_operations = {
1187 .setattr = fuse_setattr,
1188 .follow_link = fuse_follow_link,
1189 .put_link = fuse_put_link,
1190 .readlink = generic_readlink,
1191 .getattr = fuse_getattr,
1192 .setxattr = fuse_setxattr,
1193 .getxattr = fuse_getxattr,
1194 .listxattr = fuse_listxattr,
1195 .removexattr = fuse_removexattr,
1198 void fuse_init_common(struct inode *inode)
1200 inode->i_op = &fuse_common_inode_operations;
1203 void fuse_init_dir(struct inode *inode)
1205 inode->i_op = &fuse_dir_inode_operations;
1206 inode->i_fop = &fuse_dir_operations;
1209 void fuse_init_symlink(struct inode *inode)
1211 inode->i_op = &fuse_symlink_inode_operations;