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