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