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