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