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