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>
17 static inline unsigned long time_to_jiffies(unsigned long sec,
20 struct timespec ts = {sec, nsec};
21 return jiffies + timespec_to_jiffies(&ts);
24 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
26 struct fuse_entry_out *outarg)
28 req->in.h.opcode = FUSE_LOOKUP;
29 req->in.h.nodeid = get_node_id(dir);
32 req->in.args[0].size = entry->d_name.len + 1;
33 req->in.args[0].value = entry->d_name.name;
35 req->out.args[0].size = sizeof(struct fuse_entry_out);
36 req->out.args[0].value = outarg;
39 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
41 if (!entry->d_inode || is_bad_inode(entry->d_inode))
43 else if (time_after(jiffies, entry->d_time)) {
45 struct fuse_entry_out outarg;
46 struct inode *inode = entry->d_inode;
47 struct fuse_inode *fi = get_fuse_inode(inode);
48 struct fuse_conn *fc = get_fuse_conn(inode);
49 struct fuse_req *req = fuse_get_request_nonint(fc);
53 fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
54 request_send_nonint(fc, req);
55 err = req->out.h.error;
57 if (outarg.nodeid != get_node_id(inode)) {
58 fuse_send_forget(fc, req, outarg.nodeid, 1);
63 fuse_put_request(fc, req);
64 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
67 fuse_change_attributes(inode, &outarg.attr);
68 entry->d_time = time_to_jiffies(outarg.entry_valid,
69 outarg.entry_valid_nsec);
70 fi->i_time = time_to_jiffies(outarg.attr_valid,
71 outarg.attr_valid_nsec);
76 static struct dentry_operations fuse_dentry_operations = {
77 .d_revalidate = fuse_dentry_revalidate,
80 static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
81 struct inode **inodep)
84 struct fuse_entry_out outarg;
85 struct inode *inode = NULL;
86 struct fuse_conn *fc = get_fuse_conn(dir);
89 if (entry->d_name.len > FUSE_NAME_MAX)
92 req = fuse_get_request(fc);
94 return -ERESTARTNOINTR;
96 fuse_lookup_init(req, dir, entry, &outarg);
97 request_send(fc, req);
98 err = req->out.h.error;
100 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
103 fuse_send_forget(fc, req, outarg.nodeid, 1);
107 fuse_put_request(fc, req);
108 if (err && err != -ENOENT)
112 struct fuse_inode *fi = get_fuse_inode(inode);
113 entry->d_time = time_to_jiffies(outarg.entry_valid,
114 outarg.entry_valid_nsec);
115 fi->i_time = time_to_jiffies(outarg.attr_valid,
116 outarg.attr_valid_nsec);
119 entry->d_op = &fuse_dentry_operations;
124 void fuse_invalidate_attr(struct inode *inode)
126 get_fuse_inode(inode)->i_time = jiffies - 1;
129 static void fuse_invalidate_entry(struct dentry *entry)
132 entry->d_time = jiffies - 1;
135 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
136 struct inode *dir, struct dentry *entry,
139 struct fuse_entry_out outarg;
141 struct fuse_inode *fi;
144 req->in.h.nodeid = get_node_id(dir);
146 req->out.numargs = 1;
147 req->out.args[0].size = sizeof(outarg);
148 req->out.args[0].value = &outarg;
149 request_send(fc, req);
150 err = req->out.h.error;
152 fuse_put_request(fc, req);
155 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
158 fuse_send_forget(fc, req, outarg.nodeid, 1);
161 fuse_put_request(fc, req);
163 /* Don't allow userspace to do really stupid things... */
164 if ((inode->i_mode ^ mode) & S_IFMT) {
169 entry->d_time = time_to_jiffies(outarg.entry_valid,
170 outarg.entry_valid_nsec);
172 fi = get_fuse_inode(inode);
173 fi->i_time = time_to_jiffies(outarg.attr_valid,
174 outarg.attr_valid_nsec);
176 d_instantiate(entry, inode);
177 fuse_invalidate_attr(dir);
181 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
184 struct fuse_mknod_in inarg;
185 struct fuse_conn *fc = get_fuse_conn(dir);
186 struct fuse_req *req = fuse_get_request(fc);
188 return -ERESTARTNOINTR;
190 memset(&inarg, 0, sizeof(inarg));
192 inarg.rdev = new_encode_dev(rdev);
193 req->in.h.opcode = FUSE_MKNOD;
195 req->in.args[0].size = sizeof(inarg);
196 req->in.args[0].value = &inarg;
197 req->in.args[1].size = entry->d_name.len + 1;
198 req->in.args[1].value = entry->d_name.name;
199 return create_new_entry(fc, req, dir, entry, mode);
202 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
203 struct nameidata *nd)
205 return fuse_mknod(dir, entry, mode, 0);
208 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
210 struct fuse_mkdir_in inarg;
211 struct fuse_conn *fc = get_fuse_conn(dir);
212 struct fuse_req *req = fuse_get_request(fc);
214 return -ERESTARTNOINTR;
216 memset(&inarg, 0, sizeof(inarg));
218 req->in.h.opcode = FUSE_MKDIR;
220 req->in.args[0].size = sizeof(inarg);
221 req->in.args[0].value = &inarg;
222 req->in.args[1].size = entry->d_name.len + 1;
223 req->in.args[1].value = entry->d_name.name;
224 return create_new_entry(fc, req, dir, entry, S_IFDIR);
227 static int fuse_symlink(struct inode *dir, struct dentry *entry,
230 struct fuse_conn *fc = get_fuse_conn(dir);
231 unsigned len = strlen(link) + 1;
232 struct fuse_req *req;
234 if (len > FUSE_SYMLINK_MAX)
235 return -ENAMETOOLONG;
237 req = fuse_get_request(fc);
239 return -ERESTARTNOINTR;
241 req->in.h.opcode = FUSE_SYMLINK;
243 req->in.args[0].size = entry->d_name.len + 1;
244 req->in.args[0].value = entry->d_name.name;
245 req->in.args[1].size = len;
246 req->in.args[1].value = link;
247 return create_new_entry(fc, req, dir, entry, S_IFLNK);
250 static int fuse_unlink(struct inode *dir, struct dentry *entry)
253 struct fuse_conn *fc = get_fuse_conn(dir);
254 struct fuse_req *req = fuse_get_request(fc);
256 return -ERESTARTNOINTR;
258 req->in.h.opcode = FUSE_UNLINK;
259 req->in.h.nodeid = get_node_id(dir);
262 req->in.args[0].size = entry->d_name.len + 1;
263 req->in.args[0].value = entry->d_name.name;
264 request_send(fc, req);
265 err = req->out.h.error;
266 fuse_put_request(fc, req);
268 struct inode *inode = entry->d_inode;
270 /* Set nlink to zero so the inode can be cleared, if
271 the inode does have more links this will be
272 discovered at the next lookup/getattr */
274 fuse_invalidate_attr(inode);
275 fuse_invalidate_attr(dir);
276 } else if (err == -EINTR)
277 fuse_invalidate_entry(entry);
281 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
284 struct fuse_conn *fc = get_fuse_conn(dir);
285 struct fuse_req *req = fuse_get_request(fc);
287 return -ERESTARTNOINTR;
289 req->in.h.opcode = FUSE_RMDIR;
290 req->in.h.nodeid = get_node_id(dir);
293 req->in.args[0].size = entry->d_name.len + 1;
294 req->in.args[0].value = entry->d_name.name;
295 request_send(fc, req);
296 err = req->out.h.error;
297 fuse_put_request(fc, req);
299 entry->d_inode->i_nlink = 0;
300 fuse_invalidate_attr(dir);
301 } else if (err == -EINTR)
302 fuse_invalidate_entry(entry);
306 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
307 struct inode *newdir, struct dentry *newent)
310 struct fuse_rename_in inarg;
311 struct fuse_conn *fc = get_fuse_conn(olddir);
312 struct fuse_req *req = fuse_get_request(fc);
314 return -ERESTARTNOINTR;
316 memset(&inarg, 0, sizeof(inarg));
317 inarg.newdir = get_node_id(newdir);
318 req->in.h.opcode = FUSE_RENAME;
319 req->in.h.nodeid = get_node_id(olddir);
321 req->inode2 = newdir;
323 req->in.args[0].size = sizeof(inarg);
324 req->in.args[0].value = &inarg;
325 req->in.args[1].size = oldent->d_name.len + 1;
326 req->in.args[1].value = oldent->d_name.name;
327 req->in.args[2].size = newent->d_name.len + 1;
328 req->in.args[2].value = newent->d_name.name;
329 request_send(fc, req);
330 err = req->out.h.error;
331 fuse_put_request(fc, req);
333 fuse_invalidate_attr(olddir);
334 if (olddir != newdir)
335 fuse_invalidate_attr(newdir);
336 } else if (err == -EINTR) {
337 /* If request was interrupted, DEITY only knows if the
338 rename actually took place. If the invalidation
339 fails (e.g. some process has CWD under the renamed
340 directory), then there can be inconsistency between
341 the dcache and the real filesystem. Tough luck. */
342 fuse_invalidate_entry(oldent);
344 fuse_invalidate_entry(newent);
350 static int fuse_link(struct dentry *entry, struct inode *newdir,
351 struct dentry *newent)
354 struct fuse_link_in inarg;
355 struct inode *inode = entry->d_inode;
356 struct fuse_conn *fc = get_fuse_conn(inode);
357 struct fuse_req *req = fuse_get_request(fc);
359 return -ERESTARTNOINTR;
361 memset(&inarg, 0, sizeof(inarg));
362 inarg.oldnodeid = get_node_id(inode);
363 req->in.h.opcode = FUSE_LINK;
366 req->in.args[0].size = sizeof(inarg);
367 req->in.args[0].value = &inarg;
368 req->in.args[1].size = newent->d_name.len + 1;
369 req->in.args[1].value = newent->d_name.name;
370 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
371 /* Contrary to "normal" filesystems it can happen that link
372 makes two "logical" inodes point to the same "physical"
373 inode. We invalidate the attributes of the old one, so it
374 will reflect changes in the backing inode (link count,
377 if (!err || err == -EINTR)
378 fuse_invalidate_attr(inode);
382 int fuse_do_getattr(struct inode *inode)
385 struct fuse_attr_out arg;
386 struct fuse_conn *fc = get_fuse_conn(inode);
387 struct fuse_req *req = fuse_get_request(fc);
389 return -ERESTARTNOINTR;
391 req->in.h.opcode = FUSE_GETATTR;
392 req->in.h.nodeid = get_node_id(inode);
394 req->out.numargs = 1;
395 req->out.args[0].size = sizeof(arg);
396 req->out.args[0].value = &arg;
397 request_send(fc, req);
398 err = req->out.h.error;
399 fuse_put_request(fc, req);
401 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
402 make_bad_inode(inode);
405 struct fuse_inode *fi = get_fuse_inode(inode);
406 fuse_change_attributes(inode, &arg.attr);
407 fi->i_time = time_to_jiffies(arg.attr_valid,
408 arg.attr_valid_nsec);
414 static int fuse_revalidate(struct dentry *entry)
416 struct inode *inode = entry->d_inode;
417 struct fuse_inode *fi = get_fuse_inode(inode);
418 struct fuse_conn *fc = get_fuse_conn(inode);
420 if (get_node_id(inode) == FUSE_ROOT_ID) {
421 if (current->fsuid != fc->user_id)
423 } else if (time_before_eq(jiffies, fi->i_time))
426 return fuse_do_getattr(inode);
429 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
431 struct fuse_conn *fc = get_fuse_conn(inode);
433 if (current->fsuid != fc->user_id)
436 int mode = inode->i_mode;
437 if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
438 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
440 if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
446 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
447 void *dstbuf, filldir_t filldir)
449 while (nbytes >= FUSE_NAME_OFFSET) {
450 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
451 size_t reclen = FUSE_DIRENT_SIZE(dirent);
453 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
458 over = filldir(dstbuf, dirent->name, dirent->namelen,
459 file->f_pos, dirent->ino, dirent->type);
465 file->f_pos = dirent->off;
471 static int fuse_checkdir(struct file *cfile, struct file *file)
476 inode = cfile->f_dentry->d_inode;
477 if (!S_ISREG(inode->i_mode)) {
482 file->private_data = cfile;
486 static int fuse_getdir(struct file *file)
488 struct inode *inode = file->f_dentry->d_inode;
489 struct fuse_conn *fc = get_fuse_conn(inode);
490 struct fuse_req *req = fuse_get_request(fc);
491 struct fuse_getdir_out_i outarg;
495 return -ERESTARTNOINTR;
497 req->in.h.opcode = FUSE_GETDIR;
498 req->in.h.nodeid = get_node_id(inode);
500 req->out.numargs = 1;
501 req->out.args[0].size = sizeof(struct fuse_getdir_out);
502 req->out.args[0].value = &outarg;
503 request_send(fc, req);
504 err = req->out.h.error;
505 fuse_put_request(fc, req);
507 err = fuse_checkdir(outarg.file, file);
511 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
513 struct file *cfile = file->private_data;
518 ret = fuse_getdir(file);
522 cfile = file->private_data;
525 buf = (char *) __get_free_page(GFP_KERNEL);
529 ret = kernel_read(cfile, file->f_pos, buf, PAGE_SIZE);
531 ret = parse_dirfile(buf, ret, file, dstbuf, filldir);
533 free_page((unsigned long) buf);
537 static char *read_link(struct dentry *dentry)
539 struct inode *inode = dentry->d_inode;
540 struct fuse_conn *fc = get_fuse_conn(inode);
541 struct fuse_req *req = fuse_get_request(fc);
545 return ERR_PTR(-ERESTARTNOINTR);
547 link = (char *) __get_free_page(GFP_KERNEL);
549 link = ERR_PTR(-ENOMEM);
552 req->in.h.opcode = FUSE_READLINK;
553 req->in.h.nodeid = get_node_id(inode);
556 req->out.numargs = 1;
557 req->out.args[0].size = PAGE_SIZE - 1;
558 req->out.args[0].value = link;
559 request_send(fc, req);
560 if (req->out.h.error) {
561 free_page((unsigned long) link);
562 link = ERR_PTR(req->out.h.error);
564 link[req->out.args[0].size] = '\0';
566 fuse_put_request(fc, req);
570 static void free_link(char *link)
573 free_page((unsigned long) link);
576 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
578 nd_set_link(nd, read_link(dentry));
582 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
584 free_link(nd_get_link(nd));
587 static int fuse_dir_open(struct inode *inode, struct file *file)
589 file->private_data = NULL;
593 static int fuse_dir_release(struct inode *inode, struct file *file)
595 struct file *cfile = file->private_data;
603 static unsigned iattr_to_fattr(struct iattr *iattr, struct fuse_attr *fattr)
605 unsigned ivalid = iattr->ia_valid;
608 memset(fattr, 0, sizeof(*fattr));
610 if (ivalid & ATTR_MODE)
611 fvalid |= FATTR_MODE, fattr->mode = iattr->ia_mode;
612 if (ivalid & ATTR_UID)
613 fvalid |= FATTR_UID, fattr->uid = iattr->ia_uid;
614 if (ivalid & ATTR_GID)
615 fvalid |= FATTR_GID, fattr->gid = iattr->ia_gid;
616 if (ivalid & ATTR_SIZE)
617 fvalid |= FATTR_SIZE, fattr->size = iattr->ia_size;
618 /* You can only _set_ these together (they may change by themselves) */
619 if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
620 fvalid |= FATTR_ATIME | FATTR_MTIME;
621 fattr->atime = iattr->ia_atime.tv_sec;
622 fattr->mtime = iattr->ia_mtime.tv_sec;
628 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
630 struct inode *inode = entry->d_inode;
631 struct fuse_conn *fc = get_fuse_conn(inode);
632 struct fuse_inode *fi = get_fuse_inode(inode);
633 struct fuse_req *req;
634 struct fuse_setattr_in inarg;
635 struct fuse_attr_out outarg;
639 if (attr->ia_valid & ATTR_SIZE) {
642 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
643 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
644 send_sig(SIGXFSZ, current, 0);
649 req = fuse_get_request(fc);
651 return -ERESTARTNOINTR;
653 memset(&inarg, 0, sizeof(inarg));
654 inarg.valid = iattr_to_fattr(attr, &inarg.attr);
655 req->in.h.opcode = FUSE_SETATTR;
656 req->in.h.nodeid = get_node_id(inode);
659 req->in.args[0].size = sizeof(inarg);
660 req->in.args[0].value = &inarg;
661 req->out.numargs = 1;
662 req->out.args[0].size = sizeof(outarg);
663 req->out.args[0].value = &outarg;
664 request_send(fc, req);
665 err = req->out.h.error;
666 fuse_put_request(fc, req);
668 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
669 make_bad_inode(inode);
673 loff_t origsize = i_size_read(inode);
674 i_size_write(inode, outarg.attr.size);
675 if (origsize > outarg.attr.size)
676 vmtruncate(inode, outarg.attr.size);
678 fuse_change_attributes(inode, &outarg.attr);
679 fi->i_time = time_to_jiffies(outarg.attr_valid,
680 outarg.attr_valid_nsec);
682 } else if (err == -EINTR)
683 fuse_invalidate_attr(inode);
688 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
691 struct inode *inode = entry->d_inode;
692 int err = fuse_revalidate(entry);
694 generic_fillattr(inode, stat);
699 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
700 struct nameidata *nd)
703 int err = fuse_lookup_iget(dir, entry, &inode);
706 if (inode && S_ISDIR(inode->i_mode)) {
707 /* Don't allow creating an alias to a directory */
708 struct dentry *alias = d_find_alias(inode);
709 if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
712 return ERR_PTR(-EIO);
715 return d_splice_alias(inode, entry);
718 static struct inode_operations fuse_dir_inode_operations = {
719 .lookup = fuse_lookup,
721 .symlink = fuse_symlink,
722 .unlink = fuse_unlink,
724 .rename = fuse_rename,
726 .setattr = fuse_setattr,
727 .create = fuse_create,
729 .permission = fuse_permission,
730 .getattr = fuse_getattr,
733 static struct file_operations fuse_dir_operations = {
734 .read = generic_read_dir,
735 .readdir = fuse_readdir,
736 .open = fuse_dir_open,
737 .release = fuse_dir_release,
740 static struct inode_operations fuse_common_inode_operations = {
741 .setattr = fuse_setattr,
742 .permission = fuse_permission,
743 .getattr = fuse_getattr,
746 static struct inode_operations fuse_symlink_inode_operations = {
747 .setattr = fuse_setattr,
748 .follow_link = fuse_follow_link,
749 .put_link = fuse_put_link,
750 .readlink = generic_readlink,
751 .getattr = fuse_getattr,
754 void fuse_init_common(struct inode *inode)
756 inode->i_op = &fuse_common_inode_operations;
759 void fuse_init_dir(struct inode *inode)
761 inode->i_op = &fuse_dir_inode_operations;
762 inode->i_fop = &fuse_dir_operations;
765 void fuse_init_symlink(struct inode *inode)
767 inode->i_op = &fuse_symlink_inode_operations;