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