]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - fs/fuse/dir.c
projects / thirdparty / kernel / stable.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'work.mkdir' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[thirdparty/kernel/stable.git] / fs / fuse / dir.c
1 /*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2008 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/sched.h>
14 #include <linux/namei.h>
15 #include <linux/slab.h>
16 #include <linux/xattr.h>
17 #include <linux/posix_acl.h>
18
19 static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
20 {
21 struct fuse_conn *fc = get_fuse_conn(dir);
22 struct fuse_inode *fi = get_fuse_inode(dir);
23
24 if (!fc->do_readdirplus)
25 return false;
26 if (!fc->readdirplus_auto)
27 return true;
28 if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
29 return true;
30 if (ctx->pos == 0)
31 return true;
32 return false;
33 }
34
35 static void fuse_advise_use_readdirplus(struct inode *dir)
36 {
37 struct fuse_inode *fi = get_fuse_inode(dir);
38
39 set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
40 }
41
42 union fuse_dentry {
43 u64 time;
44 struct rcu_head rcu;
45 };
46
47 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
48 {
49 ((union fuse_dentry *) entry->d_fsdata)->time = time;
50 }
51
52 static inline u64 fuse_dentry_time(struct dentry *entry)
53 {
54 return ((union fuse_dentry *) entry->d_fsdata)->time;
55 }
56
57 /*
58 * FUSE caches dentries and attributes with separate timeout. The
59 * time in jiffies until the dentry/attributes are valid is stored in
60 * dentry->d_fsdata and fuse_inode->i_time respectively.
61 */
62
63 /*
64 * Calculate the time in jiffies until a dentry/attributes are valid
65 */
66 static u64 time_to_jiffies(u64 sec, u32 nsec)
67 {
68 if (sec || nsec) {
69 struct timespec64 ts = {
70 sec,
71 min_t(u32, nsec, NSEC_PER_SEC - 1)
72 };
73
74 return get_jiffies_64() + timespec64_to_jiffies(&ts);
75 } else
76 return 0;
77 }
78
79 /*
80 * Set dentry and possibly attribute timeouts from the lookup/mk*
81 * replies
82 */
83 static void fuse_change_entry_timeout(struct dentry *entry,
84 struct fuse_entry_out *o)
85 {
86 fuse_dentry_settime(entry,
87 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
88 }
89
90 static u64 attr_timeout(struct fuse_attr_out *o)
91 {
92 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
93 }
94
95 static u64 entry_attr_timeout(struct fuse_entry_out *o)
96 {
97 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
98 }
99
100 /*
101 * Mark the attributes as stale, so that at the next call to
102 * ->getattr() they will be fetched from userspace
103 */
104 void fuse_invalidate_attr(struct inode *inode)
105 {
106 get_fuse_inode(inode)->i_time = 0;
107 }
108
109 /**
110 * Mark the attributes as stale due to an atime change. Avoid the invalidate if
111 * atime is not used.
112 */
113 void fuse_invalidate_atime(struct inode *inode)
114 {
115 if (!IS_RDONLY(inode))
116 fuse_invalidate_attr(inode);
117 }
118
119 /*
120 * Just mark the entry as stale, so that a next attempt to look it up
121 * will result in a new lookup call to userspace
122 *
123 * This is called when a dentry is about to become negative and the
124 * timeout is unknown (unlink, rmdir, rename and in some cases
125 * lookup)
126 */
127 void fuse_invalidate_entry_cache(struct dentry *entry)
128 {
129 fuse_dentry_settime(entry, 0);
130 }
131
132 /*
133 * Same as fuse_invalidate_entry_cache(), but also try to remove the
134 * dentry from the hash
135 */
136 static void fuse_invalidate_entry(struct dentry *entry)
137 {
138 d_invalidate(entry);
139 fuse_invalidate_entry_cache(entry);
140 }
141
142 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args,
143 u64 nodeid, const struct qstr *name,
144 struct fuse_entry_out *outarg)
145 {
146 memset(outarg, 0, sizeof(struct fuse_entry_out));
147 args->in.h.opcode = FUSE_LOOKUP;
148 args->in.h.nodeid = nodeid;
149 args->in.numargs = 1;
150 args->in.args[0].size = name->len + 1;
151 args->in.args[0].value = name->name;
152 args->out.numargs = 1;
153 args->out.args[0].size = sizeof(struct fuse_entry_out);
154 args->out.args[0].value = outarg;
155 }
156
157 u64 fuse_get_attr_version(struct fuse_conn *fc)
158 {
159 u64 curr_version;
160
161 /*
162 * The spin lock isn't actually needed on 64bit archs, but we
163 * don't yet care too much about such optimizations.
164 */
165 spin_lock(&fc->lock);
166 curr_version = fc->attr_version;
167 spin_unlock(&fc->lock);
168
169 return curr_version;
170 }
171
172 /*
173 * Check whether the dentry is still valid
174 *
175 * If the entry validity timeout has expired and the dentry is
176 * positive, try to redo the lookup. If the lookup results in a
177 * different inode, then let the VFS invalidate the dentry and redo
178 * the lookup once more. If the lookup results in the same inode,
179 * then refresh the attributes, timeouts and mark the dentry valid.
180 */
181 static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
182 {
183 struct inode *inode;
184 struct dentry *parent;
185 struct fuse_conn *fc;
186 struct fuse_inode *fi;
187 int ret;
188
189 inode = d_inode_rcu(entry);
190 if (inode && is_bad_inode(inode))
191 goto invalid;
192 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
193 (flags & LOOKUP_REVAL)) {
194 struct fuse_entry_out outarg;
195 FUSE_ARGS(args);
196 struct fuse_forget_link *forget;
197 u64 attr_version;
198
199 /* For negative dentries, always do a fresh lookup */
200 if (!inode)
201 goto invalid;
202
203 ret = -ECHILD;
204 if (flags & LOOKUP_RCU)
205 goto out;
206
207 fc = get_fuse_conn(inode);
208
209 forget = fuse_alloc_forget();
210 ret = -ENOMEM;
211 if (!forget)
212 goto out;
213
214 attr_version = fuse_get_attr_version(fc);
215
216 parent = dget_parent(entry);
217 fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
218 &entry->d_name, &outarg);
219 ret = fuse_simple_request(fc, &args);
220 dput(parent);
221 /* Zero nodeid is same as -ENOENT */
222 if (!ret && !outarg.nodeid)
223 ret = -ENOENT;
224 if (!ret) {
225 fi = get_fuse_inode(inode);
226 if (outarg.nodeid != get_node_id(inode)) {
227 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
228 goto invalid;
229 }
230 spin_lock(&fc->lock);
231 fi->nlookup++;
232 spin_unlock(&fc->lock);
233 }
234 kfree(forget);
235 if (ret == -ENOMEM)
236 goto out;
237 if (ret || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
238 goto invalid;
239
240 forget_all_cached_acls(inode);
241 fuse_change_attributes(inode, &outarg.attr,
242 entry_attr_timeout(&outarg),
243 attr_version);
244 fuse_change_entry_timeout(entry, &outarg);
245 } else if (inode) {
246 fi = get_fuse_inode(inode);
247 if (flags & LOOKUP_RCU) {
248 if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
249 return -ECHILD;
250 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
251 parent = dget_parent(entry);
252 fuse_advise_use_readdirplus(d_inode(parent));
253 dput(parent);
254 }
255 }
256 ret = 1;
257 out:
258 return ret;
259
260 invalid:
261 ret = 0;
262 goto out;
263 }
264
265 static int invalid_nodeid(u64 nodeid)
266 {
267 return !nodeid || nodeid == FUSE_ROOT_ID;
268 }
269
270 static int fuse_dentry_init(struct dentry *dentry)
271 {
272 dentry->d_fsdata = kzalloc(sizeof(union fuse_dentry), GFP_KERNEL);
273
274 return dentry->d_fsdata ? 0 : -ENOMEM;
275 }
276 static void fuse_dentry_release(struct dentry *dentry)
277 {
278 union fuse_dentry *fd = dentry->d_fsdata;
279
280 kfree_rcu(fd, rcu);
281 }
282
283 const struct dentry_operations fuse_dentry_operations = {
284 .d_revalidate = fuse_dentry_revalidate,
285 .d_init = fuse_dentry_init,
286 .d_release = fuse_dentry_release,
287 };
288
289 const struct dentry_operations fuse_root_dentry_operations = {
290 .d_init = fuse_dentry_init,
291 .d_release = fuse_dentry_release,
292 };
293
294 int fuse_valid_type(int m)
295 {
296 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
297 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
298 }
299
300 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
301 struct fuse_entry_out *outarg, struct inode **inode)
302 {
303 struct fuse_conn *fc = get_fuse_conn_super(sb);
304 FUSE_ARGS(args);
305 struct fuse_forget_link *forget;
306 u64 attr_version;
307 int err;
308
309 *inode = NULL;
310 err = -ENAMETOOLONG;
311 if (name->len > FUSE_NAME_MAX)
312 goto out;
313
314
315 forget = fuse_alloc_forget();
316 err = -ENOMEM;
317 if (!forget)
318 goto out;
319
320 attr_version = fuse_get_attr_version(fc);
321
322 fuse_lookup_init(fc, &args, nodeid, name, outarg);
323 err = fuse_simple_request(fc, &args);
324 /* Zero nodeid is same as -ENOENT, but with valid timeout */
325 if (err || !outarg->nodeid)
326 goto out_put_forget;
327
328 err = -EIO;
329 if (!outarg->nodeid)
330 goto out_put_forget;
331 if (!fuse_valid_type(outarg->attr.mode))
332 goto out_put_forget;
333
334 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
335 &outarg->attr, entry_attr_timeout(outarg),
336 attr_version);
337 err = -ENOMEM;
338 if (!*inode) {
339 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
340 goto out;
341 }
342 err = 0;
343
344 out_put_forget:
345 kfree(forget);
346 out:
347 return err;
348 }
349
350 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
351 unsigned int flags)
352 {
353 int err;
354 struct fuse_entry_out outarg;
355 struct inode *inode;
356 struct dentry *newent;
357 bool outarg_valid = true;
358
359 fuse_lock_inode(dir);
360 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
361 &outarg, &inode);
362 fuse_unlock_inode(dir);
363 if (err == -ENOENT) {
364 outarg_valid = false;
365 err = 0;
366 }
367 if (err)
368 goto out_err;
369
370 err = -EIO;
371 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
372 goto out_iput;
373
374 newent = d_splice_alias(inode, entry);
375 err = PTR_ERR(newent);
376 if (IS_ERR(newent))
377 goto out_err;
378
379 entry = newent ? newent : entry;
380 if (outarg_valid)
381 fuse_change_entry_timeout(entry, &outarg);
382 else
383 fuse_invalidate_entry_cache(entry);
384
385 fuse_advise_use_readdirplus(dir);
386 return newent;
387
388 out_iput:
389 iput(inode);
390 out_err:
391 return ERR_PTR(err);
392 }
393
394 /*
395 * Atomic create+open operation
396 *
397 * If the filesystem doesn't support this, then fall back to separate
398 * 'mknod' + 'open' requests.
399 */
400 static int fuse_create_open(struct inode *dir, struct dentry *entry,
401 struct file *file, unsigned flags,
402 umode_t mode)
403 {
404 int err;
405 struct inode *inode;
406 struct fuse_conn *fc = get_fuse_conn(dir);
407 FUSE_ARGS(args);
408 struct fuse_forget_link *forget;
409 struct fuse_create_in inarg;
410 struct fuse_open_out outopen;
411 struct fuse_entry_out outentry;
412 struct fuse_file *ff;
413
414 /* Userspace expects S_IFREG in create mode */
415 BUG_ON((mode & S_IFMT) != S_IFREG);
416
417 forget = fuse_alloc_forget();
418 err = -ENOMEM;
419 if (!forget)
420 goto out_err;
421
422 err = -ENOMEM;
423 ff = fuse_file_alloc(fc);
424 if (!ff)
425 goto out_put_forget_req;
426
427 if (!fc->dont_mask)
428 mode &= ~current_umask();
429
430 flags &= ~O_NOCTTY;
431 memset(&inarg, 0, sizeof(inarg));
432 memset(&outentry, 0, sizeof(outentry));
433 inarg.flags = flags;
434 inarg.mode = mode;
435 inarg.umask = current_umask();
436 args.in.h.opcode = FUSE_CREATE;
437 args.in.h.nodeid = get_node_id(dir);
438 args.in.numargs = 2;
439 args.in.args[0].size = sizeof(inarg);
440 args.in.args[0].value = &inarg;
441 args.in.args[1].size = entry->d_name.len + 1;
442 args.in.args[1].value = entry->d_name.name;
443 args.out.numargs = 2;
444 args.out.args[0].size = sizeof(outentry);
445 args.out.args[0].value = &outentry;
446 args.out.args[1].size = sizeof(outopen);
447 args.out.args[1].value = &outopen;
448 err = fuse_simple_request(fc, &args);
449 if (err)
450 goto out_free_ff;
451
452 err = -EIO;
453 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
454 goto out_free_ff;
455
456 ff->fh = outopen.fh;
457 ff->nodeid = outentry.nodeid;
458 ff->open_flags = outopen.open_flags;
459 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
460 &outentry.attr, entry_attr_timeout(&outentry), 0);
461 if (!inode) {
462 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
463 fuse_sync_release(ff, flags);
464 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
465 err = -ENOMEM;
466 goto out_err;
467 }
468 kfree(forget);
469 d_instantiate(entry, inode);
470 fuse_change_entry_timeout(entry, &outentry);
471 fuse_invalidate_attr(dir);
472 err = finish_open(file, entry, generic_file_open);
473 if (err) {
474 fuse_sync_release(ff, flags);
475 } else {
476 file->private_data = ff;
477 fuse_finish_open(inode, file);
478 }
479 return err;
480
481 out_free_ff:
482 fuse_file_free(ff);
483 out_put_forget_req:
484 kfree(forget);
485 out_err:
486 return err;
487 }
488
489 static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
490 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
491 struct file *file, unsigned flags,
492 umode_t mode)
493 {
494 int err;
495 struct fuse_conn *fc = get_fuse_conn(dir);
496 struct dentry *res = NULL;
497
498 if (d_in_lookup(entry)) {
499 res = fuse_lookup(dir, entry, 0);
500 if (IS_ERR(res))
501 return PTR_ERR(res);
502
503 if (res)
504 entry = res;
505 }
506
507 if (!(flags & O_CREAT) || d_really_is_positive(entry))
508 goto no_open;
509
510 /* Only creates */
511 file->f_mode |= FMODE_CREATED;
512
513 if (fc->no_create)
514 goto mknod;
515
516 err = fuse_create_open(dir, entry, file, flags, mode);
517 if (err == -ENOSYS) {
518 fc->no_create = 1;
519 goto mknod;
520 }
521 out_dput:
522 dput(res);
523 return err;
524
525 mknod:
526 err = fuse_mknod(dir, entry, mode, 0);
527 if (err)
528 goto out_dput;
529 no_open:
530 return finish_no_open(file, res);
531 }
532
533 /*
534 * Code shared between mknod, mkdir, symlink and link
535 */
536 static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args,
537 struct inode *dir, struct dentry *entry,
538 umode_t mode)
539 {
540 struct fuse_entry_out outarg;
541 struct inode *inode;
542 struct dentry *d;
543 int err;
544 struct fuse_forget_link *forget;
545
546 forget = fuse_alloc_forget();
547 if (!forget)
548 return -ENOMEM;
549
550 memset(&outarg, 0, sizeof(outarg));
551 args->in.h.nodeid = get_node_id(dir);
552 args->out.numargs = 1;
553 args->out.args[0].size = sizeof(outarg);
554 args->out.args[0].value = &outarg;
555 err = fuse_simple_request(fc, args);
556 if (err)
557 goto out_put_forget_req;
558
559 err = -EIO;
560 if (invalid_nodeid(outarg.nodeid))
561 goto out_put_forget_req;
562
563 if ((outarg.attr.mode ^ mode) & S_IFMT)
564 goto out_put_forget_req;
565
566 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
567 &outarg.attr, entry_attr_timeout(&outarg), 0);
568 if (!inode) {
569 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
570 return -ENOMEM;
571 }
572 kfree(forget);
573
574 d_drop(entry);
575 d = d_splice_alias(inode, entry);
576 if (IS_ERR(d))
577 return PTR_ERR(d);
578
579 if (d) {
580 fuse_change_entry_timeout(d, &outarg);
581 dput(d);
582 } else {
583 fuse_change_entry_timeout(entry, &outarg);
584 }
585 fuse_invalidate_attr(dir);
586 return 0;
587
588 out_put_forget_req:
589 kfree(forget);
590 return err;
591 }
592
593 static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
594 dev_t rdev)
595 {
596 struct fuse_mknod_in inarg;
597 struct fuse_conn *fc = get_fuse_conn(dir);
598 FUSE_ARGS(args);
599
600 if (!fc->dont_mask)
601 mode &= ~current_umask();
602
603 memset(&inarg, 0, sizeof(inarg));
604 inarg.mode = mode;
605 inarg.rdev = new_encode_dev(rdev);
606 inarg.umask = current_umask();
607 args.in.h.opcode = FUSE_MKNOD;
608 args.in.numargs = 2;
609 args.in.args[0].size = sizeof(inarg);
610 args.in.args[0].value = &inarg;
611 args.in.args[1].size = entry->d_name.len + 1;
612 args.in.args[1].value = entry->d_name.name;
613 return create_new_entry(fc, &args, dir, entry, mode);
614 }
615
616 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
617 bool excl)
618 {
619 return fuse_mknod(dir, entry, mode, 0);
620 }
621
622 static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
623 {
624 struct fuse_mkdir_in inarg;
625 struct fuse_conn *fc = get_fuse_conn(dir);
626 FUSE_ARGS(args);
627
628 if (!fc->dont_mask)
629 mode &= ~current_umask();
630
631 memset(&inarg, 0, sizeof(inarg));
632 inarg.mode = mode;
633 inarg.umask = current_umask();
634 args.in.h.opcode = FUSE_MKDIR;
635 args.in.numargs = 2;
636 args.in.args[0].size = sizeof(inarg);
637 args.in.args[0].value = &inarg;
638 args.in.args[1].size = entry->d_name.len + 1;
639 args.in.args[1].value = entry->d_name.name;
640 return create_new_entry(fc, &args, dir, entry, S_IFDIR);
641 }
642
643 static int fuse_symlink(struct inode *dir, struct dentry *entry,
644 const char *link)
645 {
646 struct fuse_conn *fc = get_fuse_conn(dir);
647 unsigned len = strlen(link) + 1;
648 FUSE_ARGS(args);
649
650 args.in.h.opcode = FUSE_SYMLINK;
651 args.in.numargs = 2;
652 args.in.args[0].size = entry->d_name.len + 1;
653 args.in.args[0].value = entry->d_name.name;
654 args.in.args[1].size = len;
655 args.in.args[1].value = link;
656 return create_new_entry(fc, &args, dir, entry, S_IFLNK);
657 }
658
659 void fuse_update_ctime(struct inode *inode)
660 {
661 if (!IS_NOCMTIME(inode)) {
662 inode->i_ctime = current_time(inode);
663 mark_inode_dirty_sync(inode);
664 }
665 }
666
667 static int fuse_unlink(struct inode *dir, struct dentry *entry)
668 {
669 int err;
670 struct fuse_conn *fc = get_fuse_conn(dir);
671 FUSE_ARGS(args);
672
673 args.in.h.opcode = FUSE_UNLINK;
674 args.in.h.nodeid = get_node_id(dir);
675 args.in.numargs = 1;
676 args.in.args[0].size = entry->d_name.len + 1;
677 args.in.args[0].value = entry->d_name.name;
678 err = fuse_simple_request(fc, &args);
679 if (!err) {
680 struct inode *inode = d_inode(entry);
681 struct fuse_inode *fi = get_fuse_inode(inode);
682
683 spin_lock(&fc->lock);
684 fi->attr_version = ++fc->attr_version;
685 /*
686 * If i_nlink == 0 then unlink doesn't make sense, yet this can
687 * happen if userspace filesystem is careless. It would be
688 * difficult to enforce correct nlink usage so just ignore this
689 * condition here
690 */
691 if (inode->i_nlink > 0)
692 drop_nlink(inode);
693 spin_unlock(&fc->lock);
694 fuse_invalidate_attr(inode);
695 fuse_invalidate_attr(dir);
696 fuse_invalidate_entry_cache(entry);
697 fuse_update_ctime(inode);
698 } else if (err == -EINTR)
699 fuse_invalidate_entry(entry);
700 return err;
701 }
702
703 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
704 {
705 int err;
706 struct fuse_conn *fc = get_fuse_conn(dir);
707 FUSE_ARGS(args);
708
709 args.in.h.opcode = FUSE_RMDIR;
710 args.in.h.nodeid = get_node_id(dir);
711 args.in.numargs = 1;
712 args.in.args[0].size = entry->d_name.len + 1;
713 args.in.args[0].value = entry->d_name.name;
714 err = fuse_simple_request(fc, &args);
715 if (!err) {
716 clear_nlink(d_inode(entry));
717 fuse_invalidate_attr(dir);
718 fuse_invalidate_entry_cache(entry);
719 } else if (err == -EINTR)
720 fuse_invalidate_entry(entry);
721 return err;
722 }
723
724 static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
725 struct inode *newdir, struct dentry *newent,
726 unsigned int flags, int opcode, size_t argsize)
727 {
728 int err;
729 struct fuse_rename2_in inarg;
730 struct fuse_conn *fc = get_fuse_conn(olddir);
731 FUSE_ARGS(args);
732
733 memset(&inarg, 0, argsize);
734 inarg.newdir = get_node_id(newdir);
735 inarg.flags = flags;
736 args.in.h.opcode = opcode;
737 args.in.h.nodeid = get_node_id(olddir);
738 args.in.numargs = 3;
739 args.in.args[0].size = argsize;
740 args.in.args[0].value = &inarg;
741 args.in.args[1].size = oldent->d_name.len + 1;
742 args.in.args[1].value = oldent->d_name.name;
743 args.in.args[2].size = newent->d_name.len + 1;
744 args.in.args[2].value = newent->d_name.name;
745 err = fuse_simple_request(fc, &args);
746 if (!err) {
747 /* ctime changes */
748 fuse_invalidate_attr(d_inode(oldent));
749 fuse_update_ctime(d_inode(oldent));
750
751 if (flags & RENAME_EXCHANGE) {
752 fuse_invalidate_attr(d_inode(newent));
753 fuse_update_ctime(d_inode(newent));
754 }
755
756 fuse_invalidate_attr(olddir);
757 if (olddir != newdir)
758 fuse_invalidate_attr(newdir);
759
760 /* newent will end up negative */
761 if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
762 fuse_invalidate_attr(d_inode(newent));
763 fuse_invalidate_entry_cache(newent);
764 fuse_update_ctime(d_inode(newent));
765 }
766 } else if (err == -EINTR) {
767 /* If request was interrupted, DEITY only knows if the
768 rename actually took place. If the invalidation
769 fails (e.g. some process has CWD under the renamed
770 directory), then there can be inconsistency between
771 the dcache and the real filesystem. Tough luck. */
772 fuse_invalidate_entry(oldent);
773 if (d_really_is_positive(newent))
774 fuse_invalidate_entry(newent);
775 }
776
777 return err;
778 }
779
780 static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
781 struct inode *newdir, struct dentry *newent,
782 unsigned int flags)
783 {
784 struct fuse_conn *fc = get_fuse_conn(olddir);
785 int err;
786
787 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
788 return -EINVAL;
789
790 if (flags) {
791 if (fc->no_rename2 || fc->minor < 23)
792 return -EINVAL;
793
794 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
795 FUSE_RENAME2,
796 sizeof(struct fuse_rename2_in));
797 if (err == -ENOSYS) {
798 fc->no_rename2 = 1;
799 err = -EINVAL;
800 }
801 } else {
802 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
803 FUSE_RENAME,
804 sizeof(struct fuse_rename_in));
805 }
806
807 return err;
808 }
809
810 static int fuse_link(struct dentry *entry, struct inode *newdir,
811 struct dentry *newent)
812 {
813 int err;
814 struct fuse_link_in inarg;
815 struct inode *inode = d_inode(entry);
816 struct fuse_conn *fc = get_fuse_conn(inode);
817 FUSE_ARGS(args);
818
819 memset(&inarg, 0, sizeof(inarg));
820 inarg.oldnodeid = get_node_id(inode);
821 args.in.h.opcode = FUSE_LINK;
822 args.in.numargs = 2;
823 args.in.args[0].size = sizeof(inarg);
824 args.in.args[0].value = &inarg;
825 args.in.args[1].size = newent->d_name.len + 1;
826 args.in.args[1].value = newent->d_name.name;
827 err = create_new_entry(fc, &args, newdir, newent, inode->i_mode);
828 /* Contrary to "normal" filesystems it can happen that link
829 makes two "logical" inodes point to the same "physical"
830 inode. We invalidate the attributes of the old one, so it
831 will reflect changes in the backing inode (link count,
832 etc.)
833 */
834 if (!err) {
835 struct fuse_inode *fi = get_fuse_inode(inode);
836
837 spin_lock(&fc->lock);
838 fi->attr_version = ++fc->attr_version;
839 inc_nlink(inode);
840 spin_unlock(&fc->lock);
841 fuse_invalidate_attr(inode);
842 fuse_update_ctime(inode);
843 } else if (err == -EINTR) {
844 fuse_invalidate_attr(inode);
845 }
846 return err;
847 }
848
849 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
850 struct kstat *stat)
851 {
852 unsigned int blkbits;
853 struct fuse_conn *fc = get_fuse_conn(inode);
854
855 /* see the comment in fuse_change_attributes() */
856 if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
857 attr->size = i_size_read(inode);
858 attr->mtime = inode->i_mtime.tv_sec;
859 attr->mtimensec = inode->i_mtime.tv_nsec;
860 attr->ctime = inode->i_ctime.tv_sec;
861 attr->ctimensec = inode->i_ctime.tv_nsec;
862 }
863
864 stat->dev = inode->i_sb->s_dev;
865 stat->ino = attr->ino;
866 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
867 stat->nlink = attr->nlink;
868 stat->uid = make_kuid(fc->user_ns, attr->uid);
869 stat->gid = make_kgid(fc->user_ns, attr->gid);
870 stat->rdev = inode->i_rdev;
871 stat->atime.tv_sec = attr->atime;
872 stat->atime.tv_nsec = attr->atimensec;
873 stat->mtime.tv_sec = attr->mtime;
874 stat->mtime.tv_nsec = attr->mtimensec;
875 stat->ctime.tv_sec = attr->ctime;
876 stat->ctime.tv_nsec = attr->ctimensec;
877 stat->size = attr->size;
878 stat->blocks = attr->blocks;
879
880 if (attr->blksize != 0)
881 blkbits = ilog2(attr->blksize);
882 else
883 blkbits = inode->i_sb->s_blocksize_bits;
884
885 stat->blksize = 1 << blkbits;
886 }
887
888 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
889 struct file *file)
890 {
891 int err;
892 struct fuse_getattr_in inarg;
893 struct fuse_attr_out outarg;
894 struct fuse_conn *fc = get_fuse_conn(inode);
895 FUSE_ARGS(args);
896 u64 attr_version;
897
898 attr_version = fuse_get_attr_version(fc);
899
900 memset(&inarg, 0, sizeof(inarg));
901 memset(&outarg, 0, sizeof(outarg));
902 /* Directories have separate file-handle space */
903 if (file && S_ISREG(inode->i_mode)) {
904 struct fuse_file *ff = file->private_data;
905
906 inarg.getattr_flags |= FUSE_GETATTR_FH;
907 inarg.fh = ff->fh;
908 }
909 args.in.h.opcode = FUSE_GETATTR;
910 args.in.h.nodeid = get_node_id(inode);
911 args.in.numargs = 1;
912 args.in.args[0].size = sizeof(inarg);
913 args.in.args[0].value = &inarg;
914 args.out.numargs = 1;
915 args.out.args[0].size = sizeof(outarg);
916 args.out.args[0].value = &outarg;
917 err = fuse_simple_request(fc, &args);
918 if (!err) {
919 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
920 make_bad_inode(inode);
921 err = -EIO;
922 } else {
923 fuse_change_attributes(inode, &outarg.attr,
924 attr_timeout(&outarg),
925 attr_version);
926 if (stat)
927 fuse_fillattr(inode, &outarg.attr, stat);
928 }
929 }
930 return err;
931 }
932
933 static int fuse_update_get_attr(struct inode *inode, struct file *file,
934 struct kstat *stat, unsigned int flags)
935 {
936 struct fuse_inode *fi = get_fuse_inode(inode);
937 int err = 0;
938 bool sync;
939
940 if (flags & AT_STATX_FORCE_SYNC)
941 sync = true;
942 else if (flags & AT_STATX_DONT_SYNC)
943 sync = false;
944 else
945 sync = time_before64(fi->i_time, get_jiffies_64());
946
947 if (sync) {
948 forget_all_cached_acls(inode);
949 err = fuse_do_getattr(inode, stat, file);
950 } else if (stat) {
951 generic_fillattr(inode, stat);
952 stat->mode = fi->orig_i_mode;
953 stat->ino = fi->orig_ino;
954 }
955
956 return err;
957 }
958
959 int fuse_update_attributes(struct inode *inode, struct file *file)
960 {
961 return fuse_update_get_attr(inode, file, NULL, 0);
962 }
963
964 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
965 u64 child_nodeid, struct qstr *name)
966 {
967 int err = -ENOTDIR;
968 struct inode *parent;
969 struct dentry *dir;
970 struct dentry *entry;
971
972 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
973 if (!parent)
974 return -ENOENT;
975
976 inode_lock(parent);
977 if (!S_ISDIR(parent->i_mode))
978 goto unlock;
979
980 err = -ENOENT;
981 dir = d_find_alias(parent);
982 if (!dir)
983 goto unlock;
984
985 name->hash = full_name_hash(dir, name->name, name->len);
986 entry = d_lookup(dir, name);
987 dput(dir);
988 if (!entry)
989 goto unlock;
990
991 fuse_invalidate_attr(parent);
992 fuse_invalidate_entry(entry);
993
994 if (child_nodeid != 0 && d_really_is_positive(entry)) {
995 inode_lock(d_inode(entry));
996 if (get_node_id(d_inode(entry)) != child_nodeid) {
997 err = -ENOENT;
998 goto badentry;
999 }
1000 if (d_mountpoint(entry)) {
1001 err = -EBUSY;
1002 goto badentry;
1003 }
1004 if (d_is_dir(entry)) {
1005 shrink_dcache_parent(entry);
1006 if (!simple_empty(entry)) {
1007 err = -ENOTEMPTY;
1008 goto badentry;
1009 }
1010 d_inode(entry)->i_flags |= S_DEAD;
1011 }
1012 dont_mount(entry);
1013 clear_nlink(d_inode(entry));
1014 err = 0;
1015 badentry:
1016 inode_unlock(d_inode(entry));
1017 if (!err)
1018 d_delete(entry);
1019 } else {
1020 err = 0;
1021 }
1022 dput(entry);
1023
1024 unlock:
1025 inode_unlock(parent);
1026 iput(parent);
1027 return err;
1028 }
1029
1030 /*
1031 * Calling into a user-controlled filesystem gives the filesystem
1032 * daemon ptrace-like capabilities over the current process. This
1033 * means, that the filesystem daemon is able to record the exact
1034 * filesystem operations performed, and can also control the behavior
1035 * of the requester process in otherwise impossible ways. For example
1036 * it can delay the operation for arbitrary length of time allowing
1037 * DoS against the requester.
1038 *
1039 * For this reason only those processes can call into the filesystem,
1040 * for which the owner of the mount has ptrace privilege. This
1041 * excludes processes started by other users, suid or sgid processes.
1042 */
1043 int fuse_allow_current_process(struct fuse_conn *fc)
1044 {
1045 const struct cred *cred;
1046
1047 if (fc->allow_other)
1048 return current_in_userns(fc->user_ns);
1049
1050 cred = current_cred();
1051 if (uid_eq(cred->euid, fc->user_id) &&
1052 uid_eq(cred->suid, fc->user_id) &&
1053 uid_eq(cred->uid, fc->user_id) &&
1054 gid_eq(cred->egid, fc->group_id) &&
1055 gid_eq(cred->sgid, fc->group_id) &&
1056 gid_eq(cred->gid, fc->group_id))
1057 return 1;
1058
1059 return 0;
1060 }
1061
1062 static int fuse_access(struct inode *inode, int mask)
1063 {
1064 struct fuse_conn *fc = get_fuse_conn(inode);
1065 FUSE_ARGS(args);
1066 struct fuse_access_in inarg;
1067 int err;
1068
1069 BUG_ON(mask & MAY_NOT_BLOCK);
1070
1071 if (fc->no_access)
1072 return 0;
1073
1074 memset(&inarg, 0, sizeof(inarg));
1075 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1076 args.in.h.opcode = FUSE_ACCESS;
1077 args.in.h.nodeid = get_node_id(inode);
1078 args.in.numargs = 1;
1079 args.in.args[0].size = sizeof(inarg);
1080 args.in.args[0].value = &inarg;
1081 err = fuse_simple_request(fc, &args);
1082 if (err == -ENOSYS) {
1083 fc->no_access = 1;
1084 err = 0;
1085 }
1086 return err;
1087 }
1088
1089 static int fuse_perm_getattr(struct inode *inode, int mask)
1090 {
1091 if (mask & MAY_NOT_BLOCK)
1092 return -ECHILD;
1093
1094 forget_all_cached_acls(inode);
1095 return fuse_do_getattr(inode, NULL, NULL);
1096 }
1097
1098 /*
1099 * Check permission. The two basic access models of FUSE are:
1100 *
1101 * 1) Local access checking ('default_permissions' mount option) based
1102 * on file mode. This is the plain old disk filesystem permission
1103 * modell.
1104 *
1105 * 2) "Remote" access checking, where server is responsible for
1106 * checking permission in each inode operation. An exception to this
1107 * is if ->permission() was invoked from sys_access() in which case an
1108 * access request is sent. Execute permission is still checked
1109 * locally based on file mode.
1110 */
1111 static int fuse_permission(struct inode *inode, int mask)
1112 {
1113 struct fuse_conn *fc = get_fuse_conn(inode);
1114 bool refreshed = false;
1115 int err = 0;
1116
1117 if (!fuse_allow_current_process(fc))
1118 return -EACCES;
1119
1120 /*
1121 * If attributes are needed, refresh them before proceeding
1122 */
1123 if (fc->default_permissions ||
1124 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1125 struct fuse_inode *fi = get_fuse_inode(inode);
1126
1127 if (time_before64(fi->i_time, get_jiffies_64())) {
1128 refreshed = true;
1129
1130 err = fuse_perm_getattr(inode, mask);
1131 if (err)
1132 return err;
1133 }
1134 }
1135
1136 if (fc->default_permissions) {
1137 err = generic_permission(inode, mask);
1138
1139 /* If permission is denied, try to refresh file
1140 attributes. This is also needed, because the root
1141 node will at first have no permissions */
1142 if (err == -EACCES && !refreshed) {
1143 err = fuse_perm_getattr(inode, mask);
1144 if (!err)
1145 err = generic_permission(inode, mask);
1146 }
1147
1148 /* Note: the opposite of the above test does not
1149 exist. So if permissions are revoked this won't be
1150 noticed immediately, only after the attribute
1151 timeout has expired */
1152 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1153 err = fuse_access(inode, mask);
1154 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1155 if (!(inode->i_mode & S_IXUGO)) {
1156 if (refreshed)
1157 return -EACCES;
1158
1159 err = fuse_perm_getattr(inode, mask);
1160 if (!err && !(inode->i_mode & S_IXUGO))
1161 return -EACCES;
1162 }
1163 }
1164 return err;
1165 }
1166
1167 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1168 struct dir_context *ctx)
1169 {
1170 while (nbytes >= FUSE_NAME_OFFSET) {
1171 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1172 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1173 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1174 return -EIO;
1175 if (reclen > nbytes)
1176 break;
1177 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1178 return -EIO;
1179
1180 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1181 dirent->ino, dirent->type))
1182 break;
1183
1184 buf += reclen;
1185 nbytes -= reclen;
1186 ctx->pos = dirent->off;
1187 }
1188
1189 return 0;
1190 }
1191
1192 static int fuse_direntplus_link(struct file *file,
1193 struct fuse_direntplus *direntplus,
1194 u64 attr_version)
1195 {
1196 struct fuse_entry_out *o = &direntplus->entry_out;
1197 struct fuse_dirent *dirent = &direntplus->dirent;
1198 struct dentry *parent = file->f_path.dentry;
1199 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1200 struct dentry *dentry;
1201 struct dentry *alias;
1202 struct inode *dir = d_inode(parent);
1203 struct fuse_conn *fc;
1204 struct inode *inode;
1205 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1206
1207 if (!o->nodeid) {
1208 /*
1209 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1210 * ENOENT. Instead, it only means the userspace filesystem did
1211 * not want to return attributes/handle for this entry.
1212 *
1213 * So do nothing.
1214 */
1215 return 0;
1216 }
1217
1218 if (name.name[0] == '.') {
1219 /*
1220 * We could potentially refresh the attributes of the directory
1221 * and its parent?
1222 */
1223 if (name.len == 1)
1224 return 0;
1225 if (name.name[1] == '.' && name.len == 2)
1226 return 0;
1227 }
1228
1229 if (invalid_nodeid(o->nodeid))
1230 return -EIO;
1231 if (!fuse_valid_type(o->attr.mode))
1232 return -EIO;
1233
1234 fc = get_fuse_conn(dir);
1235
1236 name.hash = full_name_hash(parent, name.name, name.len);
1237 dentry = d_lookup(parent, &name);
1238 if (!dentry) {
1239 retry:
1240 dentry = d_alloc_parallel(parent, &name, &wq);
1241 if (IS_ERR(dentry))
1242 return PTR_ERR(dentry);
1243 }
1244 if (!d_in_lookup(dentry)) {
1245 struct fuse_inode *fi;
1246 inode = d_inode(dentry);
1247 if (!inode ||
1248 get_node_id(inode) != o->nodeid ||
1249 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1250 d_invalidate(dentry);
1251 dput(dentry);
1252 goto retry;
1253 }
1254 if (is_bad_inode(inode)) {
1255 dput(dentry);
1256 return -EIO;
1257 }
1258
1259 fi = get_fuse_inode(inode);
1260 spin_lock(&fc->lock);
1261 fi->nlookup++;
1262 spin_unlock(&fc->lock);
1263
1264 forget_all_cached_acls(inode);
1265 fuse_change_attributes(inode, &o->attr,
1266 entry_attr_timeout(o),
1267 attr_version);
1268 /*
1269 * The other branch comes via fuse_iget()
1270 * which bumps nlookup inside
1271 */
1272 } else {
1273 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1274 &o->attr, entry_attr_timeout(o),
1275 attr_version);
1276 if (!inode)
1277 inode = ERR_PTR(-ENOMEM);
1278
1279 alias = d_splice_alias(inode, dentry);
1280 d_lookup_done(dentry);
1281 if (alias) {
1282 dput(dentry);
1283 dentry = alias;
1284 }
1285 if (IS_ERR(dentry))
1286 return PTR_ERR(dentry);
1287 }
1288 if (fc->readdirplus_auto)
1289 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1290 fuse_change_entry_timeout(dentry, o);
1291
1292 dput(dentry);
1293 return 0;
1294 }
1295
1296 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1297 struct dir_context *ctx, u64 attr_version)
1298 {
1299 struct fuse_direntplus *direntplus;
1300 struct fuse_dirent *dirent;
1301 size_t reclen;
1302 int over = 0;
1303 int ret;
1304
1305 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1306 direntplus = (struct fuse_direntplus *) buf;
1307 dirent = &direntplus->dirent;
1308 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1309
1310 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1311 return -EIO;
1312 if (reclen > nbytes)
1313 break;
1314 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1315 return -EIO;
1316
1317 if (!over) {
1318 /* We fill entries into dstbuf only as much as
1319 it can hold. But we still continue iterating
1320 over remaining entries to link them. If not,
1321 we need to send a FORGET for each of those
1322 which we did not link.
1323 */
1324 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1325 dirent->ino, dirent->type);
1326 if (!over)
1327 ctx->pos = dirent->off;
1328 }
1329
1330 buf += reclen;
1331 nbytes -= reclen;
1332
1333 ret = fuse_direntplus_link(file, direntplus, attr_version);
1334 if (ret)
1335 fuse_force_forget(file, direntplus->entry_out.nodeid);
1336 }
1337
1338 return 0;
1339 }
1340
1341 static int fuse_readdir(struct file *file, struct dir_context *ctx)
1342 {
1343 int plus, err;
1344 size_t nbytes;
1345 struct page *page;
1346 struct inode *inode = file_inode(file);
1347 struct fuse_conn *fc = get_fuse_conn(inode);
1348 struct fuse_req *req;
1349 u64 attr_version = 0;
1350
1351 if (is_bad_inode(inode))
1352 return -EIO;
1353
1354 req = fuse_get_req(fc, 1);
1355 if (IS_ERR(req))
1356 return PTR_ERR(req);
1357
1358 page = alloc_page(GFP_KERNEL);
1359 if (!page) {
1360 fuse_put_request(fc, req);
1361 return -ENOMEM;
1362 }
1363
1364 plus = fuse_use_readdirplus(inode, ctx);
1365 req->out.argpages = 1;
1366 req->num_pages = 1;
1367 req->pages[0] = page;
1368 req->page_descs[0].length = PAGE_SIZE;
1369 if (plus) {
1370 attr_version = fuse_get_attr_version(fc);
1371 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1372 FUSE_READDIRPLUS);
1373 } else {
1374 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1375 FUSE_READDIR);
1376 }
1377 fuse_lock_inode(inode);
1378 fuse_request_send(fc, req);
1379 fuse_unlock_inode(inode);
1380 nbytes = req->out.args[0].size;
1381 err = req->out.h.error;
1382 fuse_put_request(fc, req);
1383 if (!err) {
1384 if (plus) {
1385 err = parse_dirplusfile(page_address(page), nbytes,
1386 file, ctx,
1387 attr_version);
1388 } else {
1389 err = parse_dirfile(page_address(page), nbytes, file,
1390 ctx);
1391 }
1392 }
1393
1394 __free_page(page);
1395 fuse_invalidate_atime(inode);
1396 return err;
1397 }
1398
1399 static const char *fuse_get_link(struct dentry *dentry,
1400 struct inode *inode,
1401 struct delayed_call *done)
1402 {
1403 struct fuse_conn *fc = get_fuse_conn(inode);
1404 FUSE_ARGS(args);
1405 char *link;
1406 ssize_t ret;
1407
1408 if (!dentry)
1409 return ERR_PTR(-ECHILD);
1410
1411 link = kmalloc(PAGE_SIZE, GFP_KERNEL);
1412 if (!link)
1413 return ERR_PTR(-ENOMEM);
1414
1415 args.in.h.opcode = FUSE_READLINK;
1416 args.in.h.nodeid = get_node_id(inode);
1417 args.out.argvar = 1;
1418 args.out.numargs = 1;
1419 args.out.args[0].size = PAGE_SIZE - 1;
1420 args.out.args[0].value = link;
1421 ret = fuse_simple_request(fc, &args);
1422 if (ret < 0) {
1423 kfree(link);
1424 link = ERR_PTR(ret);
1425 } else {
1426 link[ret] = '\0';
1427 set_delayed_call(done, kfree_link, link);
1428 }
1429 fuse_invalidate_atime(inode);
1430 return link;
1431 }
1432
1433 static int fuse_dir_open(struct inode *inode, struct file *file)
1434 {
1435 return fuse_open_common(inode, file, true);
1436 }
1437
1438 static int fuse_dir_release(struct inode *inode, struct file *file)
1439 {
1440 fuse_release_common(file, FUSE_RELEASEDIR);
1441
1442 return 0;
1443 }
1444
1445 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1446 int datasync)
1447 {
1448 return fuse_fsync_common(file, start, end, datasync, 1);
1449 }
1450
1451 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1452 unsigned long arg)
1453 {
1454 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1455
1456 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1457 if (fc->minor < 18)
1458 return -ENOTTY;
1459
1460 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1461 }
1462
1463 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1464 unsigned long arg)
1465 {
1466 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1467
1468 if (fc->minor < 18)
1469 return -ENOTTY;
1470
1471 return fuse_ioctl_common(file, cmd, arg,
1472 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1473 }
1474
1475 static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1476 {
1477 /* Always update if mtime is explicitly set */
1478 if (ivalid & ATTR_MTIME_SET)
1479 return true;
1480
1481 /* Or if kernel i_mtime is the official one */
1482 if (trust_local_mtime)
1483 return true;
1484
1485 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1486 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1487 return false;
1488
1489 /* In all other cases update */
1490 return true;
1491 }
1492
1493 static void iattr_to_fattr(struct fuse_conn *fc, struct iattr *iattr,
1494 struct fuse_setattr_in *arg, bool trust_local_cmtime)
1495 {
1496 unsigned ivalid = iattr->ia_valid;
1497
1498 if (ivalid & ATTR_MODE)
1499 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1500 if (ivalid & ATTR_UID)
1501 arg->valid |= FATTR_UID, arg->uid = from_kuid(fc->user_ns, iattr->ia_uid);
1502 if (ivalid & ATTR_GID)
1503 arg->valid |= FATTR_GID, arg->gid = from_kgid(fc->user_ns, iattr->ia_gid);
1504 if (ivalid & ATTR_SIZE)
1505 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1506 if (ivalid & ATTR_ATIME) {
1507 arg->valid |= FATTR_ATIME;
1508 arg->atime = iattr->ia_atime.tv_sec;
1509 arg->atimensec = iattr->ia_atime.tv_nsec;
1510 if (!(ivalid & ATTR_ATIME_SET))
1511 arg->valid |= FATTR_ATIME_NOW;
1512 }
1513 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1514 arg->valid |= FATTR_MTIME;
1515 arg->mtime = iattr->ia_mtime.tv_sec;
1516 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1517 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1518 arg->valid |= FATTR_MTIME_NOW;
1519 }
1520 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1521 arg->valid |= FATTR_CTIME;
1522 arg->ctime = iattr->ia_ctime.tv_sec;
1523 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1524 }
1525 }
1526
1527 /*
1528 * Prevent concurrent writepages on inode
1529 *
1530 * This is done by adding a negative bias to the inode write counter
1531 * and waiting for all pending writes to finish.
1532 */
1533 void fuse_set_nowrite(struct inode *inode)
1534 {
1535 struct fuse_conn *fc = get_fuse_conn(inode);
1536 struct fuse_inode *fi = get_fuse_inode(inode);
1537
1538 BUG_ON(!inode_is_locked(inode));
1539
1540 spin_lock(&fc->lock);
1541 BUG_ON(fi->writectr < 0);
1542 fi->writectr += FUSE_NOWRITE;
1543 spin_unlock(&fc->lock);
1544 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1545 }
1546
1547 /*
1548 * Allow writepages on inode
1549 *
1550 * Remove the bias from the writecounter and send any queued
1551 * writepages.
1552 */
1553 static void __fuse_release_nowrite(struct inode *inode)
1554 {
1555 struct fuse_inode *fi = get_fuse_inode(inode);
1556
1557 BUG_ON(fi->writectr != FUSE_NOWRITE);
1558 fi->writectr = 0;
1559 fuse_flush_writepages(inode);
1560 }
1561
1562 void fuse_release_nowrite(struct inode *inode)
1563 {
1564 struct fuse_conn *fc = get_fuse_conn(inode);
1565
1566 spin_lock(&fc->lock);
1567 __fuse_release_nowrite(inode);
1568 spin_unlock(&fc->lock);
1569 }
1570
1571 static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
1572 struct inode *inode,
1573 struct fuse_setattr_in *inarg_p,
1574 struct fuse_attr_out *outarg_p)
1575 {
1576 args->in.h.opcode = FUSE_SETATTR;
1577 args->in.h.nodeid = get_node_id(inode);
1578 args->in.numargs = 1;
1579 args->in.args[0].size = sizeof(*inarg_p);
1580 args->in.args[0].value = inarg_p;
1581 args->out.numargs = 1;
1582 args->out.args[0].size = sizeof(*outarg_p);
1583 args->out.args[0].value = outarg_p;
1584 }
1585
1586 /*
1587 * Flush inode->i_mtime to the server
1588 */
1589 int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1590 {
1591 struct fuse_conn *fc = get_fuse_conn(inode);
1592 FUSE_ARGS(args);
1593 struct fuse_setattr_in inarg;
1594 struct fuse_attr_out outarg;
1595
1596 memset(&inarg, 0, sizeof(inarg));
1597 memset(&outarg, 0, sizeof(outarg));
1598
1599 inarg.valid = FATTR_MTIME;
1600 inarg.mtime = inode->i_mtime.tv_sec;
1601 inarg.mtimensec = inode->i_mtime.tv_nsec;
1602 if (fc->minor >= 23) {
1603 inarg.valid |= FATTR_CTIME;
1604 inarg.ctime = inode->i_ctime.tv_sec;
1605 inarg.ctimensec = inode->i_ctime.tv_nsec;
1606 }
1607 if (ff) {
1608 inarg.valid |= FATTR_FH;
1609 inarg.fh = ff->fh;
1610 }
1611 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1612
1613 return fuse_simple_request(fc, &args);
1614 }
1615
1616 /*
1617 * Set attributes, and at the same time refresh them.
1618 *
1619 * Truncation is slightly complicated, because the 'truncate' request
1620 * may fail, in which case we don't want to touch the mapping.
1621 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1622 * and the actual truncation by hand.
1623 */
1624 int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
1625 struct file *file)
1626 {
1627 struct inode *inode = d_inode(dentry);
1628 struct fuse_conn *fc = get_fuse_conn(inode);
1629 struct fuse_inode *fi = get_fuse_inode(inode);
1630 FUSE_ARGS(args);
1631 struct fuse_setattr_in inarg;
1632 struct fuse_attr_out outarg;
1633 bool is_truncate = false;
1634 bool is_wb = fc->writeback_cache;
1635 loff_t oldsize;
1636 int err;
1637 bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
1638
1639 if (!fc->default_permissions)
1640 attr->ia_valid |= ATTR_FORCE;
1641
1642 err = setattr_prepare(dentry, attr);
1643 if (err)
1644 return err;
1645
1646 if (attr->ia_valid & ATTR_OPEN) {
1647 /* This is coming from open(..., ... | O_TRUNC); */
1648 WARN_ON(!(attr->ia_valid & ATTR_SIZE));
1649 WARN_ON(attr->ia_size != 0);
1650 if (fc->atomic_o_trunc) {
1651 /*
1652 * No need to send request to userspace, since actual
1653 * truncation has already been done by OPEN. But still
1654 * need to truncate page cache.
1655 */
1656 i_size_write(inode, 0);
1657 truncate_pagecache(inode, 0);
1658 return 0;
1659 }
1660 file = NULL;
1661 }
1662
1663 if (attr->ia_valid & ATTR_SIZE)
1664 is_truncate = true;
1665
1666 if (is_truncate) {
1667 fuse_set_nowrite(inode);
1668 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1669 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1670 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1671 }
1672
1673 memset(&inarg, 0, sizeof(inarg));
1674 memset(&outarg, 0, sizeof(outarg));
1675 iattr_to_fattr(fc, attr, &inarg, trust_local_cmtime);
1676 if (file) {
1677 struct fuse_file *ff = file->private_data;
1678 inarg.valid |= FATTR_FH;
1679 inarg.fh = ff->fh;
1680 }
1681 if (attr->ia_valid & ATTR_SIZE) {
1682 /* For mandatory locking in truncate */
1683 inarg.valid |= FATTR_LOCKOWNER;
1684 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1685 }
1686 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1687 err = fuse_simple_request(fc, &args);
1688 if (err) {
1689 if (err == -EINTR)
1690 fuse_invalidate_attr(inode);
1691 goto error;
1692 }
1693
1694 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1695 make_bad_inode(inode);
1696 err = -EIO;
1697 goto error;
1698 }
1699
1700 spin_lock(&fc->lock);
1701 /* the kernel maintains i_mtime locally */
1702 if (trust_local_cmtime) {
1703 if (attr->ia_valid & ATTR_MTIME)
1704 inode->i_mtime = attr->ia_mtime;
1705 if (attr->ia_valid & ATTR_CTIME)
1706 inode->i_ctime = attr->ia_ctime;
1707 /* FIXME: clear I_DIRTY_SYNC? */
1708 }
1709
1710 fuse_change_attributes_common(inode, &outarg.attr,
1711 attr_timeout(&outarg));
1712 oldsize = inode->i_size;
1713 /* see the comment in fuse_change_attributes() */
1714 if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1715 i_size_write(inode, outarg.attr.size);
1716
1717 if (is_truncate) {
1718 /* NOTE: this may release/reacquire fc->lock */
1719 __fuse_release_nowrite(inode);
1720 }
1721 spin_unlock(&fc->lock);
1722
1723 /*
1724 * Only call invalidate_inode_pages2() after removing
1725 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1726 */
1727 if ((is_truncate || !is_wb) &&
1728 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1729 truncate_pagecache(inode, outarg.attr.size);
1730 invalidate_inode_pages2(inode->i_mapping);
1731 }
1732
1733 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1734 return 0;
1735
1736 error:
1737 if (is_truncate)
1738 fuse_release_nowrite(inode);
1739
1740 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1741 return err;
1742 }
1743
1744 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1745 {
1746 struct inode *inode = d_inode(entry);
1747 struct fuse_conn *fc = get_fuse_conn(inode);
1748 struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL;
1749 int ret;
1750
1751 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1752 return -EACCES;
1753
1754 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) {
1755 attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID |
1756 ATTR_MODE);
1757
1758 /*
1759 * The only sane way to reliably kill suid/sgid is to do it in
1760 * the userspace filesystem
1761 *
1762 * This should be done on write(), truncate() and chown().
1763 */
1764 if (!fc->handle_killpriv) {
1765 /*
1766 * ia_mode calculation may have used stale i_mode.
1767 * Refresh and recalculate.
1768 */
1769 ret = fuse_do_getattr(inode, NULL, file);
1770 if (ret)
1771 return ret;
1772
1773 attr->ia_mode = inode->i_mode;
1774 if (inode->i_mode & S_ISUID) {
1775 attr->ia_valid |= ATTR_MODE;
1776 attr->ia_mode &= ~S_ISUID;
1777 }
1778 if ((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
1779 attr->ia_valid |= ATTR_MODE;
1780 attr->ia_mode &= ~S_ISGID;
1781 }
1782 }
1783 }
1784 if (!attr->ia_valid)
1785 return 0;
1786
1787 ret = fuse_do_setattr(entry, attr, file);
1788 if (!ret) {
1789 /*
1790 * If filesystem supports acls it may have updated acl xattrs in
1791 * the filesystem, so forget cached acls for the inode.
1792 */
1793 if (fc->posix_acl)
1794 forget_all_cached_acls(inode);
1795
1796 /* Directory mode changed, may need to revalidate access */
1797 if (d_is_dir(entry) && (attr->ia_valid & ATTR_MODE))
1798 fuse_invalidate_entry_cache(entry);
1799 }
1800 return ret;
1801 }
1802
1803 static int fuse_getattr(const struct path *path, struct kstat *stat,
1804 u32 request_mask, unsigned int flags)
1805 {
1806 struct inode *inode = d_inode(path->dentry);
1807 struct fuse_conn *fc = get_fuse_conn(inode);
1808
1809 if (!fuse_allow_current_process(fc))
1810 return -EACCES;
1811
1812 return fuse_update_get_attr(inode, NULL, stat, flags);
1813 }
1814
1815 static const struct inode_operations fuse_dir_inode_operations = {
1816 .lookup = fuse_lookup,
1817 .mkdir = fuse_mkdir,
1818 .symlink = fuse_symlink,
1819 .unlink = fuse_unlink,
1820 .rmdir = fuse_rmdir,
1821 .rename = fuse_rename2,
1822 .link = fuse_link,
1823 .setattr = fuse_setattr,
1824 .create = fuse_create,
1825 .atomic_open = fuse_atomic_open,
1826 .mknod = fuse_mknod,
1827 .permission = fuse_permission,
1828 .getattr = fuse_getattr,
1829 .listxattr = fuse_listxattr,
1830 .get_acl = fuse_get_acl,
1831 .set_acl = fuse_set_acl,
1832 };
1833
1834 static const struct file_operations fuse_dir_operations = {
1835 .llseek = generic_file_llseek,
1836 .read = generic_read_dir,
1837 .iterate_shared = fuse_readdir,
1838 .open = fuse_dir_open,
1839 .release = fuse_dir_release,
1840 .fsync = fuse_dir_fsync,
1841 .unlocked_ioctl = fuse_dir_ioctl,
1842 .compat_ioctl = fuse_dir_compat_ioctl,
1843 };
1844
1845 static const struct inode_operations fuse_common_inode_operations = {
1846 .setattr = fuse_setattr,
1847 .permission = fuse_permission,
1848 .getattr = fuse_getattr,
1849 .listxattr = fuse_listxattr,
1850 .get_acl = fuse_get_acl,
1851 .set_acl = fuse_set_acl,
1852 };
1853
1854 static const struct inode_operations fuse_symlink_inode_operations = {
1855 .setattr = fuse_setattr,
1856 .get_link = fuse_get_link,
1857 .getattr = fuse_getattr,
1858 .listxattr = fuse_listxattr,
1859 };
1860
1861 void fuse_init_common(struct inode *inode)
1862 {
1863 inode->i_op = &fuse_common_inode_operations;
1864 }
1865
1866 void fuse_init_dir(struct inode *inode)
1867 {
1868 inode->i_op = &fuse_dir_inode_operations;
1869 inode->i_fop = &fuse_dir_operations;
1870 }
1871
1872 void fuse_init_symlink(struct inode *inode)
1873 {
1874 inode->i_op = &fuse_symlink_inode_operations;
1875 }
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git