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>
16 #include <linux/mount.h>
18 static inline unsigned long time_to_jiffies(unsigned long sec
,
21 struct timespec ts
= {sec
, nsec
};
22 return jiffies
+ timespec_to_jiffies(&ts
);
25 static void fuse_lookup_init(struct fuse_req
*req
, struct inode
*dir
,
27 struct fuse_entry_out
*outarg
)
29 req
->in
.h
.opcode
= FUSE_LOOKUP
;
30 req
->in
.h
.nodeid
= get_node_id(dir
);
33 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
34 req
->in
.args
[0].value
= entry
->d_name
.name
;
36 req
->out
.args
[0].size
= sizeof(struct fuse_entry_out
);
37 req
->out
.args
[0].value
= outarg
;
40 static int fuse_dentry_revalidate(struct dentry
*entry
, struct nameidata
*nd
)
42 if (!entry
->d_inode
|| is_bad_inode(entry
->d_inode
))
44 else if (time_after(jiffies
, entry
->d_time
)) {
46 struct fuse_entry_out outarg
;
47 struct inode
*inode
= entry
->d_inode
;
48 struct fuse_inode
*fi
= get_fuse_inode(inode
);
49 struct fuse_conn
*fc
= get_fuse_conn(inode
);
50 struct fuse_req
*req
= fuse_get_request(fc
);
54 fuse_lookup_init(req
, entry
->d_parent
->d_inode
, entry
, &outarg
);
55 request_send(fc
, req
);
56 err
= req
->out
.h
.error
;
58 if (outarg
.nodeid
!= get_node_id(inode
)) {
59 fuse_send_forget(fc
, req
, outarg
.nodeid
, 1);
64 fuse_put_request(fc
, req
);
65 if (err
|| (outarg
.attr
.mode
^ inode
->i_mode
) & S_IFMT
)
68 fuse_change_attributes(inode
, &outarg
.attr
);
69 entry
->d_time
= time_to_jiffies(outarg
.entry_valid
,
70 outarg
.entry_valid_nsec
);
71 fi
->i_time
= time_to_jiffies(outarg
.attr_valid
,
72 outarg
.attr_valid_nsec
);
77 static int dir_alias(struct inode
*inode
)
79 if (S_ISDIR(inode
->i_mode
)) {
80 /* Don't allow creating an alias to a directory */
81 struct dentry
*alias
= d_find_alias(inode
);
90 static inline int invalid_nodeid(u64 nodeid
)
92 return !nodeid
|| nodeid
== FUSE_ROOT_ID
;
95 static struct dentry_operations fuse_dentry_operations
= {
96 .d_revalidate
= fuse_dentry_revalidate
,
99 static int fuse_lookup_iget(struct inode
*dir
, struct dentry
*entry
,
100 struct inode
**inodep
)
103 struct fuse_entry_out outarg
;
104 struct inode
*inode
= NULL
;
105 struct fuse_conn
*fc
= get_fuse_conn(dir
);
106 struct fuse_req
*req
;
108 if (entry
->d_name
.len
> FUSE_NAME_MAX
)
109 return -ENAMETOOLONG
;
111 req
= fuse_get_request(fc
);
115 fuse_lookup_init(req
, dir
, entry
, &outarg
);
116 request_send(fc
, req
);
117 err
= req
->out
.h
.error
;
118 if (!err
&& invalid_nodeid(outarg
.nodeid
))
121 inode
= fuse_iget(dir
->i_sb
, outarg
.nodeid
, outarg
.generation
,
124 fuse_send_forget(fc
, req
, outarg
.nodeid
, 1);
128 fuse_put_request(fc
, req
);
129 if (err
&& err
!= -ENOENT
)
133 struct fuse_inode
*fi
= get_fuse_inode(inode
);
134 entry
->d_time
= time_to_jiffies(outarg
.entry_valid
,
135 outarg
.entry_valid_nsec
);
136 fi
->i_time
= time_to_jiffies(outarg
.attr_valid
,
137 outarg
.attr_valid_nsec
);
140 entry
->d_op
= &fuse_dentry_operations
;
145 void fuse_invalidate_attr(struct inode
*inode
)
147 get_fuse_inode(inode
)->i_time
= jiffies
- 1;
150 static void fuse_invalidate_entry(struct dentry
*entry
)
153 entry
->d_time
= jiffies
- 1;
156 static int fuse_create_open(struct inode
*dir
, struct dentry
*entry
, int mode
,
157 struct nameidata
*nd
)
161 struct fuse_conn
*fc
= get_fuse_conn(dir
);
162 struct fuse_req
*req
;
163 struct fuse_open_in inarg
;
164 struct fuse_open_out outopen
;
165 struct fuse_entry_out outentry
;
166 struct fuse_inode
*fi
;
167 struct fuse_file
*ff
;
169 int flags
= nd
->intent
.open
.flags
- 1;
176 if (entry
->d_name
.len
> FUSE_NAME_MAX
)
180 req
= fuse_get_request(fc
);
184 ff
= fuse_file_alloc();
186 goto out_put_request
;
189 memset(&inarg
, 0, sizeof(inarg
));
192 req
->in
.h
.opcode
= FUSE_CREATE
;
193 req
->in
.h
.nodeid
= get_node_id(dir
);
196 req
->in
.args
[0].size
= sizeof(inarg
);
197 req
->in
.args
[0].value
= &inarg
;
198 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
199 req
->in
.args
[1].value
= entry
->d_name
.name
;
200 req
->out
.numargs
= 2;
201 req
->out
.args
[0].size
= sizeof(outentry
);
202 req
->out
.args
[0].value
= &outentry
;
203 req
->out
.args
[1].size
= sizeof(outopen
);
204 req
->out
.args
[1].value
= &outopen
;
205 request_send(fc
, req
);
206 err
= req
->out
.h
.error
;
214 if (!S_ISREG(outentry
.attr
.mode
) || invalid_nodeid(outentry
.nodeid
))
217 inode
= fuse_iget(dir
->i_sb
, outentry
.nodeid
, outentry
.generation
,
221 flags
&= ~(O_CREAT
| O_EXCL
| O_TRUNC
);
223 fuse_send_release(fc
, ff
, outentry
.nodeid
, NULL
, flags
, 0);
224 goto out_put_request
;
226 fuse_put_request(fc
, req
);
227 entry
->d_time
= time_to_jiffies(outentry
.entry_valid
,
228 outentry
.entry_valid_nsec
);
229 fi
= get_fuse_inode(inode
);
230 fi
->i_time
= time_to_jiffies(outentry
.attr_valid
,
231 outentry
.attr_valid_nsec
);
233 d_instantiate(entry
, inode
);
234 file
= lookup_instantiate_filp(nd
, entry
, generic_file_open
);
237 fuse_send_release(fc
, ff
, outentry
.nodeid
, inode
, flags
, 0);
238 return PTR_ERR(file
);
240 fuse_finish_open(inode
, file
, ff
, &outopen
);
246 fuse_put_request(fc
, req
);
251 static int create_new_entry(struct fuse_conn
*fc
, struct fuse_req
*req
,
252 struct inode
*dir
, struct dentry
*entry
,
255 struct fuse_entry_out outarg
;
257 struct fuse_inode
*fi
;
260 req
->in
.h
.nodeid
= get_node_id(dir
);
262 req
->out
.numargs
= 1;
263 req
->out
.args
[0].size
= sizeof(outarg
);
264 req
->out
.args
[0].value
= &outarg
;
265 request_send(fc
, req
);
266 err
= req
->out
.h
.error
;
268 fuse_put_request(fc
, req
);
271 if (invalid_nodeid(outarg
.nodeid
)) {
272 fuse_put_request(fc
, req
);
275 inode
= fuse_iget(dir
->i_sb
, outarg
.nodeid
, outarg
.generation
,
278 fuse_send_forget(fc
, req
, outarg
.nodeid
, 1);
281 fuse_put_request(fc
, req
);
283 /* Don't allow userspace to do really stupid things... */
284 if (((inode
->i_mode
^ mode
) & S_IFMT
) || dir_alias(inode
)) {
289 entry
->d_time
= time_to_jiffies(outarg
.entry_valid
,
290 outarg
.entry_valid_nsec
);
292 fi
= get_fuse_inode(inode
);
293 fi
->i_time
= time_to_jiffies(outarg
.attr_valid
,
294 outarg
.attr_valid_nsec
);
296 d_instantiate(entry
, inode
);
297 fuse_invalidate_attr(dir
);
301 static int fuse_mknod(struct inode
*dir
, struct dentry
*entry
, int mode
,
304 struct fuse_mknod_in inarg
;
305 struct fuse_conn
*fc
= get_fuse_conn(dir
);
306 struct fuse_req
*req
= fuse_get_request(fc
);
310 memset(&inarg
, 0, sizeof(inarg
));
312 inarg
.rdev
= new_encode_dev(rdev
);
313 req
->in
.h
.opcode
= FUSE_MKNOD
;
315 req
->in
.args
[0].size
= sizeof(inarg
);
316 req
->in
.args
[0].value
= &inarg
;
317 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
318 req
->in
.args
[1].value
= entry
->d_name
.name
;
319 return create_new_entry(fc
, req
, dir
, entry
, mode
);
322 static int fuse_create(struct inode
*dir
, struct dentry
*entry
, int mode
,
323 struct nameidata
*nd
)
325 if (nd
&& (nd
->flags
& LOOKUP_CREATE
)) {
326 int err
= fuse_create_open(dir
, entry
, mode
, nd
);
329 /* Fall back on mknod */
331 return fuse_mknod(dir
, entry
, mode
, 0);
334 static int fuse_mkdir(struct inode
*dir
, struct dentry
*entry
, int mode
)
336 struct fuse_mkdir_in inarg
;
337 struct fuse_conn
*fc
= get_fuse_conn(dir
);
338 struct fuse_req
*req
= fuse_get_request(fc
);
342 memset(&inarg
, 0, sizeof(inarg
));
344 req
->in
.h
.opcode
= FUSE_MKDIR
;
346 req
->in
.args
[0].size
= sizeof(inarg
);
347 req
->in
.args
[0].value
= &inarg
;
348 req
->in
.args
[1].size
= entry
->d_name
.len
+ 1;
349 req
->in
.args
[1].value
= entry
->d_name
.name
;
350 return create_new_entry(fc
, req
, dir
, entry
, S_IFDIR
);
353 static int fuse_symlink(struct inode
*dir
, struct dentry
*entry
,
356 struct fuse_conn
*fc
= get_fuse_conn(dir
);
357 unsigned len
= strlen(link
) + 1;
358 struct fuse_req
*req
;
360 if (len
> FUSE_SYMLINK_MAX
)
361 return -ENAMETOOLONG
;
363 req
= fuse_get_request(fc
);
367 req
->in
.h
.opcode
= FUSE_SYMLINK
;
369 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
370 req
->in
.args
[0].value
= entry
->d_name
.name
;
371 req
->in
.args
[1].size
= len
;
372 req
->in
.args
[1].value
= link
;
373 return create_new_entry(fc
, req
, dir
, entry
, S_IFLNK
);
376 static int fuse_unlink(struct inode
*dir
, struct dentry
*entry
)
379 struct fuse_conn
*fc
= get_fuse_conn(dir
);
380 struct fuse_req
*req
= fuse_get_request(fc
);
384 req
->in
.h
.opcode
= FUSE_UNLINK
;
385 req
->in
.h
.nodeid
= get_node_id(dir
);
388 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
389 req
->in
.args
[0].value
= entry
->d_name
.name
;
390 request_send(fc
, req
);
391 err
= req
->out
.h
.error
;
392 fuse_put_request(fc
, req
);
394 struct inode
*inode
= entry
->d_inode
;
396 /* Set nlink to zero so the inode can be cleared, if
397 the inode does have more links this will be
398 discovered at the next lookup/getattr */
400 fuse_invalidate_attr(inode
);
401 fuse_invalidate_attr(dir
);
402 } else if (err
== -EINTR
)
403 fuse_invalidate_entry(entry
);
407 static int fuse_rmdir(struct inode
*dir
, struct dentry
*entry
)
410 struct fuse_conn
*fc
= get_fuse_conn(dir
);
411 struct fuse_req
*req
= fuse_get_request(fc
);
415 req
->in
.h
.opcode
= FUSE_RMDIR
;
416 req
->in
.h
.nodeid
= get_node_id(dir
);
419 req
->in
.args
[0].size
= entry
->d_name
.len
+ 1;
420 req
->in
.args
[0].value
= entry
->d_name
.name
;
421 request_send(fc
, req
);
422 err
= req
->out
.h
.error
;
423 fuse_put_request(fc
, req
);
425 entry
->d_inode
->i_nlink
= 0;
426 fuse_invalidate_attr(dir
);
427 } else if (err
== -EINTR
)
428 fuse_invalidate_entry(entry
);
432 static int fuse_rename(struct inode
*olddir
, struct dentry
*oldent
,
433 struct inode
*newdir
, struct dentry
*newent
)
436 struct fuse_rename_in inarg
;
437 struct fuse_conn
*fc
= get_fuse_conn(olddir
);
438 struct fuse_req
*req
= fuse_get_request(fc
);
442 memset(&inarg
, 0, sizeof(inarg
));
443 inarg
.newdir
= get_node_id(newdir
);
444 req
->in
.h
.opcode
= FUSE_RENAME
;
445 req
->in
.h
.nodeid
= get_node_id(olddir
);
447 req
->inode2
= newdir
;
449 req
->in
.args
[0].size
= sizeof(inarg
);
450 req
->in
.args
[0].value
= &inarg
;
451 req
->in
.args
[1].size
= oldent
->d_name
.len
+ 1;
452 req
->in
.args
[1].value
= oldent
->d_name
.name
;
453 req
->in
.args
[2].size
= newent
->d_name
.len
+ 1;
454 req
->in
.args
[2].value
= newent
->d_name
.name
;
455 request_send(fc
, req
);
456 err
= req
->out
.h
.error
;
457 fuse_put_request(fc
, req
);
459 fuse_invalidate_attr(olddir
);
460 if (olddir
!= newdir
)
461 fuse_invalidate_attr(newdir
);
462 } else if (err
== -EINTR
) {
463 /* If request was interrupted, DEITY only knows if the
464 rename actually took place. If the invalidation
465 fails (e.g. some process has CWD under the renamed
466 directory), then there can be inconsistency between
467 the dcache and the real filesystem. Tough luck. */
468 fuse_invalidate_entry(oldent
);
470 fuse_invalidate_entry(newent
);
476 static int fuse_link(struct dentry
*entry
, struct inode
*newdir
,
477 struct dentry
*newent
)
480 struct fuse_link_in inarg
;
481 struct inode
*inode
= entry
->d_inode
;
482 struct fuse_conn
*fc
= get_fuse_conn(inode
);
483 struct fuse_req
*req
= fuse_get_request(fc
);
487 memset(&inarg
, 0, sizeof(inarg
));
488 inarg
.oldnodeid
= get_node_id(inode
);
489 req
->in
.h
.opcode
= FUSE_LINK
;
492 req
->in
.args
[0].size
= sizeof(inarg
);
493 req
->in
.args
[0].value
= &inarg
;
494 req
->in
.args
[1].size
= newent
->d_name
.len
+ 1;
495 req
->in
.args
[1].value
= newent
->d_name
.name
;
496 err
= create_new_entry(fc
, req
, newdir
, newent
, inode
->i_mode
);
497 /* Contrary to "normal" filesystems it can happen that link
498 makes two "logical" inodes point to the same "physical"
499 inode. We invalidate the attributes of the old one, so it
500 will reflect changes in the backing inode (link count,
503 if (!err
|| err
== -EINTR
)
504 fuse_invalidate_attr(inode
);
508 int fuse_do_getattr(struct inode
*inode
)
511 struct fuse_attr_out arg
;
512 struct fuse_conn
*fc
= get_fuse_conn(inode
);
513 struct fuse_req
*req
= fuse_get_request(fc
);
517 req
->in
.h
.opcode
= FUSE_GETATTR
;
518 req
->in
.h
.nodeid
= get_node_id(inode
);
520 req
->out
.numargs
= 1;
521 req
->out
.args
[0].size
= sizeof(arg
);
522 req
->out
.args
[0].value
= &arg
;
523 request_send(fc
, req
);
524 err
= req
->out
.h
.error
;
525 fuse_put_request(fc
, req
);
527 if ((inode
->i_mode
^ arg
.attr
.mode
) & S_IFMT
) {
528 make_bad_inode(inode
);
531 struct fuse_inode
*fi
= get_fuse_inode(inode
);
532 fuse_change_attributes(inode
, &arg
.attr
);
533 fi
->i_time
= time_to_jiffies(arg
.attr_valid
,
534 arg
.attr_valid_nsec
);
541 * Calling into a user-controlled filesystem gives the filesystem
542 * daemon ptrace-like capabilities over the requester process. This
543 * means, that the filesystem daemon is able to record the exact
544 * filesystem operations performed, and can also control the behavior
545 * of the requester process in otherwise impossible ways. For example
546 * it can delay the operation for arbitrary length of time allowing
547 * DoS against the requester.
549 * For this reason only those processes can call into the filesystem,
550 * for which the owner of the mount has ptrace privilege. This
551 * excludes processes started by other users, suid or sgid processes.
553 static int fuse_allow_task(struct fuse_conn
*fc
, struct task_struct
*task
)
555 if (fc
->flags
& FUSE_ALLOW_OTHER
)
558 if (task
->euid
== fc
->user_id
&&
559 task
->suid
== fc
->user_id
&&
560 task
->uid
== fc
->user_id
&&
561 task
->egid
== fc
->group_id
&&
562 task
->sgid
== fc
->group_id
&&
563 task
->gid
== fc
->group_id
)
569 static int fuse_revalidate(struct dentry
*entry
)
571 struct inode
*inode
= entry
->d_inode
;
572 struct fuse_inode
*fi
= get_fuse_inode(inode
);
573 struct fuse_conn
*fc
= get_fuse_conn(inode
);
575 if (!fuse_allow_task(fc
, current
))
577 if (get_node_id(inode
) != FUSE_ROOT_ID
&&
578 time_before_eq(jiffies
, fi
->i_time
))
581 return fuse_do_getattr(inode
);
584 static int fuse_access(struct inode
*inode
, int mask
)
586 struct fuse_conn
*fc
= get_fuse_conn(inode
);
587 struct fuse_req
*req
;
588 struct fuse_access_in inarg
;
594 req
= fuse_get_request(fc
);
598 memset(&inarg
, 0, sizeof(inarg
));
600 req
->in
.h
.opcode
= FUSE_ACCESS
;
601 req
->in
.h
.nodeid
= get_node_id(inode
);
604 req
->in
.args
[0].size
= sizeof(inarg
);
605 req
->in
.args
[0].value
= &inarg
;
606 request_send(fc
, req
);
607 err
= req
->out
.h
.error
;
608 fuse_put_request(fc
, req
);
609 if (err
== -ENOSYS
) {
616 static int fuse_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
618 struct fuse_conn
*fc
= get_fuse_conn(inode
);
620 if (!fuse_allow_task(fc
, current
))
622 else if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
623 int err
= generic_permission(inode
, mask
, NULL
);
625 /* If permission is denied, try to refresh file
626 attributes. This is also needed, because the root
627 node will at first have no permissions */
628 if (err
== -EACCES
) {
629 err
= fuse_do_getattr(inode
);
631 err
= generic_permission(inode
, mask
, NULL
);
634 /* FIXME: Need some mechanism to revoke permissions:
635 currently if the filesystem suddenly changes the
636 file mode, we will not be informed about it, and
637 continue to allow access to the file/directory.
639 This is actually not so grave, since the user can
640 simply keep access to the file/directory anyway by
641 keeping it open... */
645 int mode
= inode
->i_mode
;
646 if ((mask
& MAY_EXEC
) && !S_ISDIR(mode
) && !(mode
& S_IXUGO
))
649 if (nd
&& (nd
->flags
& LOOKUP_ACCESS
))
650 return fuse_access(inode
, mask
);
655 static int parse_dirfile(char *buf
, size_t nbytes
, struct file
*file
,
656 void *dstbuf
, filldir_t filldir
)
658 while (nbytes
>= FUSE_NAME_OFFSET
) {
659 struct fuse_dirent
*dirent
= (struct fuse_dirent
*) buf
;
660 size_t reclen
= FUSE_DIRENT_SIZE(dirent
);
662 if (!dirent
->namelen
|| dirent
->namelen
> FUSE_NAME_MAX
)
667 over
= filldir(dstbuf
, dirent
->name
, dirent
->namelen
,
668 file
->f_pos
, dirent
->ino
, dirent
->type
);
674 file
->f_pos
= dirent
->off
;
680 static inline size_t fuse_send_readdir(struct fuse_req
*req
, struct file
*file
,
681 struct inode
*inode
, loff_t pos
,
684 return fuse_send_read_common(req
, file
, inode
, pos
, count
, 1);
687 static int fuse_readdir(struct file
*file
, void *dstbuf
, filldir_t filldir
)
692 struct inode
*inode
= file
->f_dentry
->d_inode
;
693 struct fuse_conn
*fc
= get_fuse_conn(inode
);
694 struct fuse_req
*req
= fuse_get_request(fc
);
698 page
= alloc_page(GFP_KERNEL
);
700 fuse_put_request(fc
, req
);
704 req
->pages
[0] = page
;
705 nbytes
= fuse_send_readdir(req
, file
, inode
, file
->f_pos
, PAGE_SIZE
);
706 err
= req
->out
.h
.error
;
707 fuse_put_request(fc
, req
);
709 err
= parse_dirfile(page_address(page
), nbytes
, file
, dstbuf
,
713 fuse_invalidate_attr(inode
); /* atime changed */
717 static char *read_link(struct dentry
*dentry
)
719 struct inode
*inode
= dentry
->d_inode
;
720 struct fuse_conn
*fc
= get_fuse_conn(inode
);
721 struct fuse_req
*req
= fuse_get_request(fc
);
725 return ERR_PTR(-EINTR
);
727 link
= (char *) __get_free_page(GFP_KERNEL
);
729 link
= ERR_PTR(-ENOMEM
);
732 req
->in
.h
.opcode
= FUSE_READLINK
;
733 req
->in
.h
.nodeid
= get_node_id(inode
);
736 req
->out
.numargs
= 1;
737 req
->out
.args
[0].size
= PAGE_SIZE
- 1;
738 req
->out
.args
[0].value
= link
;
739 request_send(fc
, req
);
740 if (req
->out
.h
.error
) {
741 free_page((unsigned long) link
);
742 link
= ERR_PTR(req
->out
.h
.error
);
744 link
[req
->out
.args
[0].size
] = '\0';
746 fuse_put_request(fc
, req
);
747 fuse_invalidate_attr(inode
); /* atime changed */
751 static void free_link(char *link
)
754 free_page((unsigned long) link
);
757 static void *fuse_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
759 nd_set_link(nd
, read_link(dentry
));
763 static void fuse_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *c
)
765 free_link(nd_get_link(nd
));
768 static int fuse_dir_open(struct inode
*inode
, struct file
*file
)
770 return fuse_open_common(inode
, file
, 1);
773 static int fuse_dir_release(struct inode
*inode
, struct file
*file
)
775 return fuse_release_common(inode
, file
, 1);
778 static int fuse_dir_fsync(struct file
*file
, struct dentry
*de
, int datasync
)
780 /* nfsd can call this with no file */
781 return file
? fuse_fsync_common(file
, de
, datasync
, 1) : 0;
784 static void iattr_to_fattr(struct iattr
*iattr
, struct fuse_setattr_in
*arg
)
786 unsigned ivalid
= iattr
->ia_valid
;
788 if (ivalid
& ATTR_MODE
)
789 arg
->valid
|= FATTR_MODE
, arg
->mode
= iattr
->ia_mode
;
790 if (ivalid
& ATTR_UID
)
791 arg
->valid
|= FATTR_UID
, arg
->uid
= iattr
->ia_uid
;
792 if (ivalid
& ATTR_GID
)
793 arg
->valid
|= FATTR_GID
, arg
->gid
= iattr
->ia_gid
;
794 if (ivalid
& ATTR_SIZE
)
795 arg
->valid
|= FATTR_SIZE
, arg
->size
= iattr
->ia_size
;
796 /* You can only _set_ these together (they may change by themselves) */
797 if ((ivalid
& (ATTR_ATIME
| ATTR_MTIME
)) == (ATTR_ATIME
| ATTR_MTIME
)) {
798 arg
->valid
|= FATTR_ATIME
| FATTR_MTIME
;
799 arg
->atime
= iattr
->ia_atime
.tv_sec
;
800 arg
->mtime
= iattr
->ia_mtime
.tv_sec
;
802 if (ivalid
& ATTR_FILE
) {
803 struct fuse_file
*ff
= iattr
->ia_file
->private_data
;
804 arg
->valid
|= FATTR_FH
;
809 static int fuse_setattr(struct dentry
*entry
, struct iattr
*attr
)
811 struct inode
*inode
= entry
->d_inode
;
812 struct fuse_conn
*fc
= get_fuse_conn(inode
);
813 struct fuse_inode
*fi
= get_fuse_inode(inode
);
814 struct fuse_req
*req
;
815 struct fuse_setattr_in inarg
;
816 struct fuse_attr_out outarg
;
820 if (fc
->flags
& FUSE_DEFAULT_PERMISSIONS
) {
821 err
= inode_change_ok(inode
, attr
);
826 if (attr
->ia_valid
& ATTR_SIZE
) {
829 limit
= current
->signal
->rlim
[RLIMIT_FSIZE
].rlim_cur
;
830 if (limit
!= RLIM_INFINITY
&& attr
->ia_size
> (loff_t
) limit
) {
831 send_sig(SIGXFSZ
, current
, 0);
836 req
= fuse_get_request(fc
);
840 memset(&inarg
, 0, sizeof(inarg
));
841 iattr_to_fattr(attr
, &inarg
);
842 req
->in
.h
.opcode
= FUSE_SETATTR
;
843 req
->in
.h
.nodeid
= get_node_id(inode
);
846 req
->in
.args
[0].size
= sizeof(inarg
);
847 req
->in
.args
[0].value
= &inarg
;
848 req
->out
.numargs
= 1;
849 req
->out
.args
[0].size
= sizeof(outarg
);
850 req
->out
.args
[0].value
= &outarg
;
851 request_send(fc
, req
);
852 err
= req
->out
.h
.error
;
853 fuse_put_request(fc
, req
);
855 if ((inode
->i_mode
^ outarg
.attr
.mode
) & S_IFMT
) {
856 make_bad_inode(inode
);
860 loff_t origsize
= i_size_read(inode
);
861 i_size_write(inode
, outarg
.attr
.size
);
862 if (origsize
> outarg
.attr
.size
)
863 vmtruncate(inode
, outarg
.attr
.size
);
865 fuse_change_attributes(inode
, &outarg
.attr
);
866 fi
->i_time
= time_to_jiffies(outarg
.attr_valid
,
867 outarg
.attr_valid_nsec
);
869 } else if (err
== -EINTR
)
870 fuse_invalidate_attr(inode
);
875 static int fuse_getattr(struct vfsmount
*mnt
, struct dentry
*entry
,
878 struct inode
*inode
= entry
->d_inode
;
879 int err
= fuse_revalidate(entry
);
881 generic_fillattr(inode
, stat
);
886 static struct dentry
*fuse_lookup(struct inode
*dir
, struct dentry
*entry
,
887 struct nameidata
*nd
)
892 err
= fuse_lookup_iget(dir
, entry
, &inode
);
895 if (inode
&& dir_alias(inode
)) {
897 return ERR_PTR(-EIO
);
903 static int fuse_setxattr(struct dentry
*entry
, const char *name
,
904 const void *value
, size_t size
, int flags
)
906 struct inode
*inode
= entry
->d_inode
;
907 struct fuse_conn
*fc
= get_fuse_conn(inode
);
908 struct fuse_req
*req
;
909 struct fuse_setxattr_in inarg
;
912 if (size
> FUSE_XATTR_SIZE_MAX
)
918 req
= fuse_get_request(fc
);
922 memset(&inarg
, 0, sizeof(inarg
));
925 req
->in
.h
.opcode
= FUSE_SETXATTR
;
926 req
->in
.h
.nodeid
= get_node_id(inode
);
929 req
->in
.args
[0].size
= sizeof(inarg
);
930 req
->in
.args
[0].value
= &inarg
;
931 req
->in
.args
[1].size
= strlen(name
) + 1;
932 req
->in
.args
[1].value
= name
;
933 req
->in
.args
[2].size
= size
;
934 req
->in
.args
[2].value
= value
;
935 request_send(fc
, req
);
936 err
= req
->out
.h
.error
;
937 fuse_put_request(fc
, req
);
938 if (err
== -ENOSYS
) {
945 static ssize_t
fuse_getxattr(struct dentry
*entry
, const char *name
,
946 void *value
, size_t size
)
948 struct inode
*inode
= entry
->d_inode
;
949 struct fuse_conn
*fc
= get_fuse_conn(inode
);
950 struct fuse_req
*req
;
951 struct fuse_getxattr_in inarg
;
952 struct fuse_getxattr_out outarg
;
958 req
= fuse_get_request(fc
);
962 memset(&inarg
, 0, sizeof(inarg
));
964 req
->in
.h
.opcode
= FUSE_GETXATTR
;
965 req
->in
.h
.nodeid
= get_node_id(inode
);
968 req
->in
.args
[0].size
= sizeof(inarg
);
969 req
->in
.args
[0].value
= &inarg
;
970 req
->in
.args
[1].size
= strlen(name
) + 1;
971 req
->in
.args
[1].value
= name
;
972 /* This is really two different operations rolled into one */
973 req
->out
.numargs
= 1;
976 req
->out
.args
[0].size
= size
;
977 req
->out
.args
[0].value
= value
;
979 req
->out
.args
[0].size
= sizeof(outarg
);
980 req
->out
.args
[0].value
= &outarg
;
982 request_send(fc
, req
);
983 ret
= req
->out
.h
.error
;
985 ret
= size
? req
->out
.args
[0].size
: outarg
.size
;
987 if (ret
== -ENOSYS
) {
992 fuse_put_request(fc
, req
);
996 static ssize_t
fuse_listxattr(struct dentry
*entry
, char *list
, size_t size
)
998 struct inode
*inode
= entry
->d_inode
;
999 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1000 struct fuse_req
*req
;
1001 struct fuse_getxattr_in inarg
;
1002 struct fuse_getxattr_out outarg
;
1005 if (fc
->no_listxattr
)
1008 req
= fuse_get_request(fc
);
1012 memset(&inarg
, 0, sizeof(inarg
));
1014 req
->in
.h
.opcode
= FUSE_LISTXATTR
;
1015 req
->in
.h
.nodeid
= get_node_id(inode
);
1017 req
->in
.numargs
= 1;
1018 req
->in
.args
[0].size
= sizeof(inarg
);
1019 req
->in
.args
[0].value
= &inarg
;
1020 /* This is really two different operations rolled into one */
1021 req
->out
.numargs
= 1;
1023 req
->out
.argvar
= 1;
1024 req
->out
.args
[0].size
= size
;
1025 req
->out
.args
[0].value
= list
;
1027 req
->out
.args
[0].size
= sizeof(outarg
);
1028 req
->out
.args
[0].value
= &outarg
;
1030 request_send(fc
, req
);
1031 ret
= req
->out
.h
.error
;
1033 ret
= size
? req
->out
.args
[0].size
: outarg
.size
;
1035 if (ret
== -ENOSYS
) {
1036 fc
->no_listxattr
= 1;
1040 fuse_put_request(fc
, req
);
1044 static int fuse_removexattr(struct dentry
*entry
, const char *name
)
1046 struct inode
*inode
= entry
->d_inode
;
1047 struct fuse_conn
*fc
= get_fuse_conn(inode
);
1048 struct fuse_req
*req
;
1051 if (fc
->no_removexattr
)
1054 req
= fuse_get_request(fc
);
1058 req
->in
.h
.opcode
= FUSE_REMOVEXATTR
;
1059 req
->in
.h
.nodeid
= get_node_id(inode
);
1061 req
->in
.numargs
= 1;
1062 req
->in
.args
[0].size
= strlen(name
) + 1;
1063 req
->in
.args
[0].value
= name
;
1064 request_send(fc
, req
);
1065 err
= req
->out
.h
.error
;
1066 fuse_put_request(fc
, req
);
1067 if (err
== -ENOSYS
) {
1068 fc
->no_removexattr
= 1;
1074 static struct inode_operations fuse_dir_inode_operations
= {
1075 .lookup
= fuse_lookup
,
1076 .mkdir
= fuse_mkdir
,
1077 .symlink
= fuse_symlink
,
1078 .unlink
= fuse_unlink
,
1079 .rmdir
= fuse_rmdir
,
1080 .rename
= fuse_rename
,
1082 .setattr
= fuse_setattr
,
1083 .create
= fuse_create
,
1084 .mknod
= fuse_mknod
,
1085 .permission
= fuse_permission
,
1086 .getattr
= fuse_getattr
,
1087 .setxattr
= fuse_setxattr
,
1088 .getxattr
= fuse_getxattr
,
1089 .listxattr
= fuse_listxattr
,
1090 .removexattr
= fuse_removexattr
,
1093 static struct file_operations fuse_dir_operations
= {
1094 .llseek
= generic_file_llseek
,
1095 .read
= generic_read_dir
,
1096 .readdir
= fuse_readdir
,
1097 .open
= fuse_dir_open
,
1098 .release
= fuse_dir_release
,
1099 .fsync
= fuse_dir_fsync
,
1102 static struct inode_operations fuse_common_inode_operations
= {
1103 .setattr
= fuse_setattr
,
1104 .permission
= fuse_permission
,
1105 .getattr
= fuse_getattr
,
1106 .setxattr
= fuse_setxattr
,
1107 .getxattr
= fuse_getxattr
,
1108 .listxattr
= fuse_listxattr
,
1109 .removexattr
= fuse_removexattr
,
1112 static struct inode_operations fuse_symlink_inode_operations
= {
1113 .setattr
= fuse_setattr
,
1114 .follow_link
= fuse_follow_link
,
1115 .put_link
= fuse_put_link
,
1116 .readlink
= generic_readlink
,
1117 .getattr
= fuse_getattr
,
1118 .setxattr
= fuse_setxattr
,
1119 .getxattr
= fuse_getxattr
,
1120 .listxattr
= fuse_listxattr
,
1121 .removexattr
= fuse_removexattr
,
1124 void fuse_init_common(struct inode
*inode
)
1126 inode
->i_op
= &fuse_common_inode_operations
;
1129 void fuse_init_dir(struct inode
*inode
)
1131 inode
->i_op
= &fuse_dir_inode_operations
;
1132 inode
->i_fop
= &fuse_dir_operations
;
1135 void fuse_init_symlink(struct inode
*inode
)
1137 inode
->i_op
= &fuse_symlink_inode_operations
;