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
17static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
18{
19 struct fuse_conn *fc = get_fuse_conn(dir);
20 struct fuse_inode *fi = get_fuse_inode(dir);
21
22 if (!fc->do_readdirplus)
23 return false;
24 if (!fc->readdirplus_auto)
25 return true;
26 if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
27 return true;
28 if (ctx->pos == 0)
29 return true;
30 return false;
31}
32
33static void fuse_advise_use_readdirplus(struct inode *dir)
34{
35 struct fuse_inode *fi = get_fuse_inode(dir);
36
37 set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
38}
39
40#if BITS_PER_LONG >= 64
41static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
42{
43 entry->d_time = time;
44}
45
46static inline u64 fuse_dentry_time(struct dentry *entry)
47{
48 return entry->d_time;
49}
50#else
51
52
53
54static void fuse_dentry_settime(struct dentry *entry, u64 time)
55{
56 entry->d_time = time;
57 entry->d_fsdata = (void *) (unsigned long) (time >> 32);
58}
59
60static u64 fuse_dentry_time(struct dentry *entry)
61{
62 return (u64) entry->d_time +
63 ((u64) (unsigned long) entry->d_fsdata << 32);
64}
65#endif
66
67
68
69
70
71
72
73
74
75
76static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
77{
78 if (sec || nsec) {
79 struct timespec ts = {sec, nsec};
80 return get_jiffies_64() + timespec_to_jiffies(&ts);
81 } else
82 return 0;
83}
84
85
86
87
88
89static void fuse_change_entry_timeout(struct dentry *entry,
90 struct fuse_entry_out *o)
91{
92 fuse_dentry_settime(entry,
93 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
94}
95
96static u64 attr_timeout(struct fuse_attr_out *o)
97{
98 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
99}
100
101static u64 entry_attr_timeout(struct fuse_entry_out *o)
102{
103 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
104}
105
106
107
108
109
110void fuse_invalidate_attr(struct inode *inode)
111{
112 get_fuse_inode(inode)->i_time = 0;
113}
114
115
116
117
118
119void fuse_invalidate_atime(struct inode *inode)
120{
121 if (!IS_RDONLY(inode))
122 fuse_invalidate_attr(inode);
123}
124
125
126
127
128
129
130
131
132
133void fuse_invalidate_entry_cache(struct dentry *entry)
134{
135 fuse_dentry_settime(entry, 0);
136}
137
138
139
140
141
142static void fuse_invalidate_entry(struct dentry *entry)
143{
144 d_invalidate(entry);
145 fuse_invalidate_entry_cache(entry);
146}
147
148static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
149 u64 nodeid, struct qstr *name,
150 struct fuse_entry_out *outarg)
151{
152 memset(outarg, 0, sizeof(struct fuse_entry_out));
153 req->in.h.opcode = FUSE_LOOKUP;
154 req->in.h.nodeid = nodeid;
155 req->in.numargs = 1;
156 req->in.args[0].size = name->len + 1;
157 req->in.args[0].value = name->name;
158 req->out.numargs = 1;
159 if (fc->minor < 9)
160 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
161 else
162 req->out.args[0].size = sizeof(struct fuse_entry_out);
163 req->out.args[0].value = outarg;
164}
165
166u64 fuse_get_attr_version(struct fuse_conn *fc)
167{
168 u64 curr_version;
169
170
171
172
173
174 spin_lock(&fc->lock);
175 curr_version = fc->attr_version;
176 spin_unlock(&fc->lock);
177
178 return curr_version;
179}
180
181
182
183
184
185
186
187
188
189
190static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
191{
192 struct inode *inode;
193 struct dentry *parent;
194 struct fuse_conn *fc;
195 struct fuse_inode *fi;
196 int ret;
197
198 inode = ACCESS_ONCE(entry->d_inode);
199 if (inode && is_bad_inode(inode))
200 goto invalid;
201 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
202 (flags & LOOKUP_REVAL)) {
203 int err;
204 struct fuse_entry_out outarg;
205 struct fuse_req *req;
206 struct fuse_forget_link *forget;
207 u64 attr_version;
208
209
210 if (!inode)
211 goto invalid;
212
213 ret = -ECHILD;
214 if (flags & LOOKUP_RCU)
215 goto out;
216
217 fc = get_fuse_conn(inode);
218 req = fuse_get_req_nopages(fc);
219 ret = PTR_ERR(req);
220 if (IS_ERR(req))
221 goto out;
222
223 forget = fuse_alloc_forget();
224 if (!forget) {
225 fuse_put_request(fc, req);
226 ret = -ENOMEM;
227 goto out;
228 }
229
230 attr_version = fuse_get_attr_version(fc);
231
232 parent = dget_parent(entry);
233 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
234 &entry->d_name, &outarg);
235 fuse_request_send(fc, req);
236 dput(parent);
237 err = req->out.h.error;
238 fuse_put_request(fc, req);
239
240 if (!err && !outarg.nodeid)
241 err = -ENOENT;
242 if (!err) {
243 fi = get_fuse_inode(inode);
244 if (outarg.nodeid != get_node_id(inode)) {
245 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
246 goto invalid;
247 }
248 spin_lock(&fc->lock);
249 fi->nlookup++;
250 spin_unlock(&fc->lock);
251 }
252 kfree(forget);
253 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
254 goto invalid;
255
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(parent->d_inode);
268 dput(parent);
269 }
270 }
271 ret = 1;
272out:
273 return ret;
274
275invalid:
276 ret = 0;
277
278 if (!(flags & LOOKUP_RCU) && check_submounts_and_drop(entry) != 0)
279 ret = 1;
280 goto out;
281}
282
283static int invalid_nodeid(u64 nodeid)
284{
285 return !nodeid || nodeid == FUSE_ROOT_ID;
286}
287
288const struct dentry_operations fuse_dentry_operations = {
289 .d_revalidate = fuse_dentry_revalidate,
290};
291
292int fuse_valid_type(int m)
293{
294 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
295 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
296}
297
298int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
299 struct fuse_entry_out *outarg, struct inode **inode)
300{
301 struct fuse_conn *fc = get_fuse_conn_super(sb);
302 struct fuse_req *req;
303 struct fuse_forget_link *forget;
304 u64 attr_version;
305 int err;
306
307 *inode = NULL;
308 err = -ENAMETOOLONG;
309 if (name->len > FUSE_NAME_MAX)
310 goto out;
311
312 req = fuse_get_req_nopages(fc);
313 err = PTR_ERR(req);
314 if (IS_ERR(req))
315 goto out;
316
317 forget = fuse_alloc_forget();
318 err = -ENOMEM;
319 if (!forget) {
320 fuse_put_request(fc, req);
321 goto out;
322 }
323
324 attr_version = fuse_get_attr_version(fc);
325
326 fuse_lookup_init(fc, req, nodeid, name, outarg);
327 fuse_request_send(fc, req);
328 err = req->out.h.error;
329 fuse_put_request(fc, req);
330
331 if (err || !outarg->nodeid)
332 goto out_put_forget;
333
334 err = -EIO;
335 if (!outarg->nodeid)
336 goto out_put_forget;
337 if (!fuse_valid_type(outarg->attr.mode))
338 goto out_put_forget;
339
340 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
341 &outarg->attr, entry_attr_timeout(outarg),
342 attr_version);
343 err = -ENOMEM;
344 if (!*inode) {
345 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
346 goto out;
347 }
348 err = 0;
349
350 out_put_forget:
351 kfree(forget);
352 out:
353 return err;
354}
355
356static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
357 unsigned int flags)
358{
359 int err;
360 struct fuse_entry_out outarg;
361 struct inode *inode;
362 struct dentry *newent;
363 bool outarg_valid = true;
364
365 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
366 &outarg, &inode);
367 if (err == -ENOENT) {
368 outarg_valid = false;
369 err = 0;
370 }
371 if (err)
372 goto out_err;
373
374 err = -EIO;
375 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
376 goto out_iput;
377
378 newent = d_materialise_unique(entry, inode);
379 err = PTR_ERR(newent);
380 if (IS_ERR(newent))
381 goto out_err;
382
383 entry = newent ? newent : entry;
384 if (outarg_valid)
385 fuse_change_entry_timeout(entry, &outarg);
386 else
387 fuse_invalidate_entry_cache(entry);
388
389 fuse_advise_use_readdirplus(dir);
390 return newent;
391
392 out_iput:
393 iput(inode);
394 out_err:
395 return ERR_PTR(err);
396}
397
398
399
400
401
402
403
404static int fuse_create_open(struct inode *dir, struct dentry *entry,
405 struct file *file, unsigned flags,
406 umode_t mode, int *opened)
407{
408 int err;
409 struct inode *inode;
410 struct fuse_conn *fc = get_fuse_conn(dir);
411 struct fuse_req *req;
412 struct fuse_forget_link *forget;
413 struct fuse_create_in inarg;
414 struct fuse_open_out outopen;
415 struct fuse_entry_out outentry;
416 struct fuse_file *ff;
417
418
419 BUG_ON((mode & S_IFMT) != S_IFREG);
420
421 forget = fuse_alloc_forget();
422 err = -ENOMEM;
423 if (!forget)
424 goto out_err;
425
426 req = fuse_get_req_nopages(fc);
427 err = PTR_ERR(req);
428 if (IS_ERR(req))
429 goto out_put_forget_req;
430
431 err = -ENOMEM;
432 ff = fuse_file_alloc(fc);
433 if (!ff)
434 goto out_put_request;
435
436 if (!fc->dont_mask)
437 mode &= ~current_umask();
438
439 flags &= ~O_NOCTTY;
440 memset(&inarg, 0, sizeof(inarg));
441 memset(&outentry, 0, sizeof(outentry));
442 inarg.flags = flags;
443 inarg.mode = mode;
444 inarg.umask = current_umask();
445 req->in.h.opcode = FUSE_CREATE;
446 req->in.h.nodeid = get_node_id(dir);
447 req->in.numargs = 2;
448 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
449 sizeof(inarg);
450 req->in.args[0].value = &inarg;
451 req->in.args[1].size = entry->d_name.len + 1;
452 req->in.args[1].value = entry->d_name.name;
453 req->out.numargs = 2;
454 if (fc->minor < 9)
455 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
456 else
457 req->out.args[0].size = sizeof(outentry);
458 req->out.args[0].value = &outentry;
459 req->out.args[1].size = sizeof(outopen);
460 req->out.args[1].value = &outopen;
461 fuse_request_send(fc, req);
462 err = req->out.h.error;
463 if (err)
464 goto out_free_ff;
465
466 err = -EIO;
467 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
468 goto out_free_ff;
469
470 fuse_put_request(fc, req);
471 ff->fh = outopen.fh;
472 ff->nodeid = outentry.nodeid;
473 ff->open_flags = outopen.open_flags;
474 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
475 &outentry.attr, entry_attr_timeout(&outentry), 0);
476 if (!inode) {
477 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
478 fuse_sync_release(ff, flags);
479 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
480 err = -ENOMEM;
481 goto out_err;
482 }
483 kfree(forget);
484 d_instantiate(entry, inode);
485 fuse_change_entry_timeout(entry, &outentry);
486 fuse_invalidate_attr(dir);
487 err = finish_open(file, entry, generic_file_open, opened);
488 if (err) {
489 fuse_sync_release(ff, flags);
490 } else {
491 file->private_data = fuse_file_get(ff);
492 fuse_finish_open(inode, file);
493 }
494 return err;
495
496out_free_ff:
497 fuse_file_free(ff);
498out_put_request:
499 fuse_put_request(fc, req);
500out_put_forget_req:
501 kfree(forget);
502out_err:
503 return err;
504}
505
506static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
507static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
508 struct file *file, unsigned flags,
509 umode_t mode, int *opened)
510{
511 int err;
512 struct fuse_conn *fc = get_fuse_conn(dir);
513 struct dentry *res = NULL;
514
515 if (d_unhashed(entry)) {
516 res = fuse_lookup(dir, entry, 0);
517 if (IS_ERR(res))
518 return PTR_ERR(res);
519
520 if (res)
521 entry = res;
522 }
523
524 if (!(flags & O_CREAT) || entry->d_inode)
525 goto no_open;
526
527
528 *opened |= FILE_CREATED;
529
530 if (fc->no_create)
531 goto mknod;
532
533 err = fuse_create_open(dir, entry, file, flags, mode, opened);
534 if (err == -ENOSYS) {
535 fc->no_create = 1;
536 goto mknod;
537 }
538out_dput:
539 dput(res);
540 return err;
541
542mknod:
543 err = fuse_mknod(dir, entry, mode, 0);
544 if (err)
545 goto out_dput;
546no_open:
547 return finish_no_open(file, res);
548}
549
550
551
552
553static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
554 struct inode *dir, struct dentry *entry,
555 umode_t mode)
556{
557 struct fuse_entry_out outarg;
558 struct inode *inode;
559 int err;
560 struct fuse_forget_link *forget;
561
562 forget = fuse_alloc_forget();
563 if (!forget) {
564 fuse_put_request(fc, req);
565 return -ENOMEM;
566 }
567
568 memset(&outarg, 0, sizeof(outarg));
569 req->in.h.nodeid = get_node_id(dir);
570 req->out.numargs = 1;
571 if (fc->minor < 9)
572 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
573 else
574 req->out.args[0].size = sizeof(outarg);
575 req->out.args[0].value = &outarg;
576 fuse_request_send(fc, req);
577 err = req->out.h.error;
578 fuse_put_request(fc, req);
579 if (err)
580 goto out_put_forget_req;
581
582 err = -EIO;
583 if (invalid_nodeid(outarg.nodeid))
584 goto out_put_forget_req;
585
586 if ((outarg.attr.mode ^ mode) & S_IFMT)
587 goto out_put_forget_req;
588
589 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
590 &outarg.attr, entry_attr_timeout(&outarg), 0);
591 if (!inode) {
592 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
593 return -ENOMEM;
594 }
595 kfree(forget);
596
597 err = d_instantiate_no_diralias(entry, inode);
598 if (err)
599 return err;
600
601 fuse_change_entry_timeout(entry, &outarg);
602 fuse_invalidate_attr(dir);
603 return 0;
604
605 out_put_forget_req:
606 kfree(forget);
607 return err;
608}
609
610static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
611 dev_t rdev)
612{
613 struct fuse_mknod_in inarg;
614 struct fuse_conn *fc = get_fuse_conn(dir);
615 struct fuse_req *req = fuse_get_req_nopages(fc);
616 if (IS_ERR(req))
617 return PTR_ERR(req);
618
619 if (!fc->dont_mask)
620 mode &= ~current_umask();
621
622 memset(&inarg, 0, sizeof(inarg));
623 inarg.mode = mode;
624 inarg.rdev = new_encode_dev(rdev);
625 inarg.umask = current_umask();
626 req->in.h.opcode = FUSE_MKNOD;
627 req->in.numargs = 2;
628 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
629 sizeof(inarg);
630 req->in.args[0].value = &inarg;
631 req->in.args[1].size = entry->d_name.len + 1;
632 req->in.args[1].value = entry->d_name.name;
633 return create_new_entry(fc, req, dir, entry, mode);
634}
635
636static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
637 bool excl)
638{
639 return fuse_mknod(dir, entry, mode, 0);
640}
641
642static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
643{
644 struct fuse_mkdir_in inarg;
645 struct fuse_conn *fc = get_fuse_conn(dir);
646 struct fuse_req *req = fuse_get_req_nopages(fc);
647 if (IS_ERR(req))
648 return PTR_ERR(req);
649
650 if (!fc->dont_mask)
651 mode &= ~current_umask();
652
653 memset(&inarg, 0, sizeof(inarg));
654 inarg.mode = mode;
655 inarg.umask = current_umask();
656 req->in.h.opcode = FUSE_MKDIR;
657 req->in.numargs = 2;
658 req->in.args[0].size = sizeof(inarg);
659 req->in.args[0].value = &inarg;
660 req->in.args[1].size = entry->d_name.len + 1;
661 req->in.args[1].value = entry->d_name.name;
662 return create_new_entry(fc, req, dir, entry, S_IFDIR);
663}
664
665static int fuse_symlink(struct inode *dir, struct dentry *entry,
666 const char *link)
667{
668 struct fuse_conn *fc = get_fuse_conn(dir);
669 unsigned len = strlen(link) + 1;
670 struct fuse_req *req = fuse_get_req_nopages(fc);
671 if (IS_ERR(req))
672 return PTR_ERR(req);
673
674 req->in.h.opcode = FUSE_SYMLINK;
675 req->in.numargs = 2;
676 req->in.args[0].size = entry->d_name.len + 1;
677 req->in.args[0].value = entry->d_name.name;
678 req->in.args[1].size = len;
679 req->in.args[1].value = link;
680 return create_new_entry(fc, req, dir, entry, S_IFLNK);
681}
682
683static inline void fuse_update_ctime(struct inode *inode)
684{
685 if (!IS_NOCMTIME(inode)) {
686 inode->i_ctime = current_fs_time(inode->i_sb);
687 mark_inode_dirty_sync(inode);
688 }
689}
690
691static int fuse_unlink(struct inode *dir, struct dentry *entry)
692{
693 int err;
694 struct fuse_conn *fc = get_fuse_conn(dir);
695 struct fuse_req *req = fuse_get_req_nopages(fc);
696 if (IS_ERR(req))
697 return PTR_ERR(req);
698
699 req->in.h.opcode = FUSE_UNLINK;
700 req->in.h.nodeid = get_node_id(dir);
701 req->in.numargs = 1;
702 req->in.args[0].size = entry->d_name.len + 1;
703 req->in.args[0].value = entry->d_name.name;
704 fuse_request_send(fc, req);
705 err = req->out.h.error;
706 fuse_put_request(fc, req);
707 if (!err) {
708 struct inode *inode = entry->d_inode;
709 struct fuse_inode *fi = get_fuse_inode(inode);
710
711 spin_lock(&fc->lock);
712 fi->attr_version = ++fc->attr_version;
713
714
715
716
717
718
719 if (inode->i_nlink > 0)
720 drop_nlink(inode);
721 spin_unlock(&fc->lock);
722 fuse_invalidate_attr(inode);
723 fuse_invalidate_attr(dir);
724 fuse_invalidate_entry_cache(entry);
725 fuse_update_ctime(inode);
726 } else if (err == -EINTR)
727 fuse_invalidate_entry(entry);
728 return err;
729}
730
731static int fuse_rmdir(struct inode *dir, struct dentry *entry)
732{
733 int err;
734 struct fuse_conn *fc = get_fuse_conn(dir);
735 struct fuse_req *req = fuse_get_req_nopages(fc);
736 if (IS_ERR(req))
737 return PTR_ERR(req);
738
739 req->in.h.opcode = FUSE_RMDIR;
740 req->in.h.nodeid = get_node_id(dir);
741 req->in.numargs = 1;
742 req->in.args[0].size = entry->d_name.len + 1;
743 req->in.args[0].value = entry->d_name.name;
744 fuse_request_send(fc, req);
745 err = req->out.h.error;
746 fuse_put_request(fc, req);
747 if (!err) {
748 clear_nlink(entry->d_inode);
749 fuse_invalidate_attr(dir);
750 fuse_invalidate_entry_cache(entry);
751 } else if (err == -EINTR)
752 fuse_invalidate_entry(entry);
753 return err;
754}
755
756static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
757 struct inode *newdir, struct dentry *newent,
758 unsigned int flags, int opcode, size_t argsize)
759{
760 int err;
761 struct fuse_rename2_in inarg;
762 struct fuse_conn *fc = get_fuse_conn(olddir);
763 struct fuse_req *req;
764
765 req = fuse_get_req_nopages(fc);
766 if (IS_ERR(req))
767 return PTR_ERR(req);
768
769 memset(&inarg, 0, argsize);
770 inarg.newdir = get_node_id(newdir);
771 inarg.flags = flags;
772 req->in.h.opcode = opcode;
773 req->in.h.nodeid = get_node_id(olddir);
774 req->in.numargs = 3;
775 req->in.args[0].size = argsize;
776 req->in.args[0].value = &inarg;
777 req->in.args[1].size = oldent->d_name.len + 1;
778 req->in.args[1].value = oldent->d_name.name;
779 req->in.args[2].size = newent->d_name.len + 1;
780 req->in.args[2].value = newent->d_name.name;
781 fuse_request_send(fc, req);
782 err = req->out.h.error;
783 fuse_put_request(fc, req);
784 if (!err) {
785
786 fuse_invalidate_attr(oldent->d_inode);
787 fuse_update_ctime(oldent->d_inode);
788
789 if (flags & RENAME_EXCHANGE) {
790 fuse_invalidate_attr(newent->d_inode);
791 fuse_update_ctime(newent->d_inode);
792 }
793
794 fuse_invalidate_attr(olddir);
795 if (olddir != newdir)
796 fuse_invalidate_attr(newdir);
797
798
799 if (!(flags & RENAME_EXCHANGE) && newent->d_inode) {
800 fuse_invalidate_attr(newent->d_inode);
801 fuse_invalidate_entry_cache(newent);
802 fuse_update_ctime(newent->d_inode);
803 }
804 } else if (err == -EINTR) {
805
806
807
808
809
810 fuse_invalidate_entry(oldent);
811 if (newent->d_inode)
812 fuse_invalidate_entry(newent);
813 }
814
815 return err;
816}
817
818static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
819 struct inode *newdir, struct dentry *newent,
820 unsigned int flags)
821{
822 struct fuse_conn *fc = get_fuse_conn(olddir);
823 int err;
824
825 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
826 return -EINVAL;
827
828 if (flags) {
829 if (fc->no_rename2 || fc->minor < 23)
830 return -EINVAL;
831
832 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
833 FUSE_RENAME2,
834 sizeof(struct fuse_rename2_in));
835 if (err == -ENOSYS) {
836 fc->no_rename2 = 1;
837 err = -EINVAL;
838 }
839 } else {
840 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
841 FUSE_RENAME,
842 sizeof(struct fuse_rename_in));
843 }
844
845 return err;
846}
847
848static int fuse_link(struct dentry *entry, struct inode *newdir,
849 struct dentry *newent)
850{
851 int err;
852 struct fuse_link_in inarg;
853 struct inode *inode = entry->d_inode;
854 struct fuse_conn *fc = get_fuse_conn(inode);
855 struct fuse_req *req = fuse_get_req_nopages(fc);
856 if (IS_ERR(req))
857 return PTR_ERR(req);
858
859 memset(&inarg, 0, sizeof(inarg));
860 inarg.oldnodeid = get_node_id(inode);
861 req->in.h.opcode = FUSE_LINK;
862 req->in.numargs = 2;
863 req->in.args[0].size = sizeof(inarg);
864 req->in.args[0].value = &inarg;
865 req->in.args[1].size = newent->d_name.len + 1;
866 req->in.args[1].value = newent->d_name.name;
867 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
868
869
870
871
872
873
874 if (!err) {
875 struct fuse_inode *fi = get_fuse_inode(inode);
876
877 spin_lock(&fc->lock);
878 fi->attr_version = ++fc->attr_version;
879 inc_nlink(inode);
880 spin_unlock(&fc->lock);
881 fuse_invalidate_attr(inode);
882 fuse_update_ctime(inode);
883 } else if (err == -EINTR) {
884 fuse_invalidate_attr(inode);
885 }
886 return err;
887}
888
889static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
890 struct kstat *stat)
891{
892 unsigned int blkbits;
893 struct fuse_conn *fc = get_fuse_conn(inode);
894
895
896 if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
897 attr->size = i_size_read(inode);
898 attr->mtime = inode->i_mtime.tv_sec;
899 attr->mtimensec = inode->i_mtime.tv_nsec;
900 attr->ctime = inode->i_ctime.tv_sec;
901 attr->ctimensec = inode->i_ctime.tv_nsec;
902 }
903
904 stat->dev = inode->i_sb->s_dev;
905 stat->ino = attr->ino;
906 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
907 stat->nlink = attr->nlink;
908 stat->uid = make_kuid(&init_user_ns, attr->uid);
909 stat->gid = make_kgid(&init_user_ns, attr->gid);
910 stat->rdev = inode->i_rdev;
911 stat->atime.tv_sec = attr->atime;
912 stat->atime.tv_nsec = attr->atimensec;
913 stat->mtime.tv_sec = attr->mtime;
914 stat->mtime.tv_nsec = attr->mtimensec;
915 stat->ctime.tv_sec = attr->ctime;
916 stat->ctime.tv_nsec = attr->ctimensec;
917 stat->size = attr->size;
918 stat->blocks = attr->blocks;
919
920 if (attr->blksize != 0)
921 blkbits = ilog2(attr->blksize);
922 else
923 blkbits = inode->i_sb->s_blocksize_bits;
924
925 stat->blksize = 1 << blkbits;
926}
927
928static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
929 struct file *file)
930{
931 int err;
932 struct fuse_getattr_in inarg;
933 struct fuse_attr_out outarg;
934 struct fuse_conn *fc = get_fuse_conn(inode);
935 struct fuse_req *req;
936 u64 attr_version;
937
938 req = fuse_get_req_nopages(fc);
939 if (IS_ERR(req))
940 return PTR_ERR(req);
941
942 attr_version = fuse_get_attr_version(fc);
943
944 memset(&inarg, 0, sizeof(inarg));
945 memset(&outarg, 0, sizeof(outarg));
946
947 if (file && S_ISREG(inode->i_mode)) {
948 struct fuse_file *ff = file->private_data;
949
950 inarg.getattr_flags |= FUSE_GETATTR_FH;
951 inarg.fh = ff->fh;
952 }
953 req->in.h.opcode = FUSE_GETATTR;
954 req->in.h.nodeid = get_node_id(inode);
955 req->in.numargs = 1;
956 req->in.args[0].size = sizeof(inarg);
957 req->in.args[0].value = &inarg;
958 req->out.numargs = 1;
959 if (fc->minor < 9)
960 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
961 else
962 req->out.args[0].size = sizeof(outarg);
963 req->out.args[0].value = &outarg;
964 fuse_request_send(fc, req);
965 err = req->out.h.error;
966 fuse_put_request(fc, req);
967 if (!err) {
968 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
969 make_bad_inode(inode);
970 err = -EIO;
971 } else {
972 fuse_change_attributes(inode, &outarg.attr,
973 attr_timeout(&outarg),
974 attr_version);
975 if (stat)
976 fuse_fillattr(inode, &outarg.attr, stat);
977 }
978 }
979 return err;
980}
981
982int fuse_update_attributes(struct inode *inode, struct kstat *stat,
983 struct file *file, bool *refreshed)
984{
985 struct fuse_inode *fi = get_fuse_inode(inode);
986 int err;
987 bool r;
988
989 if (time_before64(fi->i_time, get_jiffies_64())) {
990 r = true;
991 err = fuse_do_getattr(inode, stat, file);
992 } else {
993 r = false;
994 err = 0;
995 if (stat) {
996 generic_fillattr(inode, stat);
997 stat->mode = fi->orig_i_mode;
998 stat->ino = fi->orig_ino;
999 }
1000 }
1001
1002 if (refreshed != NULL)
1003 *refreshed = r;
1004
1005 return err;
1006}
1007
1008int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
1009 u64 child_nodeid, struct qstr *name)
1010{
1011 int err = -ENOTDIR;
1012 struct inode *parent;
1013 struct dentry *dir;
1014 struct dentry *entry;
1015
1016 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
1017 if (!parent)
1018 return -ENOENT;
1019
1020 mutex_lock(&parent->i_mutex);
1021 if (!S_ISDIR(parent->i_mode))
1022 goto unlock;
1023
1024 err = -ENOENT;
1025 dir = d_find_alias(parent);
1026 if (!dir)
1027 goto unlock;
1028
1029 entry = d_lookup(dir, name);
1030 dput(dir);
1031 if (!entry)
1032 goto unlock;
1033
1034 fuse_invalidate_attr(parent);
1035 fuse_invalidate_entry(entry);
1036
1037 if (child_nodeid != 0 && entry->d_inode) {
1038 mutex_lock(&entry->d_inode->i_mutex);
1039 if (get_node_id(entry->d_inode) != child_nodeid) {
1040 err = -ENOENT;
1041 goto badentry;
1042 }
1043 if (d_mountpoint(entry)) {
1044 err = -EBUSY;
1045 goto badentry;
1046 }
1047 if (S_ISDIR(entry->d_inode->i_mode)) {
1048 shrink_dcache_parent(entry);
1049 if (!simple_empty(entry)) {
1050 err = -ENOTEMPTY;
1051 goto badentry;
1052 }
1053 entry->d_inode->i_flags |= S_DEAD;
1054 }
1055 dont_mount(entry);
1056 clear_nlink(entry->d_inode);
1057 err = 0;
1058 badentry:
1059 mutex_unlock(&entry->d_inode->i_mutex);
1060 if (!err)
1061 d_delete(entry);
1062 } else {
1063 err = 0;
1064 }
1065 dput(entry);
1066
1067 unlock:
1068 mutex_unlock(&parent->i_mutex);
1069 iput(parent);
1070 return err;
1071}
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086int fuse_allow_current_process(struct fuse_conn *fc)
1087{
1088 const struct cred *cred;
1089
1090 if (fc->flags & FUSE_ALLOW_OTHER)
1091 return 1;
1092
1093 cred = current_cred();
1094 if (uid_eq(cred->euid, fc->user_id) &&
1095 uid_eq(cred->suid, fc->user_id) &&
1096 uid_eq(cred->uid, fc->user_id) &&
1097 gid_eq(cred->egid, fc->group_id) &&
1098 gid_eq(cred->sgid, fc->group_id) &&
1099 gid_eq(cred->gid, fc->group_id))
1100 return 1;
1101
1102 return 0;
1103}
1104
1105static int fuse_access(struct inode *inode, int mask)
1106{
1107 struct fuse_conn *fc = get_fuse_conn(inode);
1108 struct fuse_req *req;
1109 struct fuse_access_in inarg;
1110 int err;
1111
1112 BUG_ON(mask & MAY_NOT_BLOCK);
1113
1114 if (fc->no_access)
1115 return 0;
1116
1117 req = fuse_get_req_nopages(fc);
1118 if (IS_ERR(req))
1119 return PTR_ERR(req);
1120
1121 memset(&inarg, 0, sizeof(inarg));
1122 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1123 req->in.h.opcode = FUSE_ACCESS;
1124 req->in.h.nodeid = get_node_id(inode);
1125 req->in.numargs = 1;
1126 req->in.args[0].size = sizeof(inarg);
1127 req->in.args[0].value = &inarg;
1128 fuse_request_send(fc, req);
1129 err = req->out.h.error;
1130 fuse_put_request(fc, req);
1131 if (err == -ENOSYS) {
1132 fc->no_access = 1;
1133 err = 0;
1134 }
1135 return err;
1136}
1137
1138static int fuse_perm_getattr(struct inode *inode, int mask)
1139{
1140 if (mask & MAY_NOT_BLOCK)
1141 return -ECHILD;
1142
1143 return fuse_do_getattr(inode, NULL, NULL);
1144}
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159static int fuse_permission(struct inode *inode, int mask)
1160{
1161 struct fuse_conn *fc = get_fuse_conn(inode);
1162 bool refreshed = false;
1163 int err = 0;
1164
1165 if (!fuse_allow_current_process(fc))
1166 return -EACCES;
1167
1168
1169
1170
1171 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1172 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1173 struct fuse_inode *fi = get_fuse_inode(inode);
1174
1175 if (time_before64(fi->i_time, get_jiffies_64())) {
1176 refreshed = true;
1177
1178 err = fuse_perm_getattr(inode, mask);
1179 if (err)
1180 return err;
1181 }
1182 }
1183
1184 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1185 err = generic_permission(inode, mask);
1186
1187
1188
1189
1190 if (err == -EACCES && !refreshed) {
1191 err = fuse_perm_getattr(inode, mask);
1192 if (!err)
1193 err = generic_permission(inode, mask);
1194 }
1195
1196
1197
1198
1199
1200 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1201 err = fuse_access(inode, mask);
1202 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1203 if (!(inode->i_mode & S_IXUGO)) {
1204 if (refreshed)
1205 return -EACCES;
1206
1207 err = fuse_perm_getattr(inode, mask);
1208 if (!err && !(inode->i_mode & S_IXUGO))
1209 return -EACCES;
1210 }
1211 }
1212 return err;
1213}
1214
1215static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1216 struct dir_context *ctx)
1217{
1218 while (nbytes >= FUSE_NAME_OFFSET) {
1219 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1220 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1221 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1222 return -EIO;
1223 if (reclen > nbytes)
1224 break;
1225 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1226 return -EIO;
1227
1228 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1229 dirent->ino, dirent->type))
1230 break;
1231
1232 buf += reclen;
1233 nbytes -= reclen;
1234 ctx->pos = dirent->off;
1235 }
1236
1237 return 0;
1238}
1239
1240static int fuse_direntplus_link(struct file *file,
1241 struct fuse_direntplus *direntplus,
1242 u64 attr_version)
1243{
1244 int err;
1245 struct fuse_entry_out *o = &direntplus->entry_out;
1246 struct fuse_dirent *dirent = &direntplus->dirent;
1247 struct dentry *parent = file->f_path.dentry;
1248 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1249 struct dentry *dentry;
1250 struct dentry *alias;
1251 struct inode *dir = parent->d_inode;
1252 struct fuse_conn *fc;
1253 struct inode *inode;
1254
1255 if (!o->nodeid) {
1256
1257
1258
1259
1260
1261
1262
1263 return 0;
1264 }
1265
1266 if (name.name[0] == '.') {
1267
1268
1269
1270
1271 if (name.len == 1)
1272 return 0;
1273 if (name.name[1] == '.' && name.len == 2)
1274 return 0;
1275 }
1276
1277 if (invalid_nodeid(o->nodeid))
1278 return -EIO;
1279 if (!fuse_valid_type(o->attr.mode))
1280 return -EIO;
1281
1282 fc = get_fuse_conn(dir);
1283
1284 name.hash = full_name_hash(name.name, name.len);
1285 dentry = d_lookup(parent, &name);
1286 if (dentry) {
1287 inode = dentry->d_inode;
1288 if (!inode) {
1289 d_drop(dentry);
1290 } else if (get_node_id(inode) != o->nodeid ||
1291 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1292 err = d_invalidate(dentry);
1293 if (err)
1294 goto out;
1295 } else if (is_bad_inode(inode)) {
1296 err = -EIO;
1297 goto out;
1298 } else {
1299 struct fuse_inode *fi;
1300 fi = get_fuse_inode(inode);
1301 spin_lock(&fc->lock);
1302 fi->nlookup++;
1303 spin_unlock(&fc->lock);
1304
1305 fuse_change_attributes(inode, &o->attr,
1306 entry_attr_timeout(o),
1307 attr_version);
1308
1309
1310
1311
1312
1313 goto found;
1314 }
1315 dput(dentry);
1316 }
1317
1318 dentry = d_alloc(parent, &name);
1319 err = -ENOMEM;
1320 if (!dentry)
1321 goto out;
1322
1323 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1324 &o->attr, entry_attr_timeout(o), attr_version);
1325 if (!inode)
1326 goto out;
1327
1328 alias = d_materialise_unique(dentry, inode);
1329 err = PTR_ERR(alias);
1330 if (IS_ERR(alias))
1331 goto out;
1332
1333 if (alias) {
1334 dput(dentry);
1335 dentry = alias;
1336 }
1337
1338found:
1339 if (fc->readdirplus_auto)
1340 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1341 fuse_change_entry_timeout(dentry, o);
1342
1343 err = 0;
1344out:
1345 dput(dentry);
1346 return err;
1347}
1348
1349static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1350 struct dir_context *ctx, u64 attr_version)
1351{
1352 struct fuse_direntplus *direntplus;
1353 struct fuse_dirent *dirent;
1354 size_t reclen;
1355 int over = 0;
1356 int ret;
1357
1358 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1359 direntplus = (struct fuse_direntplus *) buf;
1360 dirent = &direntplus->dirent;
1361 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1362
1363 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1364 return -EIO;
1365 if (reclen > nbytes)
1366 break;
1367 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1368 return -EIO;
1369
1370 if (!over) {
1371
1372
1373
1374
1375
1376
1377 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1378 dirent->ino, dirent->type);
1379 ctx->pos = dirent->off;
1380 }
1381
1382 buf += reclen;
1383 nbytes -= reclen;
1384
1385 ret = fuse_direntplus_link(file, direntplus, attr_version);
1386 if (ret)
1387 fuse_force_forget(file, direntplus->entry_out.nodeid);
1388 }
1389
1390 return 0;
1391}
1392
1393static int fuse_readdir(struct file *file, struct dir_context *ctx)
1394{
1395 int plus, err;
1396 size_t nbytes;
1397 struct page *page;
1398 struct inode *inode = file_inode(file);
1399 struct fuse_conn *fc = get_fuse_conn(inode);
1400 struct fuse_req *req;
1401 u64 attr_version = 0;
1402
1403 if (is_bad_inode(inode))
1404 return -EIO;
1405
1406 req = fuse_get_req(fc, 1);
1407 if (IS_ERR(req))
1408 return PTR_ERR(req);
1409
1410 page = alloc_page(GFP_KERNEL);
1411 if (!page) {
1412 fuse_put_request(fc, req);
1413 return -ENOMEM;
1414 }
1415
1416 plus = fuse_use_readdirplus(inode, ctx);
1417 req->out.argpages = 1;
1418 req->num_pages = 1;
1419 req->pages[0] = page;
1420 req->page_descs[0].length = PAGE_SIZE;
1421 if (plus) {
1422 attr_version = fuse_get_attr_version(fc);
1423 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1424 FUSE_READDIRPLUS);
1425 } else {
1426 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1427 FUSE_READDIR);
1428 }
1429 fuse_request_send(fc, req);
1430 nbytes = req->out.args[0].size;
1431 err = req->out.h.error;
1432 fuse_put_request(fc, req);
1433 if (!err) {
1434 if (plus) {
1435 err = parse_dirplusfile(page_address(page), nbytes,
1436 file, ctx,
1437 attr_version);
1438 } else {
1439 err = parse_dirfile(page_address(page), nbytes, file,
1440 ctx);
1441 }
1442 }
1443
1444 __free_page(page);
1445 fuse_invalidate_atime(inode);
1446 return err;
1447}
1448
1449static char *read_link(struct dentry *dentry)
1450{
1451 struct inode *inode = dentry->d_inode;
1452 struct fuse_conn *fc = get_fuse_conn(inode);
1453 struct fuse_req *req = fuse_get_req_nopages(fc);
1454 char *link;
1455
1456 if (IS_ERR(req))
1457 return ERR_CAST(req);
1458
1459 link = (char *) __get_free_page(GFP_KERNEL);
1460 if (!link) {
1461 link = ERR_PTR(-ENOMEM);
1462 goto out;
1463 }
1464 req->in.h.opcode = FUSE_READLINK;
1465 req->in.h.nodeid = get_node_id(inode);
1466 req->out.argvar = 1;
1467 req->out.numargs = 1;
1468 req->out.args[0].size = PAGE_SIZE - 1;
1469 req->out.args[0].value = link;
1470 fuse_request_send(fc, req);
1471 if (req->out.h.error) {
1472 free_page((unsigned long) link);
1473 link = ERR_PTR(req->out.h.error);
1474 } else
1475 link[req->out.args[0].size] = '\0';
1476 out:
1477 fuse_put_request(fc, req);
1478 fuse_invalidate_atime(inode);
1479 return link;
1480}
1481
1482static void free_link(char *link)
1483{
1484 if (!IS_ERR(link))
1485 free_page((unsigned long) link);
1486}
1487
1488static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1489{
1490 nd_set_link(nd, read_link(dentry));
1491 return NULL;
1492}
1493
1494static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1495{
1496 free_link(nd_get_link(nd));
1497}
1498
1499static int fuse_dir_open(struct inode *inode, struct file *file)
1500{
1501 return fuse_open_common(inode, file, true);
1502}
1503
1504static int fuse_dir_release(struct inode *inode, struct file *file)
1505{
1506 fuse_release_common(file, FUSE_RELEASEDIR);
1507
1508 return 0;
1509}
1510
1511static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1512 int datasync)
1513{
1514 return fuse_fsync_common(file, start, end, datasync, 1);
1515}
1516
1517static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1518 unsigned long arg)
1519{
1520 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1521
1522
1523 if (fc->minor < 18)
1524 return -ENOTTY;
1525
1526 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1527}
1528
1529static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1530 unsigned long arg)
1531{
1532 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1533
1534 if (fc->minor < 18)
1535 return -ENOTTY;
1536
1537 return fuse_ioctl_common(file, cmd, arg,
1538 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1539}
1540
1541static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1542{
1543
1544 if (ivalid & ATTR_MTIME_SET)
1545 return true;
1546
1547
1548 if (trust_local_mtime)
1549 return true;
1550
1551
1552 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1553 return false;
1554
1555
1556 return true;
1557}
1558
1559static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg,
1560 bool trust_local_cmtime)
1561{
1562 unsigned ivalid = iattr->ia_valid;
1563
1564 if (ivalid & ATTR_MODE)
1565 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1566 if (ivalid & ATTR_UID)
1567 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
1568 if (ivalid & ATTR_GID)
1569 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
1570 if (ivalid & ATTR_SIZE)
1571 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1572 if (ivalid & ATTR_ATIME) {
1573 arg->valid |= FATTR_ATIME;
1574 arg->atime = iattr->ia_atime.tv_sec;
1575 arg->atimensec = iattr->ia_atime.tv_nsec;
1576 if (!(ivalid & ATTR_ATIME_SET))
1577 arg->valid |= FATTR_ATIME_NOW;
1578 }
1579 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1580 arg->valid |= FATTR_MTIME;
1581 arg->mtime = iattr->ia_mtime.tv_sec;
1582 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1583 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1584 arg->valid |= FATTR_MTIME_NOW;
1585 }
1586 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1587 arg->valid |= FATTR_CTIME;
1588 arg->ctime = iattr->ia_ctime.tv_sec;
1589 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1590 }
1591}
1592
1593
1594
1595
1596
1597
1598
1599void fuse_set_nowrite(struct inode *inode)
1600{
1601 struct fuse_conn *fc = get_fuse_conn(inode);
1602 struct fuse_inode *fi = get_fuse_inode(inode);
1603
1604 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1605
1606 spin_lock(&fc->lock);
1607 BUG_ON(fi->writectr < 0);
1608 fi->writectr += FUSE_NOWRITE;
1609 spin_unlock(&fc->lock);
1610 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1611}
1612
1613
1614
1615
1616
1617
1618
1619static void __fuse_release_nowrite(struct inode *inode)
1620{
1621 struct fuse_inode *fi = get_fuse_inode(inode);
1622
1623 BUG_ON(fi->writectr != FUSE_NOWRITE);
1624 fi->writectr = 0;
1625 fuse_flush_writepages(inode);
1626}
1627
1628void fuse_release_nowrite(struct inode *inode)
1629{
1630 struct fuse_conn *fc = get_fuse_conn(inode);
1631
1632 spin_lock(&fc->lock);
1633 __fuse_release_nowrite(inode);
1634 spin_unlock(&fc->lock);
1635}
1636
1637static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_req *req,
1638 struct inode *inode,
1639 struct fuse_setattr_in *inarg_p,
1640 struct fuse_attr_out *outarg_p)
1641{
1642 req->in.h.opcode = FUSE_SETATTR;
1643 req->in.h.nodeid = get_node_id(inode);
1644 req->in.numargs = 1;
1645 req->in.args[0].size = sizeof(*inarg_p);
1646 req->in.args[0].value = inarg_p;
1647 req->out.numargs = 1;
1648 if (fc->minor < 9)
1649 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1650 else
1651 req->out.args[0].size = sizeof(*outarg_p);
1652 req->out.args[0].value = outarg_p;
1653}
1654
1655
1656
1657
1658int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1659{
1660 struct fuse_conn *fc = get_fuse_conn(inode);
1661 struct fuse_req *req;
1662 struct fuse_setattr_in inarg;
1663 struct fuse_attr_out outarg;
1664 int err;
1665
1666 req = fuse_get_req_nopages(fc);
1667 if (IS_ERR(req))
1668 return PTR_ERR(req);
1669
1670 memset(&inarg, 0, sizeof(inarg));
1671 memset(&outarg, 0, sizeof(outarg));
1672
1673 inarg.valid = FATTR_MTIME;
1674 inarg.mtime = inode->i_mtime.tv_sec;
1675 inarg.mtimensec = inode->i_mtime.tv_nsec;
1676 if (fc->minor >= 23) {
1677 inarg.valid |= FATTR_CTIME;
1678 inarg.ctime = inode->i_ctime.tv_sec;
1679 inarg.ctimensec = inode->i_ctime.tv_nsec;
1680 }
1681 if (ff) {
1682 inarg.valid |= FATTR_FH;
1683 inarg.fh = ff->fh;
1684 }
1685 fuse_setattr_fill(fc, req, inode, &inarg, &outarg);
1686 fuse_request_send(fc, req);
1687 err = req->out.h.error;
1688 fuse_put_request(fc, req);
1689
1690 return err;
1691}
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1702 struct file *file)
1703{
1704 struct fuse_conn *fc = get_fuse_conn(inode);
1705 struct fuse_inode *fi = get_fuse_inode(inode);
1706 struct fuse_req *req;
1707 struct fuse_setattr_in inarg;
1708 struct fuse_attr_out outarg;
1709 bool is_truncate = false;
1710 bool is_wb = fc->writeback_cache;
1711 loff_t oldsize;
1712 int err;
1713 bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
1714
1715 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1716 attr->ia_valid |= ATTR_FORCE;
1717
1718 err = inode_change_ok(inode, attr);
1719 if (err)
1720 return err;
1721
1722 if (attr->ia_valid & ATTR_OPEN) {
1723 if (fc->atomic_o_trunc)
1724 return 0;
1725 file = NULL;
1726 }
1727
1728 if (attr->ia_valid & ATTR_SIZE)
1729 is_truncate = true;
1730
1731 req = fuse_get_req_nopages(fc);
1732 if (IS_ERR(req))
1733 return PTR_ERR(req);
1734
1735 if (is_truncate) {
1736 fuse_set_nowrite(inode);
1737 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1738 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1739 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1740 }
1741
1742 memset(&inarg, 0, sizeof(inarg));
1743 memset(&outarg, 0, sizeof(outarg));
1744 iattr_to_fattr(attr, &inarg, trust_local_cmtime);
1745 if (file) {
1746 struct fuse_file *ff = file->private_data;
1747 inarg.valid |= FATTR_FH;
1748 inarg.fh = ff->fh;
1749 }
1750 if (attr->ia_valid & ATTR_SIZE) {
1751
1752 inarg.valid |= FATTR_LOCKOWNER;
1753 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1754 }
1755 fuse_setattr_fill(fc, req, inode, &inarg, &outarg);
1756 fuse_request_send(fc, req);
1757 err = req->out.h.error;
1758 fuse_put_request(fc, req);
1759 if (err) {
1760 if (err == -EINTR)
1761 fuse_invalidate_attr(inode);
1762 goto error;
1763 }
1764
1765 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1766 make_bad_inode(inode);
1767 err = -EIO;
1768 goto error;
1769 }
1770
1771 spin_lock(&fc->lock);
1772
1773 if (trust_local_cmtime) {
1774 if (attr->ia_valid & ATTR_MTIME)
1775 inode->i_mtime = attr->ia_mtime;
1776 if (attr->ia_valid & ATTR_CTIME)
1777 inode->i_ctime = attr->ia_ctime;
1778
1779 }
1780
1781 fuse_change_attributes_common(inode, &outarg.attr,
1782 attr_timeout(&outarg));
1783 oldsize = inode->i_size;
1784
1785 if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1786 i_size_write(inode, outarg.attr.size);
1787
1788 if (is_truncate) {
1789
1790 __fuse_release_nowrite(inode);
1791 }
1792 spin_unlock(&fc->lock);
1793
1794
1795
1796
1797
1798 if ((is_truncate || !is_wb) &&
1799 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1800 truncate_pagecache(inode, outarg.attr.size);
1801 invalidate_inode_pages2(inode->i_mapping);
1802 }
1803
1804 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1805 return 0;
1806
1807error:
1808 if (is_truncate)
1809 fuse_release_nowrite(inode);
1810
1811 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1812 return err;
1813}
1814
1815static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1816{
1817 struct inode *inode = entry->d_inode;
1818
1819 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1820 return -EACCES;
1821
1822 if (attr->ia_valid & ATTR_FILE)
1823 return fuse_do_setattr(inode, attr, attr->ia_file);
1824 else
1825 return fuse_do_setattr(inode, attr, NULL);
1826}
1827
1828static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1829 struct kstat *stat)
1830{
1831 struct inode *inode = entry->d_inode;
1832 struct fuse_conn *fc = get_fuse_conn(inode);
1833
1834 if (!fuse_allow_current_process(fc))
1835 return -EACCES;
1836
1837 return fuse_update_attributes(inode, stat, NULL, NULL);
1838}
1839
1840static int fuse_setxattr(struct dentry *entry, const char *name,
1841 const void *value, size_t size, int flags)
1842{
1843 struct inode *inode = entry->d_inode;
1844 struct fuse_conn *fc = get_fuse_conn(inode);
1845 struct fuse_req *req;
1846 struct fuse_setxattr_in inarg;
1847 int err;
1848
1849 if (fc->no_setxattr)
1850 return -EOPNOTSUPP;
1851
1852 req = fuse_get_req_nopages(fc);
1853 if (IS_ERR(req))
1854 return PTR_ERR(req);
1855
1856 memset(&inarg, 0, sizeof(inarg));
1857 inarg.size = size;
1858 inarg.flags = flags;
1859 req->in.h.opcode = FUSE_SETXATTR;
1860 req->in.h.nodeid = get_node_id(inode);
1861 req->in.numargs = 3;
1862 req->in.args[0].size = sizeof(inarg);
1863 req->in.args[0].value = &inarg;
1864 req->in.args[1].size = strlen(name) + 1;
1865 req->in.args[1].value = name;
1866 req->in.args[2].size = size;
1867 req->in.args[2].value = value;
1868 fuse_request_send(fc, req);
1869 err = req->out.h.error;
1870 fuse_put_request(fc, req);
1871 if (err == -ENOSYS) {
1872 fc->no_setxattr = 1;
1873 err = -EOPNOTSUPP;
1874 }
1875 if (!err) {
1876 fuse_invalidate_attr(inode);
1877 fuse_update_ctime(inode);
1878 }
1879 return err;
1880}
1881
1882static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1883 void *value, size_t size)
1884{
1885 struct inode *inode = entry->d_inode;
1886 struct fuse_conn *fc = get_fuse_conn(inode);
1887 struct fuse_req *req;
1888 struct fuse_getxattr_in inarg;
1889 struct fuse_getxattr_out outarg;
1890 ssize_t ret;
1891
1892 if (fc->no_getxattr)
1893 return -EOPNOTSUPP;
1894
1895 req = fuse_get_req_nopages(fc);
1896 if (IS_ERR(req))
1897 return PTR_ERR(req);
1898
1899 memset(&inarg, 0, sizeof(inarg));
1900 inarg.size = size;
1901 req->in.h.opcode = FUSE_GETXATTR;
1902 req->in.h.nodeid = get_node_id(inode);
1903 req->in.numargs = 2;
1904 req->in.args[0].size = sizeof(inarg);
1905 req->in.args[0].value = &inarg;
1906 req->in.args[1].size = strlen(name) + 1;
1907 req->in.args[1].value = name;
1908
1909 req->out.numargs = 1;
1910 if (size) {
1911 req->out.argvar = 1;
1912 req->out.args[0].size = size;
1913 req->out.args[0].value = value;
1914 } else {
1915 req->out.args[0].size = sizeof(outarg);
1916 req->out.args[0].value = &outarg;
1917 }
1918 fuse_request_send(fc, req);
1919 ret = req->out.h.error;
1920 if (!ret)
1921 ret = size ? req->out.args[0].size : outarg.size;
1922 else {
1923 if (ret == -ENOSYS) {
1924 fc->no_getxattr = 1;
1925 ret = -EOPNOTSUPP;
1926 }
1927 }
1928 fuse_put_request(fc, req);
1929 return ret;
1930}
1931
1932static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1933{
1934 struct inode *inode = entry->d_inode;
1935 struct fuse_conn *fc = get_fuse_conn(inode);
1936 struct fuse_req *req;
1937 struct fuse_getxattr_in inarg;
1938 struct fuse_getxattr_out outarg;
1939 ssize_t ret;
1940
1941 if (!fuse_allow_current_process(fc))
1942 return -EACCES;
1943
1944 if (fc->no_listxattr)
1945 return -EOPNOTSUPP;
1946
1947 req = fuse_get_req_nopages(fc);
1948 if (IS_ERR(req))
1949 return PTR_ERR(req);
1950
1951 memset(&inarg, 0, sizeof(inarg));
1952 inarg.size = size;
1953 req->in.h.opcode = FUSE_LISTXATTR;
1954 req->in.h.nodeid = get_node_id(inode);
1955 req->in.numargs = 1;
1956 req->in.args[0].size = sizeof(inarg);
1957 req->in.args[0].value = &inarg;
1958
1959 req->out.numargs = 1;
1960 if (size) {
1961 req->out.argvar = 1;
1962 req->out.args[0].size = size;
1963 req->out.args[0].value = list;
1964 } else {
1965 req->out.args[0].size = sizeof(outarg);
1966 req->out.args[0].value = &outarg;
1967 }
1968 fuse_request_send(fc, req);
1969 ret = req->out.h.error;
1970 if (!ret)
1971 ret = size ? req->out.args[0].size : outarg.size;
1972 else {
1973 if (ret == -ENOSYS) {
1974 fc->no_listxattr = 1;
1975 ret = -EOPNOTSUPP;
1976 }
1977 }
1978 fuse_put_request(fc, req);
1979 return ret;
1980}
1981
1982static int fuse_removexattr(struct dentry *entry, const char *name)
1983{
1984 struct inode *inode = entry->d_inode;
1985 struct fuse_conn *fc = get_fuse_conn(inode);
1986 struct fuse_req *req;
1987 int err;
1988
1989 if (fc->no_removexattr)
1990 return -EOPNOTSUPP;
1991
1992 req = fuse_get_req_nopages(fc);
1993 if (IS_ERR(req))
1994 return PTR_ERR(req);
1995
1996 req->in.h.opcode = FUSE_REMOVEXATTR;
1997 req->in.h.nodeid = get_node_id(inode);
1998 req->in.numargs = 1;
1999 req->in.args[0].size = strlen(name) + 1;
2000 req->in.args[0].value = name;
2001 fuse_request_send(fc, req);
2002 err = req->out.h.error;
2003 fuse_put_request(fc, req);
2004 if (err == -ENOSYS) {
2005 fc->no_removexattr = 1;
2006 err = -EOPNOTSUPP;
2007 }
2008 if (!err) {
2009 fuse_invalidate_attr(inode);
2010 fuse_update_ctime(inode);
2011 }
2012 return err;
2013}
2014
2015static const struct inode_operations fuse_dir_inode_operations = {
2016 .lookup = fuse_lookup,
2017 .mkdir = fuse_mkdir,
2018 .symlink = fuse_symlink,
2019 .unlink = fuse_unlink,
2020 .rmdir = fuse_rmdir,
2021 .rename2 = fuse_rename2,
2022 .link = fuse_link,
2023 .setattr = fuse_setattr,
2024 .create = fuse_create,
2025 .atomic_open = fuse_atomic_open,
2026 .mknod = fuse_mknod,
2027 .permission = fuse_permission,
2028 .getattr = fuse_getattr,
2029 .setxattr = fuse_setxattr,
2030 .getxattr = fuse_getxattr,
2031 .listxattr = fuse_listxattr,
2032 .removexattr = fuse_removexattr,
2033};
2034
2035static const struct file_operations fuse_dir_operations = {
2036 .llseek = generic_file_llseek,
2037 .read = generic_read_dir,
2038 .iterate = fuse_readdir,
2039 .open = fuse_dir_open,
2040 .release = fuse_dir_release,
2041 .fsync = fuse_dir_fsync,
2042 .unlocked_ioctl = fuse_dir_ioctl,
2043 .compat_ioctl = fuse_dir_compat_ioctl,
2044};
2045
2046static const struct inode_operations fuse_common_inode_operations = {
2047 .setattr = fuse_setattr,
2048 .permission = fuse_permission,
2049 .getattr = fuse_getattr,
2050 .setxattr = fuse_setxattr,
2051 .getxattr = fuse_getxattr,
2052 .listxattr = fuse_listxattr,
2053 .removexattr = fuse_removexattr,
2054};
2055
2056static const struct inode_operations fuse_symlink_inode_operations = {
2057 .setattr = fuse_setattr,
2058 .follow_link = fuse_follow_link,
2059 .put_link = fuse_put_link,
2060 .readlink = generic_readlink,
2061 .getattr = fuse_getattr,
2062 .setxattr = fuse_setxattr,
2063 .getxattr = fuse_getxattr,
2064 .listxattr = fuse_listxattr,
2065 .removexattr = fuse_removexattr,
2066};
2067
2068void fuse_init_common(struct inode *inode)
2069{
2070 inode->i_op = &fuse_common_inode_operations;
2071}
2072
2073void fuse_init_dir(struct inode *inode)
2074{
2075 inode->i_op = &fuse_dir_inode_operations;
2076 inode->i_fop = &fuse_dir_operations;
2077}
2078
2079void fuse_init_symlink(struct inode *inode)
2080{
2081 inode->i_op = &fuse_symlink_inode_operations;
2082}
2083