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