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