]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - fs/fuse/dir.c
Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/x86
[mirror_ubuntu-zesty-kernel.git] / fs / fuse / dir.c
1 /*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2005 Miklos Szeredi <miklos@szeredi.hu>
4
5 This program can be distributed under the terms of the GNU GPL.
6 See the file COPYING.
7 */
8
9 #include "fuse_i.h"
10
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
17 /*
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.
21 */
22
23 /*
24 * Calculate the time in jiffies until a dentry/attributes are valid
25 */
26 static unsigned long time_to_jiffies(unsigned long sec, unsigned long nsec)
27 {
28 struct timespec ts = {sec, nsec};
29 return jiffies + timespec_to_jiffies(&ts);
30 }
31
32 /*
33 * Set dentry and possibly attribute timeouts from the lookup/mk*
34 * replies
35 */
36 static void fuse_change_timeout(struct dentry *entry, struct fuse_entry_out *o)
37 {
38 entry->d_time = time_to_jiffies(o->entry_valid, o->entry_valid_nsec);
39 if (entry->d_inode)
40 get_fuse_inode(entry->d_inode)->i_time =
41 time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
42 }
43
44 /*
45 * Mark the attributes as stale, so that at the next call to
46 * ->getattr() they will be fetched from userspace
47 */
48 void fuse_invalidate_attr(struct inode *inode)
49 {
50 get_fuse_inode(inode)->i_time = jiffies - 1;
51 }
52
53 /*
54 * Just mark the entry as stale, so that a next attempt to look it up
55 * will result in a new lookup call to userspace
56 *
57 * This is called when a dentry is about to become negative and the
58 * timeout is unknown (unlink, rmdir, rename and in some cases
59 * lookup)
60 */
61 static void fuse_invalidate_entry_cache(struct dentry *entry)
62 {
63 entry->d_time = jiffies - 1;
64 }
65
66 /*
67 * Same as fuse_invalidate_entry_cache(), but also try to remove the
68 * dentry from the hash
69 */
70 static void fuse_invalidate_entry(struct dentry *entry)
71 {
72 d_invalidate(entry);
73 fuse_invalidate_entry_cache(entry);
74 }
75
76 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
77 struct dentry *entry,
78 struct fuse_entry_out *outarg)
79 {
80 req->in.h.opcode = FUSE_LOOKUP;
81 req->in.h.nodeid = get_node_id(dir);
82 req->inode = dir;
83 req->in.numargs = 1;
84 req->in.args[0].size = entry->d_name.len + 1;
85 req->in.args[0].value = entry->d_name.name;
86 req->out.numargs = 1;
87 req->out.args[0].size = sizeof(struct fuse_entry_out);
88 req->out.args[0].value = outarg;
89 }
90
91 /*
92 * Check whether the dentry is still valid
93 *
94 * If the entry validity timeout has expired and the dentry is
95 * positive, try to redo the lookup. If the lookup results in a
96 * different inode, then let the VFS invalidate the dentry and redo
97 * the lookup once more. If the lookup results in the same inode,
98 * then refresh the attributes, timeouts and mark the dentry valid.
99 */
100 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
101 {
102 struct inode *inode = entry->d_inode;
103
104 if (inode && is_bad_inode(inode))
105 return 0;
106 else if (time_after(jiffies, entry->d_time)) {
107 int err;
108 struct fuse_entry_out outarg;
109 struct fuse_conn *fc;
110 struct fuse_req *req;
111
112 /* Doesn't hurt to "reset" the validity timeout */
113 fuse_invalidate_entry_cache(entry);
114 if (!inode)
115 return 0;
116
117 fc = get_fuse_conn(inode);
118 req = fuse_get_request(fc);
119 if (!req)
120 return 0;
121
122 fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
123 request_send(fc, req);
124 err = req->out.h.error;
125 if (!err) {
126 struct fuse_inode *fi = get_fuse_inode(inode);
127 if (outarg.nodeid != get_node_id(inode)) {
128 fuse_send_forget(fc, req, outarg.nodeid, 1);
129 return 0;
130 }
131 fi->nlookup ++;
132 }
133 fuse_put_request(fc, req);
134 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
135 return 0;
136
137 fuse_change_attributes(inode, &outarg.attr);
138 fuse_change_timeout(entry, &outarg);
139 }
140 return 1;
141 }
142
143 /*
144 * Check if there's already a hashed alias of this directory inode.
145 * If yes, then lookup and mkdir must not create a new alias.
146 */
147 static int dir_alias(struct inode *inode)
148 {
149 if (S_ISDIR(inode->i_mode)) {
150 struct dentry *alias = d_find_alias(inode);
151 if (alias) {
152 dput(alias);
153 return 1;
154 }
155 }
156 return 0;
157 }
158
159 static int invalid_nodeid(u64 nodeid)
160 {
161 return !nodeid || nodeid == FUSE_ROOT_ID;
162 }
163
164 static struct dentry_operations fuse_dentry_operations = {
165 .d_revalidate = fuse_dentry_revalidate,
166 };
167
168 static int valid_mode(int m)
169 {
170 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
171 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
172 }
173
174 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
175 struct nameidata *nd)
176 {
177 int err;
178 struct fuse_entry_out outarg;
179 struct inode *inode = NULL;
180 struct fuse_conn *fc = get_fuse_conn(dir);
181 struct fuse_req *req;
182
183 if (entry->d_name.len > FUSE_NAME_MAX)
184 return ERR_PTR(-ENAMETOOLONG);
185
186 req = fuse_get_request(fc);
187 if (!req)
188 return ERR_PTR(-EINTR);
189
190 fuse_lookup_init(req, dir, entry, &outarg);
191 request_send(fc, req);
192 err = req->out.h.error;
193 if (!err && ((outarg.nodeid && invalid_nodeid(outarg.nodeid)) ||
194 !valid_mode(outarg.attr.mode)))
195 err = -EIO;
196 if (!err && outarg.nodeid) {
197 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
198 &outarg.attr);
199 if (!inode) {
200 fuse_send_forget(fc, req, outarg.nodeid, 1);
201 return ERR_PTR(-ENOMEM);
202 }
203 }
204 fuse_put_request(fc, req);
205 if (err && err != -ENOENT)
206 return ERR_PTR(err);
207
208 if (inode && dir_alias(inode)) {
209 iput(inode);
210 return ERR_PTR(-EIO);
211 }
212 d_add(entry, inode);
213 entry->d_op = &fuse_dentry_operations;
214 if (!err)
215 fuse_change_timeout(entry, &outarg);
216 else
217 fuse_invalidate_entry_cache(entry);
218 return NULL;
219 }
220
221 /*
222 * Atomic create+open operation
223 *
224 * If the filesystem doesn't support this, then fall back to separate
225 * 'mknod' + 'open' requests.
226 */
227 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
228 struct nameidata *nd)
229 {
230 int err;
231 struct inode *inode;
232 struct fuse_conn *fc = get_fuse_conn(dir);
233 struct fuse_req *req;
234 struct fuse_open_in inarg;
235 struct fuse_open_out outopen;
236 struct fuse_entry_out outentry;
237 struct fuse_file *ff;
238 struct file *file;
239 int flags = nd->intent.open.flags - 1;
240
241 err = -ENOSYS;
242 if (fc->no_create)
243 goto out;
244
245 err = -EINTR;
246 req = fuse_get_request(fc);
247 if (!req)
248 goto out;
249
250 ff = fuse_file_alloc();
251 if (!ff)
252 goto out_put_request;
253
254 flags &= ~O_NOCTTY;
255 memset(&inarg, 0, sizeof(inarg));
256 inarg.flags = flags;
257 inarg.mode = mode;
258 req->in.h.opcode = FUSE_CREATE;
259 req->in.h.nodeid = get_node_id(dir);
260 req->inode = dir;
261 req->in.numargs = 2;
262 req->in.args[0].size = sizeof(inarg);
263 req->in.args[0].value = &inarg;
264 req->in.args[1].size = entry->d_name.len + 1;
265 req->in.args[1].value = entry->d_name.name;
266 req->out.numargs = 2;
267 req->out.args[0].size = sizeof(outentry);
268 req->out.args[0].value = &outentry;
269 req->out.args[1].size = sizeof(outopen);
270 req->out.args[1].value = &outopen;
271 request_send(fc, req);
272 err = req->out.h.error;
273 if (err) {
274 if (err == -ENOSYS)
275 fc->no_create = 1;
276 goto out_free_ff;
277 }
278
279 err = -EIO;
280 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
281 goto out_free_ff;
282
283 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
284 &outentry.attr);
285 err = -ENOMEM;
286 if (!inode) {
287 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
288 ff->fh = outopen.fh;
289 /* Special release, with inode = NULL, this will
290 trigger a 'forget' request when the release is
291 complete */
292 fuse_send_release(fc, ff, outentry.nodeid, NULL, flags, 0);
293 goto out_put_request;
294 }
295 fuse_put_request(fc, req);
296 d_instantiate(entry, inode);
297 fuse_change_timeout(entry, &outentry);
298 file = lookup_instantiate_filp(nd, entry, generic_file_open);
299 if (IS_ERR(file)) {
300 ff->fh = outopen.fh;
301 fuse_send_release(fc, ff, outentry.nodeid, inode, flags, 0);
302 return PTR_ERR(file);
303 }
304 fuse_finish_open(inode, file, ff, &outopen);
305 return 0;
306
307 out_free_ff:
308 fuse_file_free(ff);
309 out_put_request:
310 fuse_put_request(fc, req);
311 out:
312 return err;
313 }
314
315 /*
316 * Code shared between mknod, mkdir, symlink and link
317 */
318 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
319 struct inode *dir, struct dentry *entry,
320 int mode)
321 {
322 struct fuse_entry_out outarg;
323 struct inode *inode;
324 int err;
325
326 req->in.h.nodeid = get_node_id(dir);
327 req->inode = dir;
328 req->out.numargs = 1;
329 req->out.args[0].size = sizeof(outarg);
330 req->out.args[0].value = &outarg;
331 request_send(fc, req);
332 err = req->out.h.error;
333 if (err) {
334 fuse_put_request(fc, req);
335 return err;
336 }
337 err = -EIO;
338 if (invalid_nodeid(outarg.nodeid))
339 goto out_put_request;
340
341 if ((outarg.attr.mode ^ mode) & S_IFMT)
342 goto out_put_request;
343
344 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
345 &outarg.attr);
346 if (!inode) {
347 fuse_send_forget(fc, req, outarg.nodeid, 1);
348 return -ENOMEM;
349 }
350 fuse_put_request(fc, req);
351
352 if (dir_alias(inode)) {
353 iput(inode);
354 return -EIO;
355 }
356
357 d_instantiate(entry, inode);
358 fuse_change_timeout(entry, &outarg);
359 fuse_invalidate_attr(dir);
360 return 0;
361
362 out_put_request:
363 fuse_put_request(fc, req);
364 return err;
365 }
366
367 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
368 dev_t rdev)
369 {
370 struct fuse_mknod_in inarg;
371 struct fuse_conn *fc = get_fuse_conn(dir);
372 struct fuse_req *req = fuse_get_request(fc);
373 if (!req)
374 return -EINTR;
375
376 memset(&inarg, 0, sizeof(inarg));
377 inarg.mode = mode;
378 inarg.rdev = new_encode_dev(rdev);
379 req->in.h.opcode = FUSE_MKNOD;
380 req->in.numargs = 2;
381 req->in.args[0].size = sizeof(inarg);
382 req->in.args[0].value = &inarg;
383 req->in.args[1].size = entry->d_name.len + 1;
384 req->in.args[1].value = entry->d_name.name;
385 return create_new_entry(fc, req, dir, entry, mode);
386 }
387
388 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
389 struct nameidata *nd)
390 {
391 if (nd && (nd->flags & LOOKUP_CREATE)) {
392 int err = fuse_create_open(dir, entry, mode, nd);
393 if (err != -ENOSYS)
394 return err;
395 /* Fall back on mknod */
396 }
397 return fuse_mknod(dir, entry, mode, 0);
398 }
399
400 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
401 {
402 struct fuse_mkdir_in inarg;
403 struct fuse_conn *fc = get_fuse_conn(dir);
404 struct fuse_req *req = fuse_get_request(fc);
405 if (!req)
406 return -EINTR;
407
408 memset(&inarg, 0, sizeof(inarg));
409 inarg.mode = mode;
410 req->in.h.opcode = FUSE_MKDIR;
411 req->in.numargs = 2;
412 req->in.args[0].size = sizeof(inarg);
413 req->in.args[0].value = &inarg;
414 req->in.args[1].size = entry->d_name.len + 1;
415 req->in.args[1].value = entry->d_name.name;
416 return create_new_entry(fc, req, dir, entry, S_IFDIR);
417 }
418
419 static int fuse_symlink(struct inode *dir, struct dentry *entry,
420 const char *link)
421 {
422 struct fuse_conn *fc = get_fuse_conn(dir);
423 unsigned len = strlen(link) + 1;
424 struct fuse_req *req = fuse_get_request(fc);
425 if (!req)
426 return -EINTR;
427
428 req->in.h.opcode = FUSE_SYMLINK;
429 req->in.numargs = 2;
430 req->in.args[0].size = entry->d_name.len + 1;
431 req->in.args[0].value = entry->d_name.name;
432 req->in.args[1].size = len;
433 req->in.args[1].value = link;
434 return create_new_entry(fc, req, dir, entry, S_IFLNK);
435 }
436
437 static int fuse_unlink(struct inode *dir, struct dentry *entry)
438 {
439 int err;
440 struct fuse_conn *fc = get_fuse_conn(dir);
441 struct fuse_req *req = fuse_get_request(fc);
442 if (!req)
443 return -EINTR;
444
445 req->in.h.opcode = FUSE_UNLINK;
446 req->in.h.nodeid = get_node_id(dir);
447 req->inode = dir;
448 req->in.numargs = 1;
449 req->in.args[0].size = entry->d_name.len + 1;
450 req->in.args[0].value = entry->d_name.name;
451 request_send(fc, req);
452 err = req->out.h.error;
453 fuse_put_request(fc, req);
454 if (!err) {
455 struct inode *inode = entry->d_inode;
456
457 /* Set nlink to zero so the inode can be cleared, if
458 the inode does have more links this will be
459 discovered at the next lookup/getattr */
460 inode->i_nlink = 0;
461 fuse_invalidate_attr(inode);
462 fuse_invalidate_attr(dir);
463 fuse_invalidate_entry_cache(entry);
464 } else if (err == -EINTR)
465 fuse_invalidate_entry(entry);
466 return err;
467 }
468
469 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
470 {
471 int err;
472 struct fuse_conn *fc = get_fuse_conn(dir);
473 struct fuse_req *req = fuse_get_request(fc);
474 if (!req)
475 return -EINTR;
476
477 req->in.h.opcode = FUSE_RMDIR;
478 req->in.h.nodeid = get_node_id(dir);
479 req->inode = dir;
480 req->in.numargs = 1;
481 req->in.args[0].size = entry->d_name.len + 1;
482 req->in.args[0].value = entry->d_name.name;
483 request_send(fc, req);
484 err = req->out.h.error;
485 fuse_put_request(fc, req);
486 if (!err) {
487 entry->d_inode->i_nlink = 0;
488 fuse_invalidate_attr(dir);
489 fuse_invalidate_entry_cache(entry);
490 } else if (err == -EINTR)
491 fuse_invalidate_entry(entry);
492 return err;
493 }
494
495 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
496 struct inode *newdir, struct dentry *newent)
497 {
498 int err;
499 struct fuse_rename_in inarg;
500 struct fuse_conn *fc = get_fuse_conn(olddir);
501 struct fuse_req *req = fuse_get_request(fc);
502 if (!req)
503 return -EINTR;
504
505 memset(&inarg, 0, sizeof(inarg));
506 inarg.newdir = get_node_id(newdir);
507 req->in.h.opcode = FUSE_RENAME;
508 req->in.h.nodeid = get_node_id(olddir);
509 req->inode = olddir;
510 req->inode2 = newdir;
511 req->in.numargs = 3;
512 req->in.args[0].size = sizeof(inarg);
513 req->in.args[0].value = &inarg;
514 req->in.args[1].size = oldent->d_name.len + 1;
515 req->in.args[1].value = oldent->d_name.name;
516 req->in.args[2].size = newent->d_name.len + 1;
517 req->in.args[2].value = newent->d_name.name;
518 request_send(fc, req);
519 err = req->out.h.error;
520 fuse_put_request(fc, req);
521 if (!err) {
522 fuse_invalidate_attr(olddir);
523 if (olddir != newdir)
524 fuse_invalidate_attr(newdir);
525
526 /* newent will end up negative */
527 if (newent->d_inode)
528 fuse_invalidate_entry_cache(newent);
529 } else if (err == -EINTR) {
530 /* If request was interrupted, DEITY only knows if the
531 rename actually took place. If the invalidation
532 fails (e.g. some process has CWD under the renamed
533 directory), then there can be inconsistency between
534 the dcache and the real filesystem. Tough luck. */
535 fuse_invalidate_entry(oldent);
536 if (newent->d_inode)
537 fuse_invalidate_entry(newent);
538 }
539
540 return err;
541 }
542
543 static int fuse_link(struct dentry *entry, struct inode *newdir,
544 struct dentry *newent)
545 {
546 int err;
547 struct fuse_link_in inarg;
548 struct inode *inode = entry->d_inode;
549 struct fuse_conn *fc = get_fuse_conn(inode);
550 struct fuse_req *req = fuse_get_request(fc);
551 if (!req)
552 return -EINTR;
553
554 memset(&inarg, 0, sizeof(inarg));
555 inarg.oldnodeid = get_node_id(inode);
556 req->in.h.opcode = FUSE_LINK;
557 req->inode2 = inode;
558 req->in.numargs = 2;
559 req->in.args[0].size = sizeof(inarg);
560 req->in.args[0].value = &inarg;
561 req->in.args[1].size = newent->d_name.len + 1;
562 req->in.args[1].value = newent->d_name.name;
563 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
564 /* Contrary to "normal" filesystems it can happen that link
565 makes two "logical" inodes point to the same "physical"
566 inode. We invalidate the attributes of the old one, so it
567 will reflect changes in the backing inode (link count,
568 etc.)
569 */
570 if (!err || err == -EINTR)
571 fuse_invalidate_attr(inode);
572 return err;
573 }
574
575 int fuse_do_getattr(struct inode *inode)
576 {
577 int err;
578 struct fuse_attr_out arg;
579 struct fuse_conn *fc = get_fuse_conn(inode);
580 struct fuse_req *req = fuse_get_request(fc);
581 if (!req)
582 return -EINTR;
583
584 req->in.h.opcode = FUSE_GETATTR;
585 req->in.h.nodeid = get_node_id(inode);
586 req->inode = inode;
587 req->out.numargs = 1;
588 req->out.args[0].size = sizeof(arg);
589 req->out.args[0].value = &arg;
590 request_send(fc, req);
591 err = req->out.h.error;
592 fuse_put_request(fc, req);
593 if (!err) {
594 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
595 make_bad_inode(inode);
596 err = -EIO;
597 } else {
598 struct fuse_inode *fi = get_fuse_inode(inode);
599 fuse_change_attributes(inode, &arg.attr);
600 fi->i_time = time_to_jiffies(arg.attr_valid,
601 arg.attr_valid_nsec);
602 }
603 }
604 return err;
605 }
606
607 /*
608 * Calling into a user-controlled filesystem gives the filesystem
609 * daemon ptrace-like capabilities over the requester process. This
610 * means, that the filesystem daemon is able to record the exact
611 * filesystem operations performed, and can also control the behavior
612 * of the requester process in otherwise impossible ways. For example
613 * it can delay the operation for arbitrary length of time allowing
614 * DoS against the requester.
615 *
616 * For this reason only those processes can call into the filesystem,
617 * for which the owner of the mount has ptrace privilege. This
618 * excludes processes started by other users, suid or sgid processes.
619 */
620 static int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
621 {
622 if (fc->flags & FUSE_ALLOW_OTHER)
623 return 1;
624
625 if (task->euid == fc->user_id &&
626 task->suid == fc->user_id &&
627 task->uid == fc->user_id &&
628 task->egid == fc->group_id &&
629 task->sgid == fc->group_id &&
630 task->gid == fc->group_id)
631 return 1;
632
633 return 0;
634 }
635
636 /*
637 * Check whether the inode attributes are still valid
638 *
639 * If the attribute validity timeout has expired, then fetch the fresh
640 * attributes with a 'getattr' request
641 *
642 * I'm not sure why cached attributes are never returned for the root
643 * inode, this is probably being too cautious.
644 */
645 static int fuse_revalidate(struct dentry *entry)
646 {
647 struct inode *inode = entry->d_inode;
648 struct fuse_inode *fi = get_fuse_inode(inode);
649 struct fuse_conn *fc = get_fuse_conn(inode);
650
651 if (!fuse_allow_task(fc, current))
652 return -EACCES;
653 if (get_node_id(inode) != FUSE_ROOT_ID &&
654 time_before_eq(jiffies, fi->i_time))
655 return 0;
656
657 return fuse_do_getattr(inode);
658 }
659
660 static int fuse_access(struct inode *inode, int mask)
661 {
662 struct fuse_conn *fc = get_fuse_conn(inode);
663 struct fuse_req *req;
664 struct fuse_access_in inarg;
665 int err;
666
667 if (fc->no_access)
668 return 0;
669
670 req = fuse_get_request(fc);
671 if (!req)
672 return -EINTR;
673
674 memset(&inarg, 0, sizeof(inarg));
675 inarg.mask = mask;
676 req->in.h.opcode = FUSE_ACCESS;
677 req->in.h.nodeid = get_node_id(inode);
678 req->inode = inode;
679 req->in.numargs = 1;
680 req->in.args[0].size = sizeof(inarg);
681 req->in.args[0].value = &inarg;
682 request_send(fc, req);
683 err = req->out.h.error;
684 fuse_put_request(fc, req);
685 if (err == -ENOSYS) {
686 fc->no_access = 1;
687 err = 0;
688 }
689 return err;
690 }
691
692 /*
693 * Check permission. The two basic access models of FUSE are:
694 *
695 * 1) Local access checking ('default_permissions' mount option) based
696 * on file mode. This is the plain old disk filesystem permission
697 * modell.
698 *
699 * 2) "Remote" access checking, where server is responsible for
700 * checking permission in each inode operation. An exception to this
701 * is if ->permission() was invoked from sys_access() in which case an
702 * access request is sent. Execute permission is still checked
703 * locally based on file mode.
704 */
705 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
706 {
707 struct fuse_conn *fc = get_fuse_conn(inode);
708
709 if (!fuse_allow_task(fc, current))
710 return -EACCES;
711 else if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
712 int err = generic_permission(inode, mask, NULL);
713
714 /* If permission is denied, try to refresh file
715 attributes. This is also needed, because the root
716 node will at first have no permissions */
717 if (err == -EACCES) {
718 err = fuse_do_getattr(inode);
719 if (!err)
720 err = generic_permission(inode, mask, NULL);
721 }
722
723 /* Note: the opposite of the above test does not
724 exist. So if permissions are revoked this won't be
725 noticed immediately, only after the attribute
726 timeout has expired */
727
728 return err;
729 } else {
730 int mode = inode->i_mode;
731 if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
732 return -EACCES;
733
734 if (nd && (nd->flags & LOOKUP_ACCESS))
735 return fuse_access(inode, mask);
736 return 0;
737 }
738 }
739
740 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
741 void *dstbuf, filldir_t filldir)
742 {
743 while (nbytes >= FUSE_NAME_OFFSET) {
744 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
745 size_t reclen = FUSE_DIRENT_SIZE(dirent);
746 int over;
747 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
748 return -EIO;
749 if (reclen > nbytes)
750 break;
751
752 over = filldir(dstbuf, dirent->name, dirent->namelen,
753 file->f_pos, dirent->ino, dirent->type);
754 if (over)
755 break;
756
757 buf += reclen;
758 nbytes -= reclen;
759 file->f_pos = dirent->off;
760 }
761
762 return 0;
763 }
764
765 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
766 {
767 int err;
768 size_t nbytes;
769 struct page *page;
770 struct inode *inode = file->f_dentry->d_inode;
771 struct fuse_conn *fc = get_fuse_conn(inode);
772 struct fuse_req *req;
773
774 if (is_bad_inode(inode))
775 return -EIO;
776
777 req = fuse_get_request(fc);
778 if (!req)
779 return -EINTR;
780
781 page = alloc_page(GFP_KERNEL);
782 if (!page) {
783 fuse_put_request(fc, req);
784 return -ENOMEM;
785 }
786 req->num_pages = 1;
787 req->pages[0] = page;
788 fuse_read_fill(req, file, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
789 request_send(fc, req);
790 nbytes = req->out.args[0].size;
791 err = req->out.h.error;
792 fuse_put_request(fc, req);
793 if (!err)
794 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
795 filldir);
796
797 __free_page(page);
798 fuse_invalidate_attr(inode); /* atime changed */
799 return err;
800 }
801
802 static char *read_link(struct dentry *dentry)
803 {
804 struct inode *inode = dentry->d_inode;
805 struct fuse_conn *fc = get_fuse_conn(inode);
806 struct fuse_req *req = fuse_get_request(fc);
807 char *link;
808
809 if (!req)
810 return ERR_PTR(-EINTR);
811
812 link = (char *) __get_free_page(GFP_KERNEL);
813 if (!link) {
814 link = ERR_PTR(-ENOMEM);
815 goto out;
816 }
817 req->in.h.opcode = FUSE_READLINK;
818 req->in.h.nodeid = get_node_id(inode);
819 req->inode = inode;
820 req->out.argvar = 1;
821 req->out.numargs = 1;
822 req->out.args[0].size = PAGE_SIZE - 1;
823 req->out.args[0].value = link;
824 request_send(fc, req);
825 if (req->out.h.error) {
826 free_page((unsigned long) link);
827 link = ERR_PTR(req->out.h.error);
828 } else
829 link[req->out.args[0].size] = '\0';
830 out:
831 fuse_put_request(fc, req);
832 fuse_invalidate_attr(inode); /* atime changed */
833 return link;
834 }
835
836 static void free_link(char *link)
837 {
838 if (!IS_ERR(link))
839 free_page((unsigned long) link);
840 }
841
842 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
843 {
844 nd_set_link(nd, read_link(dentry));
845 return NULL;
846 }
847
848 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
849 {
850 free_link(nd_get_link(nd));
851 }
852
853 static int fuse_dir_open(struct inode *inode, struct file *file)
854 {
855 return fuse_open_common(inode, file, 1);
856 }
857
858 static int fuse_dir_release(struct inode *inode, struct file *file)
859 {
860 return fuse_release_common(inode, file, 1);
861 }
862
863 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
864 {
865 /* nfsd can call this with no file */
866 return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
867 }
868
869 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
870 {
871 unsigned ivalid = iattr->ia_valid;
872
873 if (ivalid & ATTR_MODE)
874 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
875 if (ivalid & ATTR_UID)
876 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
877 if (ivalid & ATTR_GID)
878 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
879 if (ivalid & ATTR_SIZE)
880 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
881 /* You can only _set_ these together (they may change by themselves) */
882 if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
883 arg->valid |= FATTR_ATIME | FATTR_MTIME;
884 arg->atime = iattr->ia_atime.tv_sec;
885 arg->mtime = iattr->ia_mtime.tv_sec;
886 }
887 if (ivalid & ATTR_FILE) {
888 struct fuse_file *ff = iattr->ia_file->private_data;
889 arg->valid |= FATTR_FH;
890 arg->fh = ff->fh;
891 }
892 }
893
894 /*
895 * Set attributes, and at the same time refresh them.
896 *
897 * Truncation is slightly complicated, because the 'truncate' request
898 * may fail, in which case we don't want to touch the mapping.
899 * vmtruncate() doesn't allow for this case. So do the rlimit
900 * checking by hand and call vmtruncate() only after the file has
901 * actually been truncated.
902 */
903 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
904 {
905 struct inode *inode = entry->d_inode;
906 struct fuse_conn *fc = get_fuse_conn(inode);
907 struct fuse_inode *fi = get_fuse_inode(inode);
908 struct fuse_req *req;
909 struct fuse_setattr_in inarg;
910 struct fuse_attr_out outarg;
911 int err;
912 int is_truncate = 0;
913
914 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
915 err = inode_change_ok(inode, attr);
916 if (err)
917 return err;
918 }
919
920 if (attr->ia_valid & ATTR_SIZE) {
921 unsigned long limit;
922 is_truncate = 1;
923 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
924 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
925 send_sig(SIGXFSZ, current, 0);
926 return -EFBIG;
927 }
928 }
929
930 req = fuse_get_request(fc);
931 if (!req)
932 return -EINTR;
933
934 memset(&inarg, 0, sizeof(inarg));
935 iattr_to_fattr(attr, &inarg);
936 req->in.h.opcode = FUSE_SETATTR;
937 req->in.h.nodeid = get_node_id(inode);
938 req->inode = inode;
939 req->in.numargs = 1;
940 req->in.args[0].size = sizeof(inarg);
941 req->in.args[0].value = &inarg;
942 req->out.numargs = 1;
943 req->out.args[0].size = sizeof(outarg);
944 req->out.args[0].value = &outarg;
945 request_send(fc, req);
946 err = req->out.h.error;
947 fuse_put_request(fc, req);
948 if (!err) {
949 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
950 make_bad_inode(inode);
951 err = -EIO;
952 } else {
953 if (is_truncate) {
954 loff_t origsize = i_size_read(inode);
955 i_size_write(inode, outarg.attr.size);
956 if (origsize > outarg.attr.size)
957 vmtruncate(inode, outarg.attr.size);
958 }
959 fuse_change_attributes(inode, &outarg.attr);
960 fi->i_time = time_to_jiffies(outarg.attr_valid,
961 outarg.attr_valid_nsec);
962 }
963 } else if (err == -EINTR)
964 fuse_invalidate_attr(inode);
965
966 return err;
967 }
968
969 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
970 struct kstat *stat)
971 {
972 struct inode *inode = entry->d_inode;
973 int err = fuse_revalidate(entry);
974 if (!err)
975 generic_fillattr(inode, stat);
976
977 return err;
978 }
979
980 static int fuse_setxattr(struct dentry *entry, const char *name,
981 const void *value, size_t size, int flags)
982 {
983 struct inode *inode = entry->d_inode;
984 struct fuse_conn *fc = get_fuse_conn(inode);
985 struct fuse_req *req;
986 struct fuse_setxattr_in inarg;
987 int err;
988
989 if (fc->no_setxattr)
990 return -EOPNOTSUPP;
991
992 req = fuse_get_request(fc);
993 if (!req)
994 return -EINTR;
995
996 memset(&inarg, 0, sizeof(inarg));
997 inarg.size = size;
998 inarg.flags = flags;
999 req->in.h.opcode = FUSE_SETXATTR;
1000 req->in.h.nodeid = get_node_id(inode);
1001 req->inode = 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;
1014 err = -EOPNOTSUPP;
1015 }
1016 return err;
1017 }
1018
1019 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1020 void *value, size_t size)
1021 {
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;
1027 ssize_t ret;
1028
1029 if (fc->no_getxattr)
1030 return -EOPNOTSUPP;
1031
1032 req = fuse_get_request(fc);
1033 if (!req)
1034 return -EINTR;
1035
1036 memset(&inarg, 0, sizeof(inarg));
1037 inarg.size = size;
1038 req->in.h.opcode = FUSE_GETXATTR;
1039 req->in.h.nodeid = get_node_id(inode);
1040 req->inode = 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;
1048 if (size) {
1049 req->out.argvar = 1;
1050 req->out.args[0].size = size;
1051 req->out.args[0].value = value;
1052 } else {
1053 req->out.args[0].size = sizeof(outarg);
1054 req->out.args[0].value = &outarg;
1055 }
1056 request_send(fc, req);
1057 ret = req->out.h.error;
1058 if (!ret)
1059 ret = size ? req->out.args[0].size : outarg.size;
1060 else {
1061 if (ret == -ENOSYS) {
1062 fc->no_getxattr = 1;
1063 ret = -EOPNOTSUPP;
1064 }
1065 }
1066 fuse_put_request(fc, req);
1067 return ret;
1068 }
1069
1070 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1071 {
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;
1077 ssize_t ret;
1078
1079 if (fc->no_listxattr)
1080 return -EOPNOTSUPP;
1081
1082 req = fuse_get_request(fc);
1083 if (!req)
1084 return -EINTR;
1085
1086 memset(&inarg, 0, sizeof(inarg));
1087 inarg.size = size;
1088 req->in.h.opcode = FUSE_LISTXATTR;
1089 req->in.h.nodeid = get_node_id(inode);
1090 req->inode = 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;
1096 if (size) {
1097 req->out.argvar = 1;
1098 req->out.args[0].size = size;
1099 req->out.args[0].value = list;
1100 } else {
1101 req->out.args[0].size = sizeof(outarg);
1102 req->out.args[0].value = &outarg;
1103 }
1104 request_send(fc, req);
1105 ret = req->out.h.error;
1106 if (!ret)
1107 ret = size ? req->out.args[0].size : outarg.size;
1108 else {
1109 if (ret == -ENOSYS) {
1110 fc->no_listxattr = 1;
1111 ret = -EOPNOTSUPP;
1112 }
1113 }
1114 fuse_put_request(fc, req);
1115 return ret;
1116 }
1117
1118 static int fuse_removexattr(struct dentry *entry, const char *name)
1119 {
1120 struct inode *inode = entry->d_inode;
1121 struct fuse_conn *fc = get_fuse_conn(inode);
1122 struct fuse_req *req;
1123 int err;
1124
1125 if (fc->no_removexattr)
1126 return -EOPNOTSUPP;
1127
1128 req = fuse_get_request(fc);
1129 if (!req)
1130 return -EINTR;
1131
1132 req->in.h.opcode = FUSE_REMOVEXATTR;
1133 req->in.h.nodeid = get_node_id(inode);
1134 req->inode = 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;
1143 err = -EOPNOTSUPP;
1144 }
1145 return err;
1146 }
1147
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,
1155 .link = fuse_link,
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,
1165 };
1166
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,
1174 };
1175
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,
1184 };
1185
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,
1196 };
1197
1198 void fuse_init_common(struct inode *inode)
1199 {
1200 inode->i_op = &fuse_common_inode_operations;
1201 }
1202
1203 void fuse_init_dir(struct inode *inode)
1204 {
1205 inode->i_op = &fuse_dir_inode_operations;
1206 inode->i_fop = &fuse_dir_operations;
1207 }
1208
1209 void fuse_init_symlink(struct inode *inode)
1210 {
1211 inode->i_op = &fuse_symlink_inode_operations;
1212 }