projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'regulator/for-next'
[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, const 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, const 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 name->hash = full_name_hash(dir, name->name, name->len);
959 entry = d_lookup(dir, name);
960 dput(dir);
961 if (!entry)
962 goto unlock;
963
964 fuse_invalidate_attr(parent);
965 fuse_invalidate_entry(entry);
966
967 if (child_nodeid != 0 && d_really_is_positive(entry)) {
968 inode_lock(d_inode(entry));
969 if (get_node_id(d_inode(entry)) != child_nodeid) {
970 err = -ENOENT;
971 goto badentry;
972 }
973 if (d_mountpoint(entry)) {
974 err = -EBUSY;
975 goto badentry;
976 }
977 if (d_is_dir(entry)) {
978 shrink_dcache_parent(entry);
979 if (!simple_empty(entry)) {
980 err = -ENOTEMPTY;
981 goto badentry;
982 }
983 d_inode(entry)->i_flags |= S_DEAD;
984 }
985 dont_mount(entry);
986 clear_nlink(d_inode(entry));
987 err = 0;
988 badentry:
989 inode_unlock(d_inode(entry));
990 if (!err)
991 d_delete(entry);
992 } else {
993 err = 0;
994 }
995 dput(entry);
996
997 unlock:
998 inode_unlock(parent);
999 iput(parent);
1000 return err;
1001 }
1002
1003 /*
1004 * Calling into a user-controlled filesystem gives the filesystem
1005 * daemon ptrace-like capabilities over the current process. This
1006 * means, that the filesystem daemon is able to record the exact
1007 * filesystem operations performed, and can also control the behavior
1008 * of the requester process in otherwise impossible ways. For example
1009 * it can delay the operation for arbitrary length of time allowing
1010 * DoS against the requester.
1011 *
1012 * For this reason only those processes can call into the filesystem,
1013 * for which the owner of the mount has ptrace privilege. This
1014 * excludes processes started by other users, suid or sgid processes.
1015 */
1016 int fuse_allow_current_process(struct fuse_conn *fc)
1017 {
1018 const struct cred *cred;
1019
1020 if (fc->flags & FUSE_ALLOW_OTHER)
1021 return 1;
1022
1023 cred = current_cred();
1024 if (uid_eq(cred->euid, fc->user_id) &&
1025 uid_eq(cred->suid, fc->user_id) &&
1026 uid_eq(cred->uid, fc->user_id) &&
1027 gid_eq(cred->egid, fc->group_id) &&
1028 gid_eq(cred->sgid, fc->group_id) &&
1029 gid_eq(cred->gid, fc->group_id))
1030 return 1;
1031
1032 return 0;
1033 }
1034
1035 static int fuse_access(struct inode *inode, int mask)
1036 {
1037 struct fuse_conn *fc = get_fuse_conn(inode);
1038 FUSE_ARGS(args);
1039 struct fuse_access_in inarg;
1040 int err;
1041
1042 BUG_ON(mask & MAY_NOT_BLOCK);
1043
1044 if (fc->no_access)
1045 return 0;
1046
1047 memset(&inarg, 0, sizeof(inarg));
1048 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1049 args.in.h.opcode = FUSE_ACCESS;
1050 args.in.h.nodeid = get_node_id(inode);
1051 args.in.numargs = 1;
1052 args.in.args[0].size = sizeof(inarg);
1053 args.in.args[0].value = &inarg;
1054 err = fuse_simple_request(fc, &args);
1055 if (err == -ENOSYS) {
1056 fc->no_access = 1;
1057 err = 0;
1058 }
1059 return err;
1060 }
1061
1062 static int fuse_perm_getattr(struct inode *inode, int mask)
1063 {
1064 if (mask & MAY_NOT_BLOCK)
1065 return -ECHILD;
1066
1067 return fuse_do_getattr(inode, NULL, NULL);
1068 }
1069
1070 /*
1071 * Check permission. The two basic access models of FUSE are:
1072 *
1073 * 1) Local access checking ('default_permissions' mount option) based
1074 * on file mode. This is the plain old disk filesystem permission
1075 * modell.
1076 *
1077 * 2) "Remote" access checking, where server is responsible for
1078 * checking permission in each inode operation. An exception to this
1079 * is if ->permission() was invoked from sys_access() in which case an
1080 * access request is sent. Execute permission is still checked
1081 * locally based on file mode.
1082 */
1083 static int fuse_permission(struct inode *inode, int mask)
1084 {
1085 struct fuse_conn *fc = get_fuse_conn(inode);
1086 bool refreshed = false;
1087 int err = 0;
1088
1089 if (!fuse_allow_current_process(fc))
1090 return -EACCES;
1091
1092 /*
1093 * If attributes are needed, refresh them before proceeding
1094 */
1095 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1096 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1097 struct fuse_inode *fi = get_fuse_inode(inode);
1098
1099 if (time_before64(fi->i_time, get_jiffies_64())) {
1100 refreshed = true;
1101
1102 err = fuse_perm_getattr(inode, mask);
1103 if (err)
1104 return err;
1105 }
1106 }
1107
1108 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1109 err = generic_permission(inode, mask);
1110
1111 /* If permission is denied, try to refresh file
1112 attributes. This is also needed, because the root
1113 node will at first have no permissions */
1114 if (err == -EACCES && !refreshed) {
1115 err = fuse_perm_getattr(inode, mask);
1116 if (!err)
1117 err = generic_permission(inode, mask);
1118 }
1119
1120 /* Note: the opposite of the above test does not
1121 exist. So if permissions are revoked this won't be
1122 noticed immediately, only after the attribute
1123 timeout has expired */
1124 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1125 err = fuse_access(inode, mask);
1126 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1127 if (!(inode->i_mode & S_IXUGO)) {
1128 if (refreshed)
1129 return -EACCES;
1130
1131 err = fuse_perm_getattr(inode, mask);
1132 if (!err && !(inode->i_mode & S_IXUGO))
1133 return -EACCES;
1134 }
1135 }
1136 return err;
1137 }
1138
1139 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1140 struct dir_context *ctx)
1141 {
1142 while (nbytes >= FUSE_NAME_OFFSET) {
1143 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1144 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1145 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1146 return -EIO;
1147 if (reclen > nbytes)
1148 break;
1149 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1150 return -EIO;
1151
1152 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1153 dirent->ino, dirent->type))
1154 break;
1155
1156 buf += reclen;
1157 nbytes -= reclen;
1158 ctx->pos = dirent->off;
1159 }
1160
1161 return 0;
1162 }
1163
1164 static int fuse_direntplus_link(struct file *file,
1165 struct fuse_direntplus *direntplus,
1166 u64 attr_version)
1167 {
1168 struct fuse_entry_out *o = &direntplus->entry_out;
1169 struct fuse_dirent *dirent = &direntplus->dirent;
1170 struct dentry *parent = file->f_path.dentry;
1171 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1172 struct dentry *dentry;
1173 struct dentry *alias;
1174 struct inode *dir = d_inode(parent);
1175 struct fuse_conn *fc;
1176 struct inode *inode;
1177 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1178
1179 if (!o->nodeid) {
1180 /*
1181 * Unlike in the case of fuse_lookup, zero nodeid does not mean
1182 * ENOENT. Instead, it only means the userspace filesystem did
1183 * not want to return attributes/handle for this entry.
1184 *
1185 * So do nothing.
1186 */
1187 return 0;
1188 }
1189
1190 if (name.name[0] == '.') {
1191 /*
1192 * We could potentially refresh the attributes of the directory
1193 * and its parent?
1194 */
1195 if (name.len == 1)
1196 return 0;
1197 if (name.name[1] == '.' && name.len == 2)
1198 return 0;
1199 }
1200
1201 if (invalid_nodeid(o->nodeid))
1202 return -EIO;
1203 if (!fuse_valid_type(o->attr.mode))
1204 return -EIO;
1205
1206 fc = get_fuse_conn(dir);
1207
1208 name.hash = full_name_hash(parent, name.name, name.len);
1209 dentry = d_lookup(parent, &name);
1210 if (!dentry) {
1211 retry:
1212 dentry = d_alloc_parallel(parent, &name, &wq);
1213 if (IS_ERR(dentry))
1214 return PTR_ERR(dentry);
1215 }
1216 if (!d_in_lookup(dentry)) {
1217 struct fuse_inode *fi;
1218 inode = d_inode(dentry);
1219 if (!inode ||
1220 get_node_id(inode) != o->nodeid ||
1221 ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1222 d_invalidate(dentry);
1223 dput(dentry);
1224 goto retry;
1225 }
1226 if (is_bad_inode(inode)) {
1227 dput(dentry);
1228 return -EIO;
1229 }
1230
1231 fi = get_fuse_inode(inode);
1232 spin_lock(&fc->lock);
1233 fi->nlookup++;
1234 spin_unlock(&fc->lock);
1235
1236 fuse_change_attributes(inode, &o->attr,
1237 entry_attr_timeout(o),
1238 attr_version);
1239 /*
1240 * The other branch comes via fuse_iget()
1241 * which bumps nlookup inside
1242 */
1243 } else {
1244 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1245 &o->attr, entry_attr_timeout(o),
1246 attr_version);
1247 if (!inode)
1248 inode = ERR_PTR(-ENOMEM);
1249
1250 alias = d_splice_alias(inode, dentry);
1251 d_lookup_done(dentry);
1252 if (alias) {
1253 dput(dentry);
1254 dentry = alias;
1255 }
1256 if (IS_ERR(dentry))
1257 return PTR_ERR(dentry);
1258 }
1259 if (fc->readdirplus_auto)
1260 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1261 fuse_change_entry_timeout(dentry, o);
1262
1263 dput(dentry);
1264 return 0;
1265 }
1266
1267 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1268 struct dir_context *ctx, u64 attr_version)
1269 {
1270 struct fuse_direntplus *direntplus;
1271 struct fuse_dirent *dirent;
1272 size_t reclen;
1273 int over = 0;
1274 int ret;
1275
1276 while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1277 direntplus = (struct fuse_direntplus *) buf;
1278 dirent = &direntplus->dirent;
1279 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1280
1281 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1282 return -EIO;
1283 if (reclen > nbytes)
1284 break;
1285 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1286 return -EIO;
1287
1288 if (!over) {
1289 /* We fill entries into dstbuf only as much as
1290 it can hold. But we still continue iterating
1291 over remaining entries to link them. If not,
1292 we need to send a FORGET for each of those
1293 which we did not link.
1294 */
1295 over = !dir_emit(ctx, dirent->name, dirent->namelen,
1296 dirent->ino, dirent->type);
1297 ctx->pos = dirent->off;
1298 }
1299
1300 buf += reclen;
1301 nbytes -= reclen;
1302
1303 ret = fuse_direntplus_link(file, direntplus, attr_version);
1304 if (ret)
1305 fuse_force_forget(file, direntplus->entry_out.nodeid);
1306 }
1307
1308 return 0;
1309 }
1310
1311 static int fuse_readdir(struct file *file, struct dir_context *ctx)
1312 {
1313 int plus, err;
1314 size_t nbytes;
1315 struct page *page;
1316 struct inode *inode = file_inode(file);
1317 struct fuse_conn *fc = get_fuse_conn(inode);
1318 struct fuse_req *req;
1319 u64 attr_version = 0;
1320
1321 if (is_bad_inode(inode))
1322 return -EIO;
1323
1324 req = fuse_get_req(fc, 1);
1325 if (IS_ERR(req))
1326 return PTR_ERR(req);
1327
1328 page = alloc_page(GFP_KERNEL);
1329 if (!page) {
1330 fuse_put_request(fc, req);
1331 return -ENOMEM;
1332 }
1333
1334 plus = fuse_use_readdirplus(inode, ctx);
1335 req->out.argpages = 1;
1336 req->num_pages = 1;
1337 req->pages[0] = page;
1338 req->page_descs[0].length = PAGE_SIZE;
1339 if (plus) {
1340 attr_version = fuse_get_attr_version(fc);
1341 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1342 FUSE_READDIRPLUS);
1343 } else {
1344 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1345 FUSE_READDIR);
1346 }
1347 fuse_lock_inode(inode);
1348 fuse_request_send(fc, req);
1349 fuse_unlock_inode(inode);
1350 nbytes = req->out.args[0].size;
1351 err = req->out.h.error;
1352 fuse_put_request(fc, req);
1353 if (!err) {
1354 if (plus) {
1355 err = parse_dirplusfile(page_address(page), nbytes,
1356 file, ctx,
1357 attr_version);
1358 } else {
1359 err = parse_dirfile(page_address(page), nbytes, file,
1360 ctx);
1361 }
1362 }
1363
1364 __free_page(page);
1365 fuse_invalidate_atime(inode);
1366 return err;
1367 }
1368
1369 static const char *fuse_get_link(struct dentry *dentry,
1370 struct inode *inode,
1371 struct delayed_call *done)
1372 {
1373 struct fuse_conn *fc = get_fuse_conn(inode);
1374 FUSE_ARGS(args);
1375 char *link;
1376 ssize_t ret;
1377
1378 if (!dentry)
1379 return ERR_PTR(-ECHILD);
1380
1381 link = kmalloc(PAGE_SIZE, GFP_KERNEL);
1382 if (!link)
1383 return ERR_PTR(-ENOMEM);
1384
1385 args.in.h.opcode = FUSE_READLINK;
1386 args.in.h.nodeid = get_node_id(inode);
1387 args.out.argvar = 1;
1388 args.out.numargs = 1;
1389 args.out.args[0].size = PAGE_SIZE - 1;
1390 args.out.args[0].value = link;
1391 ret = fuse_simple_request(fc, &args);
1392 if (ret < 0) {
1393 kfree(link);
1394 link = ERR_PTR(ret);
1395 } else {
1396 link[ret] = '\0';
1397 set_delayed_call(done, kfree_link, link);
1398 }
1399 fuse_invalidate_atime(inode);
1400 return link;
1401 }
1402
1403 static int fuse_dir_open(struct inode *inode, struct file *file)
1404 {
1405 return fuse_open_common(inode, file, true);
1406 }
1407
1408 static int fuse_dir_release(struct inode *inode, struct file *file)
1409 {
1410 fuse_release_common(file, FUSE_RELEASEDIR);
1411
1412 return 0;
1413 }
1414
1415 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1416 int datasync)
1417 {
1418 return fuse_fsync_common(file, start, end, datasync, 1);
1419 }
1420
1421 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1422 unsigned long arg)
1423 {
1424 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1425
1426 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1427 if (fc->minor < 18)
1428 return -ENOTTY;
1429
1430 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1431 }
1432
1433 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1434 unsigned long arg)
1435 {
1436 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1437
1438 if (fc->minor < 18)
1439 return -ENOTTY;
1440
1441 return fuse_ioctl_common(file, cmd, arg,
1442 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1443 }
1444
1445 static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1446 {
1447 /* Always update if mtime is explicitly set */
1448 if (ivalid & ATTR_MTIME_SET)
1449 return true;
1450
1451 /* Or if kernel i_mtime is the official one */
1452 if (trust_local_mtime)
1453 return true;
1454
1455 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1456 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1457 return false;
1458
1459 /* In all other cases update */
1460 return true;
1461 }
1462
1463 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg,
1464 bool trust_local_cmtime)
1465 {
1466 unsigned ivalid = iattr->ia_valid;
1467
1468 if (ivalid & ATTR_MODE)
1469 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1470 if (ivalid & ATTR_UID)
1471 arg->valid |= FATTR_UID, arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
1472 if (ivalid & ATTR_GID)
1473 arg->valid |= FATTR_GID, arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
1474 if (ivalid & ATTR_SIZE)
1475 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1476 if (ivalid & ATTR_ATIME) {
1477 arg->valid |= FATTR_ATIME;
1478 arg->atime = iattr->ia_atime.tv_sec;
1479 arg->atimensec = iattr->ia_atime.tv_nsec;
1480 if (!(ivalid & ATTR_ATIME_SET))
1481 arg->valid |= FATTR_ATIME_NOW;
1482 }
1483 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1484 arg->valid |= FATTR_MTIME;
1485 arg->mtime = iattr->ia_mtime.tv_sec;
1486 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1487 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1488 arg->valid |= FATTR_MTIME_NOW;
1489 }
1490 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1491 arg->valid |= FATTR_CTIME;
1492 arg->ctime = iattr->ia_ctime.tv_sec;
1493 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1494 }
1495 }
1496
1497 /*
1498 * Prevent concurrent writepages on inode
1499 *
1500 * This is done by adding a negative bias to the inode write counter
1501 * and waiting for all pending writes to finish.
1502 */
1503 void fuse_set_nowrite(struct inode *inode)
1504 {
1505 struct fuse_conn *fc = get_fuse_conn(inode);
1506 struct fuse_inode *fi = get_fuse_inode(inode);
1507
1508 BUG_ON(!inode_is_locked(inode));
1509
1510 spin_lock(&fc->lock);
1511 BUG_ON(fi->writectr < 0);
1512 fi->writectr += FUSE_NOWRITE;
1513 spin_unlock(&fc->lock);
1514 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1515 }
1516
1517 /*
1518 * Allow writepages on inode
1519 *
1520 * Remove the bias from the writecounter and send any queued
1521 * writepages.
1522 */
1523 static void __fuse_release_nowrite(struct inode *inode)
1524 {
1525 struct fuse_inode *fi = get_fuse_inode(inode);
1526
1527 BUG_ON(fi->writectr != FUSE_NOWRITE);
1528 fi->writectr = 0;
1529 fuse_flush_writepages(inode);
1530 }
1531
1532 void fuse_release_nowrite(struct inode *inode)
1533 {
1534 struct fuse_conn *fc = get_fuse_conn(inode);
1535
1536 spin_lock(&fc->lock);
1537 __fuse_release_nowrite(inode);
1538 spin_unlock(&fc->lock);
1539 }
1540
1541 static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
1542 struct inode *inode,
1543 struct fuse_setattr_in *inarg_p,
1544 struct fuse_attr_out *outarg_p)
1545 {
1546 args->in.h.opcode = FUSE_SETATTR;
1547 args->in.h.nodeid = get_node_id(inode);
1548 args->in.numargs = 1;
1549 args->in.args[0].size = sizeof(*inarg_p);
1550 args->in.args[0].value = inarg_p;
1551 args->out.numargs = 1;
1552 args->out.args[0].size = sizeof(*outarg_p);
1553 args->out.args[0].value = outarg_p;
1554 }
1555
1556 /*
1557 * Flush inode->i_mtime to the server
1558 */
1559 int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1560 {
1561 struct fuse_conn *fc = get_fuse_conn(inode);
1562 FUSE_ARGS(args);
1563 struct fuse_setattr_in inarg;
1564 struct fuse_attr_out outarg;
1565
1566 memset(&inarg, 0, sizeof(inarg));
1567 memset(&outarg, 0, sizeof(outarg));
1568
1569 inarg.valid = FATTR_MTIME;
1570 inarg.mtime = inode->i_mtime.tv_sec;
1571 inarg.mtimensec = inode->i_mtime.tv_nsec;
1572 if (fc->minor >= 23) {
1573 inarg.valid |= FATTR_CTIME;
1574 inarg.ctime = inode->i_ctime.tv_sec;
1575 inarg.ctimensec = inode->i_ctime.tv_nsec;
1576 }
1577 if (ff) {
1578 inarg.valid |= FATTR_FH;
1579 inarg.fh = ff->fh;
1580 }
1581 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1582
1583 return fuse_simple_request(fc, &args);
1584 }
1585
1586 /*
1587 * Set attributes, and at the same time refresh them.
1588 *
1589 * Truncation is slightly complicated, because the 'truncate' request
1590 * may fail, in which case we don't want to touch the mapping.
1591 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1592 * and the actual truncation by hand.
1593 */
1594 int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1595 struct file *file)
1596 {
1597 struct fuse_conn *fc = get_fuse_conn(inode);
1598 struct fuse_inode *fi = get_fuse_inode(inode);
1599 FUSE_ARGS(args);
1600 struct fuse_setattr_in inarg;
1601 struct fuse_attr_out outarg;
1602 bool is_truncate = false;
1603 bool is_wb = fc->writeback_cache;
1604 loff_t oldsize;
1605 int err;
1606 bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
1607
1608 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1609 attr->ia_valid |= ATTR_FORCE;
1610
1611 err = inode_change_ok(inode, attr);
1612 if (err)
1613 return err;
1614
1615 if (attr->ia_valid & ATTR_OPEN) {
1616 if (fc->atomic_o_trunc)
1617 return 0;
1618 file = NULL;
1619 }
1620
1621 if (attr->ia_valid & ATTR_SIZE)
1622 is_truncate = true;
1623
1624 if (is_truncate) {
1625 fuse_set_nowrite(inode);
1626 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1627 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1628 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1629 }
1630
1631 memset(&inarg, 0, sizeof(inarg));
1632 memset(&outarg, 0, sizeof(outarg));
1633 iattr_to_fattr(attr, &inarg, trust_local_cmtime);
1634 if (file) {
1635 struct fuse_file *ff = file->private_data;
1636 inarg.valid |= FATTR_FH;
1637 inarg.fh = ff->fh;
1638 }
1639 if (attr->ia_valid & ATTR_SIZE) {
1640 /* For mandatory locking in truncate */
1641 inarg.valid |= FATTR_LOCKOWNER;
1642 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1643 }
1644 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1645 err = fuse_simple_request(fc, &args);
1646 if (err) {
1647 if (err == -EINTR)
1648 fuse_invalidate_attr(inode);
1649 goto error;
1650 }
1651
1652 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1653 make_bad_inode(inode);
1654 err = -EIO;
1655 goto error;
1656 }
1657
1658 spin_lock(&fc->lock);
1659 /* the kernel maintains i_mtime locally */
1660 if (trust_local_cmtime) {
1661 if (attr->ia_valid & ATTR_MTIME)
1662 inode->i_mtime = attr->ia_mtime;
1663 if (attr->ia_valid & ATTR_CTIME)
1664 inode->i_ctime = attr->ia_ctime;
1665 /* FIXME: clear I_DIRTY_SYNC? */
1666 }
1667
1668 fuse_change_attributes_common(inode, &outarg.attr,
1669 attr_timeout(&outarg));
1670 oldsize = inode->i_size;
1671 /* see the comment in fuse_change_attributes() */
1672 if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1673 i_size_write(inode, outarg.attr.size);
1674
1675 if (is_truncate) {
1676 /* NOTE: this may release/reacquire fc->lock */
1677 __fuse_release_nowrite(inode);
1678 }
1679 spin_unlock(&fc->lock);
1680
1681 /*
1682 * Only call invalidate_inode_pages2() after removing
1683 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1684 */
1685 if ((is_truncate || !is_wb) &&
1686 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1687 truncate_pagecache(inode, outarg.attr.size);
1688 invalidate_inode_pages2(inode->i_mapping);
1689 }
1690
1691 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1692 return 0;
1693
1694 error:
1695 if (is_truncate)
1696 fuse_release_nowrite(inode);
1697
1698 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1699 return err;
1700 }
1701
1702 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1703 {
1704 struct inode *inode = d_inode(entry);
1705
1706 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1707 return -EACCES;
1708
1709 if (attr->ia_valid & ATTR_FILE)
1710 return fuse_do_setattr(inode, attr, attr->ia_file);
1711 else
1712 return fuse_do_setattr(inode, attr, NULL);
1713 }
1714
1715 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1716 struct kstat *stat)
1717 {
1718 struct inode *inode = d_inode(entry);
1719 struct fuse_conn *fc = get_fuse_conn(inode);
1720
1721 if (!fuse_allow_current_process(fc))
1722 return -EACCES;
1723
1724 return fuse_update_attributes(inode, stat, NULL, NULL);
1725 }
1726
1727 static int fuse_setxattr(struct dentry *unused, struct inode *inode,
1728 const char *name, const void *value,
1729 size_t size, int flags)
1730 {
1731 struct fuse_conn *fc = get_fuse_conn(inode);
1732 FUSE_ARGS(args);
1733 struct fuse_setxattr_in inarg;
1734 int err;
1735
1736 if (fc->no_setxattr)
1737 return -EOPNOTSUPP;
1738
1739 memset(&inarg, 0, sizeof(inarg));
1740 inarg.size = size;
1741 inarg.flags = flags;
1742 args.in.h.opcode = FUSE_SETXATTR;
1743 args.in.h.nodeid = get_node_id(inode);
1744 args.in.numargs = 3;
1745 args.in.args[0].size = sizeof(inarg);
1746 args.in.args[0].value = &inarg;
1747 args.in.args[1].size = strlen(name) + 1;
1748 args.in.args[1].value = name;
1749 args.in.args[2].size = size;
1750 args.in.args[2].value = value;
1751 err = fuse_simple_request(fc, &args);
1752 if (err == -ENOSYS) {
1753 fc->no_setxattr = 1;
1754 err = -EOPNOTSUPP;
1755 }
1756 if (!err) {
1757 fuse_invalidate_attr(inode);
1758 fuse_update_ctime(inode);
1759 }
1760 return err;
1761 }
1762
1763 static ssize_t fuse_getxattr(struct dentry *entry, struct inode *inode,
1764 const char *name, void *value, size_t size)
1765 {
1766 struct fuse_conn *fc = get_fuse_conn(inode);
1767 FUSE_ARGS(args);
1768 struct fuse_getxattr_in inarg;
1769 struct fuse_getxattr_out outarg;
1770 ssize_t ret;
1771
1772 if (fc->no_getxattr)
1773 return -EOPNOTSUPP;
1774
1775 memset(&inarg, 0, sizeof(inarg));
1776 inarg.size = size;
1777 args.in.h.opcode = FUSE_GETXATTR;
1778 args.in.h.nodeid = get_node_id(inode);
1779 args.in.numargs = 2;
1780 args.in.args[0].size = sizeof(inarg);
1781 args.in.args[0].value = &inarg;
1782 args.in.args[1].size = strlen(name) + 1;
1783 args.in.args[1].value = name;
1784 /* This is really two different operations rolled into one */
1785 args.out.numargs = 1;
1786 if (size) {
1787 args.out.argvar = 1;
1788 args.out.args[0].size = size;
1789 args.out.args[0].value = value;
1790 } else {
1791 args.out.args[0].size = sizeof(outarg);
1792 args.out.args[0].value = &outarg;
1793 }
1794 ret = fuse_simple_request(fc, &args);
1795 if (!ret && !size)
1796 ret = outarg.size;
1797 if (ret == -ENOSYS) {
1798 fc->no_getxattr = 1;
1799 ret = -EOPNOTSUPP;
1800 }
1801 return ret;
1802 }
1803
1804 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1805 {
1806 struct inode *inode = d_inode(entry);
1807 struct fuse_conn *fc = get_fuse_conn(inode);
1808 FUSE_ARGS(args);
1809 struct fuse_getxattr_in inarg;
1810 struct fuse_getxattr_out outarg;
1811 ssize_t ret;
1812
1813 if (!fuse_allow_current_process(fc))
1814 return -EACCES;
1815
1816 if (fc->no_listxattr)
1817 return -EOPNOTSUPP;
1818
1819 memset(&inarg, 0, sizeof(inarg));
1820 inarg.size = size;
1821 args.in.h.opcode = FUSE_LISTXATTR;
1822 args.in.h.nodeid = get_node_id(inode);
1823 args.in.numargs = 1;
1824 args.in.args[0].size = sizeof(inarg);
1825 args.in.args[0].value = &inarg;
1826 /* This is really two different operations rolled into one */
1827 args.out.numargs = 1;
1828 if (size) {
1829 args.out.argvar = 1;
1830 args.out.args[0].size = size;
1831 args.out.args[0].value = list;
1832 } else {
1833 args.out.args[0].size = sizeof(outarg);
1834 args.out.args[0].value = &outarg;
1835 }
1836 ret = fuse_simple_request(fc, &args);
1837 if (!ret && !size)
1838 ret = outarg.size;
1839 if (ret == -ENOSYS) {
1840 fc->no_listxattr = 1;
1841 ret = -EOPNOTSUPP;
1842 }
1843 return ret;
1844 }
1845
1846 static int fuse_removexattr(struct dentry *entry, const char *name)
1847 {
1848 struct inode *inode = d_inode(entry);
1849 struct fuse_conn *fc = get_fuse_conn(inode);
1850 FUSE_ARGS(args);
1851 int err;
1852
1853 if (fc->no_removexattr)
1854 return -EOPNOTSUPP;
1855
1856 args.in.h.opcode = FUSE_REMOVEXATTR;
1857 args.in.h.nodeid = get_node_id(inode);
1858 args.in.numargs = 1;
1859 args.in.args[0].size = strlen(name) + 1;
1860 args.in.args[0].value = name;
1861 err = fuse_simple_request(fc, &args);
1862 if (err == -ENOSYS) {
1863 fc->no_removexattr = 1;
1864 err = -EOPNOTSUPP;
1865 }
1866 if (!err) {
1867 fuse_invalidate_attr(inode);
1868 fuse_update_ctime(inode);
1869 }
1870 return err;
1871 }
1872
1873 static const struct inode_operations fuse_dir_inode_operations = {
1874 .lookup = fuse_lookup,
1875 .mkdir = fuse_mkdir,
1876 .symlink = fuse_symlink,
1877 .unlink = fuse_unlink,
1878 .rmdir = fuse_rmdir,
1879 .rename = fuse_rename2,
1880 .link = fuse_link,
1881 .setattr = fuse_setattr,
1882 .create = fuse_create,
1883 .atomic_open = fuse_atomic_open,
1884 .mknod = fuse_mknod,
1885 .permission = fuse_permission,
1886 .getattr = fuse_getattr,
1887 .setxattr = fuse_setxattr,
1888 .getxattr = fuse_getxattr,
1889 .listxattr = fuse_listxattr,
1890 .removexattr = fuse_removexattr,
1891 };
1892
1893 static const struct file_operations fuse_dir_operations = {
1894 .llseek = generic_file_llseek,
1895 .read = generic_read_dir,
1896 .iterate_shared = fuse_readdir,
1897 .open = fuse_dir_open,
1898 .release = fuse_dir_release,
1899 .fsync = fuse_dir_fsync,
1900 .unlocked_ioctl = fuse_dir_ioctl,
1901 .compat_ioctl = fuse_dir_compat_ioctl,
1902 };
1903
1904 static const struct inode_operations fuse_common_inode_operations = {
1905 .setattr = fuse_setattr,
1906 .permission = fuse_permission,
1907 .getattr = fuse_getattr,
1908 .setxattr = fuse_setxattr,
1909 .getxattr = fuse_getxattr,
1910 .listxattr = fuse_listxattr,
1911 .removexattr = fuse_removexattr,
1912 };
1913
1914 static const struct inode_operations fuse_symlink_inode_operations = {
1915 .setattr = fuse_setattr,
1916 .get_link = fuse_get_link,
1917 .readlink = generic_readlink,
1918 .getattr = fuse_getattr,
1919 .setxattr = fuse_setxattr,
1920 .getxattr = fuse_getxattr,
1921 .listxattr = fuse_listxattr,
1922 .removexattr = fuse_removexattr,
1923 };
1924
1925 void fuse_init_common(struct inode *inode)
1926 {
1927 inode->i_op = &fuse_common_inode_operations;
1928 }
1929
1930 void fuse_init_dir(struct inode *inode)
1931 {
1932 inode->i_op = &fuse_dir_inode_operations;
1933 inode->i_fop = &fuse_dir_operations;
1934 }
1935
1936 void fuse_init_symlink(struct inode *inode)
1937 {
1938 inode->i_op = &fuse_symlink_inode_operations;
1939 }
Linux kernel - Deliverables
This page took 0.137108 seconds and 5 git commands to generate.