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