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