1
2
3
4
5
6
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
19static 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
35static 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
42union fuse_dentry {
43 u64 time;
44 struct rcu_head rcu;
45};
46
47static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
48{
49 ((union fuse_dentry *) entry->d_fsdata)->time = time;
50}
51
52static inline u64 fuse_dentry_time(struct dentry *entry)
53{
54 return ((union fuse_dentry *) entry->d_fsdata)->time;
55}
56
57
58
59
60
61
62
63
64
65
66static 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
81
82
83static 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
90static u64 attr_timeout(struct fuse_attr_out *o)
91{
92 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
93}
94
95static 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
102
103
104void fuse_invalidate_attr(struct inode *inode)
105{
106 get_fuse_inode(inode)->i_time = 0;
107}
108
109
110
111
112
113void fuse_invalidate_atime(struct inode *inode)
114{
115 if (!IS_RDONLY(inode))
116 fuse_invalidate_attr(inode);
117}
118
119
120
121
122
123
124
125
126
127void fuse_invalidate_entry_cache(struct dentry *entry)
128{
129 fuse_dentry_settime(entry, 0);
130}
131
132
133
134
135
136static void fuse_invalidate_entry(struct dentry *entry)
137{
138 d_invalidate(entry);
139 fuse_invalidate_entry_cache(entry);
140}
141
142static 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
157u64 fuse_get_attr_version(struct fuse_conn *fc)
158{
159 u64 curr_version;
160
161
162
163
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
174
175
176
177
178
179
180
181static 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
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
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;
257out:
258 return ret;
259
260invalid:
261 ret = 0;
262 goto out;
263}
264
265static int invalid_nodeid(u64 nodeid)
266{
267 return !nodeid || nodeid == FUSE_ROOT_ID;
268}
269
270static 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}
276static void fuse_dentry_release(struct dentry *dentry)
277{
278 union fuse_dentry *fd = dentry->d_fsdata;
279
280 kfree_rcu(fd, rcu);
281}
282
283const 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
289const struct dentry_operations fuse_root_dentry_operations = {
290 .d_init = fuse_dentry_init,
291 .d_release = fuse_dentry_release,
292};
293
294int 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
300int 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
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
350static 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
396
397
398
399
400static int fuse_create_open(struct inode *dir, struct dentry *entry,
401 struct file *file, unsigned flags,
402 umode_t mode, int *opened)
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
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, opened);
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
481out_free_ff:
482 fuse_file_free(ff);
483out_put_forget_req:
484 kfree(forget);
485out_err:
486 return err;
487}
488
489static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
490static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
491 struct file *file, unsigned flags,
492 umode_t mode, int *opened)
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
511 *opened |= FILE_CREATED;
512
513 if (fc->no_create)
514 goto mknod;
515
516 err = fuse_create_open(dir, entry, file, flags, mode, opened);
517 if (err == -ENOSYS) {
518 fc->no_create = 1;
519 goto mknod;
520 }
521out_dput:
522 dput(res);
523 return err;
524
525mknod:
526 err = fuse_mknod(dir, entry, mode, 0);
527 if (err)
528 goto out_dput;
529no_open:
530 return finish_no_open(file, res);
531}
532
533
534
535
536static 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 int err;
543 struct fuse_forget_link *forget;
544
545 forget = fuse_alloc_forget();
546 if (!forget)
547 return -ENOMEM;
548
549 memset(&outarg, 0, sizeof(outarg));
550 args->in.h.nodeid = get_node_id(dir);
551 args->out.numargs = 1;
552 args->out.args[0].size = sizeof(outarg);
553 args->out.args[0].value = &outarg;
554 err = fuse_simple_request(fc, args);
555 if (err)
556 goto out_put_forget_req;
557
558 err = -EIO;
559 if (invalid_nodeid(outarg.nodeid))
560 goto out_put_forget_req;
561
562 if ((outarg.attr.mode ^ mode) & S_IFMT)
563 goto out_put_forget_req;
564
565 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
566 &outarg.attr, entry_attr_timeout(&outarg), 0);
567 if (!inode) {
568 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
569 return -ENOMEM;
570 }
571 kfree(forget);
572
573 err = d_instantiate_no_diralias(entry, inode);
574 if (err)
575 return err;
576
577 fuse_change_entry_timeout(entry, &outarg);
578 fuse_invalidate_attr(dir);
579 return 0;
580
581 out_put_forget_req:
582 kfree(forget);
583 return err;
584}
585
586static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
587 dev_t rdev)
588{
589 struct fuse_mknod_in inarg;
590 struct fuse_conn *fc = get_fuse_conn(dir);
591 FUSE_ARGS(args);
592
593 if (!fc->dont_mask)
594 mode &= ~current_umask();
595
596 memset(&inarg, 0, sizeof(inarg));
597 inarg.mode = mode;
598 inarg.rdev = new_encode_dev(rdev);
599 inarg.umask = current_umask();
600 args.in.h.opcode = FUSE_MKNOD;
601 args.in.numargs = 2;
602 args.in.args[0].size = sizeof(inarg);
603 args.in.args[0].value = &inarg;
604 args.in.args[1].size = entry->d_name.len + 1;
605 args.in.args[1].value = entry->d_name.name;
606 return create_new_entry(fc, &args, dir, entry, mode);
607}
608
609static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
610 bool excl)
611{
612 return fuse_mknod(dir, entry, mode, 0);
613}
614
615static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
616{
617 struct fuse_mkdir_in inarg;
618 struct fuse_conn *fc = get_fuse_conn(dir);
619 FUSE_ARGS(args);
620
621 if (!fc->dont_mask)
622 mode &= ~current_umask();
623
624 memset(&inarg, 0, sizeof(inarg));
625 inarg.mode = mode;
626 inarg.umask = current_umask();
627 args.in.h.opcode = FUSE_MKDIR;
628 args.in.numargs = 2;
629 args.in.args[0].size = sizeof(inarg);
630 args.in.args[0].value = &inarg;
631 args.in.args[1].size = entry->d_name.len + 1;
632 args.in.args[1].value = entry->d_name.name;
633 return create_new_entry(fc, &args, dir, entry, S_IFDIR);
634}
635
636static int fuse_symlink(struct inode *dir, struct dentry *entry,
637 const char *link)
638{
639 struct fuse_conn *fc = get_fuse_conn(dir);
640 unsigned len = strlen(link) + 1;
641 FUSE_ARGS(args);
642
643 args.in.h.opcode = FUSE_SYMLINK;
644 args.in.numargs = 2;
645 args.in.args[0].size = entry->d_name.len + 1;
646 args.in.args[0].value = entry->d_name.name;
647 args.in.args[1].size = len;
648 args.in.args[1].value = link;
649 return create_new_entry(fc, &args, dir, entry, S_IFLNK);
650}
651
652void fuse_update_ctime(struct inode *inode)
653{
654 if (!IS_NOCMTIME(inode)) {
655 inode->i_ctime = current_time(inode);
656 mark_inode_dirty_sync(inode);
657 }
658}
659
660static int fuse_unlink(struct inode *dir, struct dentry *entry)
661{
662 int err;
663 struct fuse_conn *fc = get_fuse_conn(dir);
664 FUSE_ARGS(args);
665
666 args.in.h.opcode = FUSE_UNLINK;
667 args.in.h.nodeid = get_node_id(dir);
668 args.in.numargs = 1;
669 args.in.args[0].size = entry->d_name.len + 1;
670 args.in.args[0].value = entry->d_name.name;
671 err = fuse_simple_request(fc, &args);
672 if (!err) {
673 struct inode *inode = d_inode(entry);
674 struct fuse_inode *fi = get_fuse_inode(inode);
675
676 spin_lock(&fc->lock);
677 fi->attr_version = ++fc->attr_version;
678
679
680
681
682
683
684 if (inode->i_nlink > 0)
685 drop_nlink(inode);
686 spin_unlock(&fc->lock);
687 fuse_invalidate_attr(inode);
688 fuse_invalidate_attr(dir);
689 fuse_invalidate_entry_cache(entry);
690 fuse_update_ctime(inode);
691 } else if (err == -EINTR)
692 fuse_invalidate_entry(entry);
693 return err;
694}
695
696static int fuse_rmdir(struct inode *dir, struct dentry *entry)
697{
698 int err;
699 struct fuse_conn *fc = get_fuse_conn(dir);
700 FUSE_ARGS(args);
701
702 args.in.h.opcode = FUSE_RMDIR;
703 args.in.h.nodeid = get_node_id(dir);
704 args.in.numargs = 1;
705 args.in.args[0].size = entry->d_name.len + 1;
706 args.in.args[0].value = entry->d_name.name;
707 err = fuse_simple_request(fc, &args);
708 if (!err) {
709 clear_nlink(d_inode(entry));
710 fuse_invalidate_attr(dir);
711 fuse_invalidate_entry_cache(entry);
712 } else if (err == -EINTR)
713 fuse_invalidate_entry(entry);
714 return err;
715}
716
717static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
718 struct inode *newdir, struct dentry *newent,
719 unsigned int flags, int opcode, size_t argsize)
720{
721 int err;
722 struct fuse_rename2_in inarg;
723 struct fuse_conn *fc = get_fuse_conn(olddir);
724 FUSE_ARGS(args);
725
726 memset(&inarg, 0, argsize);
727 inarg.newdir = get_node_id(newdir);
728 inarg.flags = flags;
729 args.in.h.opcode = opcode;
730 args.in.h.nodeid = get_node_id(olddir);
731 args.in.numargs = 3;
732 args.in.args[0].size = argsize;
733 args.in.args[0].value = &inarg;
734 args.in.args[1].size = oldent->d_name.len + 1;
735 args.in.args[1].value = oldent->d_name.name;
736 args.in.args[2].size = newent->d_name.len + 1;
737 args.in.args[2].value = newent->d_name.name;
738 err = fuse_simple_request(fc, &args);
739 if (!err) {
740
741 fuse_invalidate_attr(d_inode(oldent));
742 fuse_update_ctime(d_inode(oldent));
743
744 if (flags & RENAME_EXCHANGE) {
745 fuse_invalidate_attr(d_inode(newent));
746 fuse_update_ctime(d_inode(newent));
747 }
748
749 fuse_invalidate_attr(olddir);
750 if (olddir != newdir)
751 fuse_invalidate_attr(newdir);
752
753
754 if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
755 fuse_invalidate_attr(d_inode(newent));
756 fuse_invalidate_entry_cache(newent);
757 fuse_update_ctime(d_inode(newent));
758 }
759 } else if (err == -EINTR) {
760
761
762
763
764
765 fuse_invalidate_entry(oldent);
766 if (d_really_is_positive(newent))
767 fuse_invalidate_entry(newent);
768 }
769
770 return err;
771}
772
773static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
774 struct inode *newdir, struct dentry *newent,
775 unsigned int flags)
776{
777 struct fuse_conn *fc = get_fuse_conn(olddir);
778 int err;
779
780 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
781 return -EINVAL;
782
783 if (flags) {
784 if (fc->no_rename2 || fc->minor < 23)
785 return -EINVAL;
786
787 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
788 FUSE_RENAME2,
789 sizeof(struct fuse_rename2_in));
790 if (err == -ENOSYS) {
791 fc->no_rename2 = 1;
792 err = -EINVAL;
793 }
794 } else {
795 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
796 FUSE_RENAME,
797 sizeof(struct fuse_rename_in));
798 }
799
800 return err;
801}
802
803static int fuse_link(struct dentry *entry, struct inode *newdir,
804 struct dentry *newent)
805{
806 int err;
807 struct fuse_link_in inarg;
808 struct inode *inode = d_inode(entry);
809 struct fuse_conn *fc = get_fuse_conn(inode);
810 FUSE_ARGS(args);
811
812 memset(&inarg, 0, sizeof(inarg));
813 inarg.oldnodeid = get_node_id(inode);
814 args.in.h.opcode = FUSE_LINK;
815 args.in.numargs = 2;
816 args.in.args[0].size = sizeof(inarg);
817 args.in.args[0].value = &inarg;
818 args.in.args[1].size = newent->d_name.len + 1;
819 args.in.args[1].value = newent->d_name.name;
820 err = create_new_entry(fc, &args, newdir, newent, inode->i_mode);
821
822
823
824
825
826
827 if (!err) {
828 struct fuse_inode *fi = get_fuse_inode(inode);
829
830 spin_lock(&fc->lock);
831 fi->attr_version = ++fc->attr_version;
832 inc_nlink(inode);
833 spin_unlock(&fc->lock);
834 fuse_invalidate_attr(inode);
835 fuse_update_ctime(inode);
836 } else if (err == -EINTR) {
837 fuse_invalidate_attr(inode);
838 }
839 return err;
840}
841
842static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
843 struct kstat *stat)
844{
845 unsigned int blkbits;
846 struct fuse_conn *fc = get_fuse_conn(inode);
847
848
849 if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
850 attr->size = i_size_read(inode);
851 attr->mtime = inode->i_mtime.tv_sec;
852 attr->mtimensec = inode->i_mtime.tv_nsec;
853 attr->ctime = inode->i_ctime.tv_sec;
854 attr->ctimensec = inode->i_ctime.tv_nsec;
855 }
856
857 stat->dev = inode->i_sb->s_dev;
858 stat->ino = attr->ino;
859 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
860 stat->nlink = attr->nlink;
861 stat->uid = make_kuid(fc->user_ns, attr->uid);
862 stat->gid = make_kgid(fc->user_ns, attr->gid);
863 stat->rdev = inode->i_rdev;
864 stat->atime.tv_sec = attr->atime;
865 stat->atime.tv_nsec = attr->atimensec;
866 stat->mtime.tv_sec = attr->mtime;
867 stat->mtime.tv_nsec = attr->mtimensec;
868 stat->ctime.tv_sec = attr->ctime;
869 stat->ctime.tv_nsec = attr->ctimensec;
870 stat->size = attr->size;
871 stat->blocks = attr->blocks;
872
873 if (attr->blksize != 0)
874 blkbits = ilog2(attr->blksize);
875 else
876 blkbits = inode->i_sb->s_blocksize_bits;
877
878 stat->blksize = 1 << blkbits;
879}
880
881static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
882 struct file *file)
883{
884 int err;
885 struct fuse_getattr_in inarg;
886 struct fuse_attr_out outarg;
887 struct fuse_conn *fc = get_fuse_conn(inode);
888 FUSE_ARGS(args);
889 u64 attr_version;
890
891 attr_version = fuse_get_attr_version(fc);
892
893 memset(&inarg, 0, sizeof(inarg));
894 memset(&outarg, 0, sizeof(outarg));
895
896 if (file && S_ISREG(inode->i_mode)) {
897 struct fuse_file *ff = file->private_data;
898
899 inarg.getattr_flags |= FUSE_GETATTR_FH;
900 inarg.fh = ff->fh;
901 }
902 args.in.h.opcode = FUSE_GETATTR;
903 args.in.h.nodeid = get_node_id(inode);
904 args.in.numargs = 1;
905 args.in.args[0].size = sizeof(inarg);
906 args.in.args[0].value = &inarg;
907 args.out.numargs = 1;
908 args.out.args[0].size = sizeof(outarg);
909 args.out.args[0].value = &outarg;
910 err = fuse_simple_request(fc, &args);
911 if (!err) {
912 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
913 make_bad_inode(inode);
914 err = -EIO;
915 } else {
916 fuse_change_attributes(inode, &outarg.attr,
917 attr_timeout(&outarg),
918 attr_version);
919 if (stat)
920 fuse_fillattr(inode, &outarg.attr, stat);
921 }
922 }
923 return err;
924}
925
926static int fuse_update_get_attr(struct inode *inode, struct file *file,
927 struct kstat *stat, unsigned int flags)
928{
929 struct fuse_inode *fi = get_fuse_inode(inode);
930 int err = 0;
931 bool sync;
932
933 if (flags & AT_STATX_FORCE_SYNC)
934 sync = true;
935 else if (flags & AT_STATX_DONT_SYNC)
936 sync = false;
937 else
938 sync = time_before64(fi->i_time, get_jiffies_64());
939
940 if (sync) {
941 forget_all_cached_acls(inode);
942 err = fuse_do_getattr(inode, stat, file);
943 } else if (stat) {
944 generic_fillattr(inode, stat);
945 stat->mode = fi->orig_i_mode;
946 stat->ino = fi->orig_ino;
947 }
948
949 return err;
950}
951
952int fuse_update_attributes(struct inode *inode, struct file *file)
953{
954 return fuse_update_get_attr(inode, file, NULL, 0);
955}
956
957int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
958 u64 child_nodeid, struct qstr *name)
959{
960 int err = -ENOTDIR;
961 struct inode *parent;
962 struct dentry *dir;
963 struct dentry *entry;
964
965 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
966 if (!parent)
967 return -ENOENT;
968
969 inode_lock(parent);
970 if (!S_ISDIR(parent->i_mode))
971 goto unlock;
972
973 err = -ENOENT;
974 dir = d_find_alias(parent);
975 if (!dir)
976 goto unlock;
977
978 name->hash = full_name_hash(dir, name->name, name->len);
979 entry = d_lookup(dir, name);
980 dput(dir);
981 if (!entry)
982 goto unlock;
983
984 fuse_invalidate_attr(parent);
985 fuse_invalidate_entry(entry);
986
987 if (child_nodeid != 0 && d_really_is_positive(entry)) {
988 inode_lock(d_inode(entry));
989 if (get_node_id(d_inode(entry)) != child_nodeid) {
990 err = -ENOENT;
991 goto badentry;
992 }
993 if (d_mountpoint(entry)) {
994 err = -EBUSY;
995 goto badentry;
996 }
997 if (d_is_dir(entry)) {
998 shrink_dcache_parent(entry);
999 if (!simple_empty(entry)) {
1000 err = -ENOTEMPTY;
1001 goto badentry;
1002 }
1003 d_inode(entry)->i_flags |= S_DEAD;
1004 }
1005 dont_mount(entry);
1006 clear_nlink(d_inode(entry));
1007 err = 0;
1008 badentry:
1009 inode_unlock(d_inode(entry));
1010 if (!err)
1011 d_delete(entry);
1012 } else {
1013 err = 0;
1014 }
1015 dput(entry);
1016
1017 unlock:
1018 inode_unlock(parent);
1019 iput(parent);
1020 return err;
1021}
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036int fuse_allow_current_process(struct fuse_conn *fc)
1037{
1038 const struct cred *cred;
1039
1040 if (fc->allow_other)
1041 return current_in_userns(fc->user_ns);
1042
1043 cred = current_cred();
1044 if (uid_eq(cred->euid, fc->user_id) &&
1045 uid_eq(cred->suid, fc->user_id) &&
1046 uid_eq(cred->uid, fc->user_id) &&
1047 gid_eq(cred->egid, fc->group_id) &&
1048 gid_eq(cred->sgid, fc->group_id) &&
1049 gid_eq(cred->gid, fc->group_id))
1050 return 1;
1051
1052 return 0;
1053}
1054
1055static int fuse_access(struct inode *inode, int mask)
1056{
1057 struct fuse_conn *fc = get_fuse_conn(inode);
1058 FUSE_ARGS(args);
1059 struct fuse_access_in inarg;
1060 int err;
1061
1062 BUG_ON(mask & MAY_NOT_BLOCK);
1063
1064 if (fc->no_access)
1065 return 0;
1066
1067 memset(&inarg, 0, sizeof(inarg));
1068 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1069 args.in.h.opcode = FUSE_ACCESS;
1070 args.in.h.nodeid = get_node_id(inode);
1071 args.in.numargs = 1;
1072 args.in.args[0].size = sizeof(inarg);
1073 args.in.args[0].value = &inarg;
1074 err = fuse_simple_request(fc, &args);
1075 if (err == -ENOSYS) {
1076 fc->no_access = 1;
1077 err = 0;
1078 }
1079 return err;
1080}
1081
1082static int fuse_perm_getattr(struct inode *inode, int mask)
1083{
1084 if (mask & MAY_NOT_BLOCK)
1085 return -ECHILD;
1086
1087 forget_all_cached_acls(inode);
1088 return fuse_do_getattr(inode, NULL, NULL);
1089}
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104static int fuse_permission(struct inode *inode, int mask)
1105{
1106 struct fuse_conn *fc = get_fuse_conn(inode);
1107 bool refreshed = false;
1108 int err = 0;
1109
1110 if (!fuse_allow_current_process(fc))
1111 return -EACCES;
1112
1113
1114
1115
1116 if (fc->default_permissions ||
1117 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1118 struct fuse_inode *fi = get_fuse_inode(inode);
1119
1120 if (time_before64(fi->i_time, get_jiffies_64())) {
1121 refreshed = true;
1122
1123 err = fuse_perm_getattr(inode, mask);
1124 if (err)
1125 return err;
1126 }
1127 }
1128
1129 if (fc->default_permissions) {
1130 err = generic_permission(inode, mask);
1131
1132
1133
1134
1135 if (err == -EACCES && !refreshed) {
1136 err = fuse_perm_getattr(inode, mask);
1137 if (!err)
1138 err = generic_permission(inode, mask);
1139 }
1140
1141
1142
1143
1144
1145 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1146 err = fuse_access(inode, mask);
1147 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1148 if (!(inode->i_mode & S_IXUGO)) {
1149 if (refreshed)
1150 return -EACCES;
1151
1152 err = fuse_perm_getattr(inode, mask);
1153 if (!err && !(inode->i_mode & S_IXUGO))
1154 return -EACCES;
1155 }
1156 }
1157 return err;
1158}
1159
1160static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1161 struct dir_context *ctx)
1162{
1163 while (nbytes >= FUSE_NAME_OFFSET) {
1164 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1165 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1166 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1167 return -EIO;
1168 if (reclen > nbytes)
1169 break;
1170 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1171 return -EIO;
1172
1173 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1174 dirent->ino, dirent->type))
1175 break;
1176
1177 buf += reclen;
1178 nbytes -= reclen;
1179 ctx->pos = dirent->off;
1180 }
1181
1182 return 0;
1183}
1184
1185static int fuse_direntplus_link(struct file *file,
1186 struct fuse_direntplus *direntplus,
1187 u64 attr_version)
1188{
1189 struct fuse_entry_out *o = &direntplus->entry_out;
1190 struct fuse_dirent *dirent = &direntplus->dirent;
1191 struct dentry *parent = file->f_path.dentry;
1192 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1193 struct dentry *dentry;
1194 struct dentry *alias;
1195 struct inode *dir = d_inode(parent);
1196 struct fuse_conn *fc;
1197 struct inode *inode;
1198 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1199
1200 if (!o->nodeid) {
1201
1202
1203
1204
1205
1206
1207
1208 return 0;
1209 }
1210
1211 if (name.name[0] == '.') {
1212
1213
1214
1215
1216 if (name.len == 1)
1217 return 0;
1218 if (name.name[1] == '.' && name.len == 2)
1219 return 0;
1220 }
1221
1222 if (invalid_nodeid(o->nodeid))
1223 return -EIO;
1224 if (!fuse_valid_type(o->attr.mode))
1225 return -EIO;
1226
1227 fc = get_fuse_conn(dir);
1228
1229 name.hash = full_name_hash(parent, name.name, name.len);
1230 dentry = d_lookup(parent, &name);
1231 if (!dentry) {
1232retry:
1233 dentry = d_alloc_parallel(parent, &name, &wq);
1234 if (IS_ERR(dentry))
1235 return PTR_ERR(dentry);
1236 }
1237 if (!d_in_lookup(dentry)) {
1238 struct fuse_inode *fi;
1239 inode = d_inode(dentry);
1240 if (!inode ||
1241 get_node_id(inode) != o->nodeid ||
1242 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1243 d_invalidate(dentry);
1244 dput(dentry);
1245 goto retry;
1246 }
1247 if (is_bad_inode(inode)) {
1248 dput(dentry);
1249 return -EIO;
1250 }
1251
1252 fi = get_fuse_inode(inode);
1253 spin_lock(&fc->lock);
1254 fi->nlookup++;
1255 spin_unlock(&fc->lock);
1256
1257 forget_all_cached_acls(inode);
1258 fuse_change_attributes(inode, &o->attr,
1259 entry_attr_timeout(o),
1260 attr_version);
1261
1262
1263
1264
1265 } else {
1266 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1267 &o->attr, entry_attr_timeout(o),
1268 attr_version);
1269 if (!inode)
1270 inode = ERR_PTR(-ENOMEM);
1271
1272 alias = d_splice_alias(inode, dentry);
1273 d_lookup_done(dentry);
1274 if (alias) {
1275 dput(dentry);
1276 dentry = alias;
1277 }
1278 if (IS_ERR(dentry))
1279 return PTR_ERR(dentry);
1280 }
1281 if (fc->readdirplus_auto)
1282 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1283 fuse_change_entry_timeout(dentry, o);
1284
1285 dput(dentry);
1286 return 0;
1287}
1288
1289static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1290 struct dir_context *ctx, u64 attr_version)
1291{
1292 struct fuse_direntplus *direntplus;
1293 struct fuse_dirent *dirent;
1294 size_t reclen;
1295 int over = 0;
1296 int ret;
1297
1298 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1299 direntplus = (struct fuse_direntplus *) buf;
1300 dirent = &direntplus->dirent;
1301 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1302
1303 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1304 return -EIO;
1305 if (reclen > nbytes)
1306 break;
1307 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1308 return -EIO;
1309
1310 if (!over) {
1311
1312
1313
1314
1315
1316
1317 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1318 dirent->ino, dirent->type);
1319 if (!over)
1320 ctx->pos = dirent->off;
1321 }
1322
1323 buf += reclen;
1324 nbytes -= reclen;
1325
1326 ret = fuse_direntplus_link(file, direntplus, attr_version);
1327 if (ret)
1328 fuse_force_forget(file, direntplus->entry_out.nodeid);
1329 }
1330
1331 return 0;
1332}
1333
1334static int fuse_readdir(struct file *file, struct dir_context *ctx)
1335{
1336 int plus, err;
1337 size_t nbytes;
1338 struct page *page;
1339 struct inode *inode = file_inode(file);
1340 struct fuse_conn *fc = get_fuse_conn(inode);
1341 struct fuse_req *req;
1342 u64 attr_version = 0;
1343
1344 if (is_bad_inode(inode))
1345 return -EIO;
1346
1347 req = fuse_get_req(fc, 1);
1348 if (IS_ERR(req))
1349 return PTR_ERR(req);
1350
1351 page = alloc_page(GFP_KERNEL);
1352 if (!page) {
1353 fuse_put_request(fc, req);
1354 return -ENOMEM;
1355 }
1356
1357 plus = fuse_use_readdirplus(inode, ctx);
1358 req->out.argpages = 1;
1359 req->num_pages = 1;
1360 req->pages[0] = page;
1361 req->page_descs[0].length = PAGE_SIZE;
1362 if (plus) {
1363 attr_version = fuse_get_attr_version(fc);
1364 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1365 FUSE_READDIRPLUS);
1366 } else {
1367 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1368 FUSE_READDIR);
1369 }
1370 fuse_lock_inode(inode);
1371 fuse_request_send(fc, req);
1372 fuse_unlock_inode(inode);
1373 nbytes = req->out.args[0].size;
1374 err = req->out.h.error;
1375 fuse_put_request(fc, req);
1376 if (!err) {
1377 if (plus) {
1378 err = parse_dirplusfile(page_address(page), nbytes,
1379 file, ctx,
1380 attr_version);
1381 } else {
1382 err = parse_dirfile(page_address(page), nbytes, file,
1383 ctx);
1384 }
1385 }
1386
1387 __free_page(page);
1388 fuse_invalidate_atime(inode);
1389 return err;
1390}
1391
1392static const char *fuse_get_link(struct dentry *dentry,
1393 struct inode *inode,
1394 struct delayed_call *done)
1395{
1396 struct fuse_conn *fc = get_fuse_conn(inode);
1397 FUSE_ARGS(args);
1398 char *link;
1399 ssize_t ret;
1400
1401 if (!dentry)
1402 return ERR_PTR(-ECHILD);
1403
1404 link = kmalloc(PAGE_SIZE, GFP_KERNEL);
1405 if (!link)
1406 return ERR_PTR(-ENOMEM);
1407
1408 args.in.h.opcode = FUSE_READLINK;
1409 args.in.h.nodeid = get_node_id(inode);
1410 args.out.argvar = 1;
1411 args.out.numargs = 1;
1412 args.out.args[0].size = PAGE_SIZE - 1;
1413 args.out.args[0].value = link;
1414 ret = fuse_simple_request(fc, &args);
1415 if (ret < 0) {
1416 kfree(link);
1417 link = ERR_PTR(ret);
1418 } else {
1419 link[ret] = '\0';
1420 set_delayed_call(done, kfree_link, link);
1421 }
1422 fuse_invalidate_atime(inode);
1423 return link;
1424}
1425
1426static int fuse_dir_open(struct inode *inode, struct file *file)
1427{
1428 return fuse_open_common(inode, file, true);
1429}
1430
1431static int fuse_dir_release(struct inode *inode, struct file *file)
1432{
1433 fuse_release_common(file, FUSE_RELEASEDIR);
1434
1435 return 0;
1436}
1437
1438static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1439 int datasync)
1440{
1441 return fuse_fsync_common(file, start, end, datasync, 1);
1442}
1443
1444static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1445 unsigned long arg)
1446{
1447 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1448
1449
1450 if (fc->minor < 18)
1451 return -ENOTTY;
1452
1453 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1454}
1455
1456static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1457 unsigned long arg)
1458{
1459 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1460
1461 if (fc->minor < 18)
1462 return -ENOTTY;
1463
1464 return fuse_ioctl_common(file, cmd, arg,
1465 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1466}
1467
1468static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1469{
1470
1471 if (ivalid & ATTR_MTIME_SET)
1472 return true;
1473
1474
1475 if (trust_local_mtime)
1476 return true;
1477
1478
1479 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1480 return false;
1481
1482
1483 return true;
1484}
1485
1486static void iattr_to_fattr(struct fuse_conn *fc, struct iattr *iattr,
1487 struct fuse_setattr_in *arg, bool trust_local_cmtime)
1488{
1489 unsigned ivalid = iattr->ia_valid;
1490
1491 if (ivalid & ATTR_MODE)
1492 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1493 if (ivalid & ATTR_UID)
1494 arg->valid |= FATTR_UID, arg->uid = from_kuid(fc->user_ns, iattr->ia_uid);
1495 if (ivalid & ATTR_GID)
1496 arg->valid |= FATTR_GID, arg->gid = from_kgid(fc->user_ns, iattr->ia_gid);
1497 if (ivalid & ATTR_SIZE)
1498 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1499 if (ivalid & ATTR_ATIME) {
1500 arg->valid |= FATTR_ATIME;
1501 arg->atime = iattr->ia_atime.tv_sec;
1502 arg->atimensec = iattr->ia_atime.tv_nsec;
1503 if (!(ivalid & ATTR_ATIME_SET))
1504 arg->valid |= FATTR_ATIME_NOW;
1505 }
1506 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1507 arg->valid |= FATTR_MTIME;
1508 arg->mtime = iattr->ia_mtime.tv_sec;
1509 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1510 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1511 arg->valid |= FATTR_MTIME_NOW;
1512 }
1513 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1514 arg->valid |= FATTR_CTIME;
1515 arg->ctime = iattr->ia_ctime.tv_sec;
1516 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1517 }
1518}
1519
1520
1521
1522
1523
1524
1525
1526void fuse_set_nowrite(struct inode *inode)
1527{
1528 struct fuse_conn *fc = get_fuse_conn(inode);
1529 struct fuse_inode *fi = get_fuse_inode(inode);
1530
1531 BUG_ON(!inode_is_locked(inode));
1532
1533 spin_lock(&fc->lock);
1534 BUG_ON(fi->writectr < 0);
1535 fi->writectr += FUSE_NOWRITE;
1536 spin_unlock(&fc->lock);
1537 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1538}
1539
1540
1541
1542
1543
1544
1545
1546static void __fuse_release_nowrite(struct inode *inode)
1547{
1548 struct fuse_inode *fi = get_fuse_inode(inode);
1549
1550 BUG_ON(fi->writectr != FUSE_NOWRITE);
1551 fi->writectr = 0;
1552 fuse_flush_writepages(inode);
1553}
1554
1555void fuse_release_nowrite(struct inode *inode)
1556{
1557 struct fuse_conn *fc = get_fuse_conn(inode);
1558
1559 spin_lock(&fc->lock);
1560 __fuse_release_nowrite(inode);
1561 spin_unlock(&fc->lock);
1562}
1563
1564static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
1565 struct inode *inode,
1566 struct fuse_setattr_in *inarg_p,
1567 struct fuse_attr_out *outarg_p)
1568{
1569 args->in.h.opcode = FUSE_SETATTR;
1570 args->in.h.nodeid = get_node_id(inode);
1571 args->in.numargs = 1;
1572 args->in.args[0].size = sizeof(*inarg_p);
1573 args->in.args[0].value = inarg_p;
1574 args->out.numargs = 1;
1575 args->out.args[0].size = sizeof(*outarg_p);
1576 args->out.args[0].value = outarg_p;
1577}
1578
1579
1580
1581
1582int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1583{
1584 struct fuse_conn *fc = get_fuse_conn(inode);
1585 FUSE_ARGS(args);
1586 struct fuse_setattr_in inarg;
1587 struct fuse_attr_out outarg;
1588
1589 memset(&inarg, 0, sizeof(inarg));
1590 memset(&outarg, 0, sizeof(outarg));
1591
1592 inarg.valid = FATTR_MTIME;
1593 inarg.mtime = inode->i_mtime.tv_sec;
1594 inarg.mtimensec = inode->i_mtime.tv_nsec;
1595 if (fc->minor >= 23) {
1596 inarg.valid |= FATTR_CTIME;
1597 inarg.ctime = inode->i_ctime.tv_sec;
1598 inarg.ctimensec = inode->i_ctime.tv_nsec;
1599 }
1600 if (ff) {
1601 inarg.valid |= FATTR_FH;
1602 inarg.fh = ff->fh;
1603 }
1604 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1605
1606 return fuse_simple_request(fc, &args);
1607}
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
1618 struct file *file)
1619{
1620 struct inode *inode = d_inode(dentry);
1621 struct fuse_conn *fc = get_fuse_conn(inode);
1622 struct fuse_inode *fi = get_fuse_inode(inode);
1623 FUSE_ARGS(args);
1624 struct fuse_setattr_in inarg;
1625 struct fuse_attr_out outarg;
1626 bool is_truncate = false;
1627 bool is_wb = fc->writeback_cache;
1628 loff_t oldsize;
1629 int err;
1630 bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
1631
1632 if (!fc->default_permissions)
1633 attr->ia_valid |= ATTR_FORCE;
1634
1635 err = setattr_prepare(dentry, attr);
1636 if (err)
1637 return err;
1638
1639 if (attr->ia_valid & ATTR_OPEN) {
1640
1641 WARN_ON(!(attr->ia_valid & ATTR_SIZE));
1642 WARN_ON(attr->ia_size != 0);
1643 if (fc->atomic_o_trunc) {
1644
1645
1646
1647
1648
1649 i_size_write(inode, 0);
1650 truncate_pagecache(inode, 0);
1651 return 0;
1652 }
1653 file = NULL;
1654 }
1655
1656 if (attr->ia_valid & ATTR_SIZE)
1657 is_truncate = true;
1658
1659 if (is_truncate) {
1660 fuse_set_nowrite(inode);
1661 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1662 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1663 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1664 }
1665
1666 memset(&inarg, 0, sizeof(inarg));
1667 memset(&outarg, 0, sizeof(outarg));
1668 iattr_to_fattr(fc, attr, &inarg, trust_local_cmtime);
1669 if (file) {
1670 struct fuse_file *ff = file->private_data;
1671 inarg.valid |= FATTR_FH;
1672 inarg.fh = ff->fh;
1673 }
1674 if (attr->ia_valid & ATTR_SIZE) {
1675
1676 inarg.valid |= FATTR_LOCKOWNER;
1677 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1678 }
1679 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1680 err = fuse_simple_request(fc, &args);
1681 if (err) {
1682 if (err == -EINTR)
1683 fuse_invalidate_attr(inode);
1684 goto error;
1685 }
1686
1687 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1688 make_bad_inode(inode);
1689 err = -EIO;
1690 goto error;
1691 }
1692
1693 spin_lock(&fc->lock);
1694
1695 if (trust_local_cmtime) {
1696 if (attr->ia_valid & ATTR_MTIME)
1697 inode->i_mtime = attr->ia_mtime;
1698 if (attr->ia_valid & ATTR_CTIME)
1699 inode->i_ctime = attr->ia_ctime;
1700
1701 }
1702
1703 fuse_change_attributes_common(inode, &outarg.attr,
1704 attr_timeout(&outarg));
1705 oldsize = inode->i_size;
1706
1707 if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1708 i_size_write(inode, outarg.attr.size);
1709
1710 if (is_truncate) {
1711
1712 __fuse_release_nowrite(inode);
1713 }
1714 spin_unlock(&fc->lock);
1715
1716
1717
1718
1719
1720 if ((is_truncate || !is_wb) &&
1721 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1722 truncate_pagecache(inode, outarg.attr.size);
1723 invalidate_inode_pages2(inode->i_mapping);
1724 }
1725
1726 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1727 return 0;
1728
1729error:
1730 if (is_truncate)
1731 fuse_release_nowrite(inode);
1732
1733 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1734 return err;
1735}
1736
1737static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1738{
1739 struct inode *inode = d_inode(entry);
1740 struct fuse_conn *fc = get_fuse_conn(inode);
1741 struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL;
1742 int ret;
1743
1744 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1745 return -EACCES;
1746
1747 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) {
1748 attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID |
1749 ATTR_MODE);
1750
1751
1752
1753
1754
1755
1756
1757 if (!fc->handle_killpriv) {
1758
1759
1760
1761
1762 ret = fuse_do_getattr(inode, NULL, file);
1763 if (ret)
1764 return ret;
1765
1766 attr->ia_mode = inode->i_mode;
1767 if (inode->i_mode & S_ISUID) {
1768 attr->ia_valid |= ATTR_MODE;
1769 attr->ia_mode &= ~S_ISUID;
1770 }
1771 if ((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
1772 attr->ia_valid |= ATTR_MODE;
1773 attr->ia_mode &= ~S_ISGID;
1774 }
1775 }
1776 }
1777 if (!attr->ia_valid)
1778 return 0;
1779
1780 ret = fuse_do_setattr(entry, attr, file);
1781 if (!ret) {
1782
1783
1784
1785
1786 if (fc->posix_acl)
1787 forget_all_cached_acls(inode);
1788
1789
1790 if (d_is_dir(entry) && (attr->ia_valid & ATTR_MODE))
1791 fuse_invalidate_entry_cache(entry);
1792 }
1793 return ret;
1794}
1795
1796static int fuse_getattr(const struct path *path, struct kstat *stat,
1797 u32 request_mask, unsigned int flags)
1798{
1799 struct inode *inode = d_inode(path->dentry);
1800 struct fuse_conn *fc = get_fuse_conn(inode);
1801
1802 if (!fuse_allow_current_process(fc))
1803 return -EACCES;
1804
1805 return fuse_update_get_attr(inode, NULL, stat, flags);
1806}
1807
1808static const struct inode_operations fuse_dir_inode_operations = {
1809 .lookup = fuse_lookup,
1810 .mkdir = fuse_mkdir,
1811 .symlink = fuse_symlink,
1812 .unlink = fuse_unlink,
1813 .rmdir = fuse_rmdir,
1814 .rename = fuse_rename2,
1815 .link = fuse_link,
1816 .setattr = fuse_setattr,
1817 .create = fuse_create,
1818 .atomic_open = fuse_atomic_open,
1819 .mknod = fuse_mknod,
1820 .permission = fuse_permission,
1821 .getattr = fuse_getattr,
1822 .listxattr = fuse_listxattr,
1823 .get_acl = fuse_get_acl,
1824 .set_acl = fuse_set_acl,
1825};
1826
1827static const struct file_operations fuse_dir_operations = {
1828 .llseek = generic_file_llseek,
1829 .read = generic_read_dir,
1830 .iterate_shared = fuse_readdir,
1831 .open = fuse_dir_open,
1832 .release = fuse_dir_release,
1833 .fsync = fuse_dir_fsync,
1834 .unlocked_ioctl = fuse_dir_ioctl,
1835 .compat_ioctl = fuse_dir_compat_ioctl,
1836};
1837
1838static const struct inode_operations fuse_common_inode_operations = {
1839 .setattr = fuse_setattr,
1840 .permission = fuse_permission,
1841 .getattr = fuse_getattr,
1842 .listxattr = fuse_listxattr,
1843 .get_acl = fuse_get_acl,
1844 .set_acl = fuse_set_acl,
1845};
1846
1847static const struct inode_operations fuse_symlink_inode_operations = {
1848 .setattr = fuse_setattr,
1849 .get_link = fuse_get_link,
1850 .getattr = fuse_getattr,
1851 .listxattr = fuse_listxattr,
1852};
1853
1854void fuse_init_common(struct inode *inode)
1855{
1856 inode->i_op = &fuse_common_inode_operations;
1857}
1858
1859void fuse_init_dir(struct inode *inode)
1860{
1861 inode->i_op = &fuse_dir_inode_operations;
1862 inode->i_fop = &fuse_dir_operations;
1863}
1864
1865void fuse_init_symlink(struct inode *inode)
1866{
1867 inode->i_op = &fuse_symlink_inode_operations;
1868}
1869