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