1
2
3
4
5
6
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
18static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
19{
20 entry->d_time = time;
21}
22
23static inline u64 fuse_dentry_time(struct dentry *entry)
24{
25 return entry->d_time;
26}
27#else
28
29
30
31static 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
37static 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
46
47
48
49
50
51
52
53static 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
64
65
66static 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
73static u64 attr_timeout(struct fuse_attr_out *o)
74{
75 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
76}
77
78static 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
85
86
87void fuse_invalidate_attr(struct inode *inode)
88{
89 get_fuse_inode(inode)->i_time = 0;
90}
91
92
93
94
95
96
97
98
99
100void fuse_invalidate_entry_cache(struct dentry *entry)
101{
102 fuse_dentry_settime(entry, 0);
103}
104
105
106
107
108
109static void fuse_invalidate_entry(struct dentry *entry)
110{
111 d_invalidate(entry);
112 fuse_invalidate_entry_cache(entry);
113}
114
115static 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
133u64 fuse_get_attr_version(struct fuse_conn *fc)
134{
135 u64 curr_version;
136
137
138
139
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
150
151
152
153
154
155
156
157static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
158{
159 struct inode *inode;
160
161 if (nd && nd->flags & LOOKUP_RCU)
162 return -ECHILD;
163
164 inode = entry->d_inode;
165 if (inode && is_bad_inode(inode))
166 return 0;
167 else if (fuse_dentry_time(entry) < get_jiffies_64()) {
168 int err;
169 struct fuse_entry_out outarg;
170 struct fuse_conn *fc;
171 struct fuse_req *req;
172 struct fuse_forget_link *forget;
173 struct dentry *parent;
174 u64 attr_version;
175
176
177 if (!inode)
178 return 0;
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
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
225static int invalid_nodeid(u64 nodeid)
226{
227 return !nodeid || nodeid == FUSE_ROOT_ID;
228}
229
230const struct dentry_operations fuse_dentry_operations = {
231 .d_revalidate = fuse_dentry_revalidate,
232};
233
234int 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
242
243
244static 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
250 fuse_invalidate_entry(alias);
251 dput(alias);
252 if (!list_empty(&inode->i_dentry))
253 return ERR_PTR(-EBUSY);
254 } else {
255 dput(alias);
256 }
257 return d_splice_alias(inode, entry);
258}
259
260int 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
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
318static 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
368
369
370
371
372static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
373 struct nameidata *nd)
374{
375 int err;
376 struct inode *inode;
377 struct fuse_conn *fc = get_fuse_conn(dir);
378 struct fuse_req *req;
379 struct fuse_forget_link *forget;
380 struct fuse_create_in inarg;
381 struct fuse_open_out outopen;
382 struct fuse_entry_out outentry;
383 struct fuse_file *ff;
384 struct file *file;
385 int flags = nd->intent.open.flags - 1;
386
387 if (fc->no_create)
388 return -ENOSYS;
389
390 if (flags & O_DIRECT)
391 return -EINVAL;
392
393 forget = fuse_alloc_forget();
394 if (!forget)
395 return -ENOMEM;
396
397 req = fuse_get_req(fc);
398 err = PTR_ERR(req);
399 if (IS_ERR(req))
400 goto out_put_forget_req;
401
402 err = -ENOMEM;
403 ff = fuse_file_alloc(fc);
404 if (!ff)
405 goto out_put_request;
406
407 if (!fc->dont_mask)
408 mode &= ~current_umask();
409
410 flags &= ~O_NOCTTY;
411 memset(&inarg, 0, sizeof(inarg));
412 memset(&outentry, 0, sizeof(outentry));
413 inarg.flags = flags;
414 inarg.mode = mode;
415 inarg.umask = current_umask();
416 req->in.h.opcode = FUSE_CREATE;
417 req->in.h.nodeid = get_node_id(dir);
418 req->in.numargs = 2;
419 req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
420 sizeof(inarg);
421 req->in.args[0].value = &inarg;
422 req->in.args[1].size = entry->d_name.len + 1;
423 req->in.args[1].value = entry->d_name.name;
424 req->out.numargs = 2;
425 if (fc->minor < 9)
426 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
427 else
428 req->out.args[0].size = sizeof(outentry);
429 req->out.args[0].value = &outentry;
430 req->out.args[1].size = sizeof(outopen);
431 req->out.args[1].value = &outopen;
432 fuse_request_send(fc, req);
433 err = req->out.h.error;
434 if (err) {
435 if (err == -ENOSYS)
436 fc->no_create = 1;
437 goto out_free_ff;
438 }
439
440 err = -EIO;
441 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
442 goto out_free_ff;
443
444 fuse_put_request(fc, req);
445 ff->fh = outopen.fh;
446 ff->nodeid = outentry.nodeid;
447 ff->open_flags = outopen.open_flags;
448 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
449 &outentry.attr, entry_attr_timeout(&outentry), 0);
450 if (!inode) {
451 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
452 fuse_sync_release(ff, flags);
453 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
454 return -ENOMEM;
455 }
456 kfree(forget);
457 d_instantiate(entry, inode);
458 fuse_change_entry_timeout(entry, &outentry);
459 fuse_invalidate_attr(dir);
460 file = lookup_instantiate_filp(nd, entry, generic_file_open);
461 if (IS_ERR(file)) {
462 fuse_sync_release(ff, flags);
463 return PTR_ERR(file);
464 }
465 file->private_data = fuse_file_get(ff);
466 fuse_finish_open(inode, file);
467 return 0;
468
469 out_free_ff:
470 fuse_file_free(ff);
471 out_put_request:
472 fuse_put_request(fc, req);
473 out_put_forget_req:
474 kfree(forget);
475 return err;
476}
477
478
479
480
481static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
482 struct inode *dir, struct dentry *entry,
483 int mode)
484{
485 struct fuse_entry_out outarg;
486 struct inode *inode;
487 int err;
488 struct fuse_forget_link *forget;
489
490 forget = fuse_alloc_forget();
491 if (!forget) {
492 fuse_put_request(fc, req);
493 return -ENOMEM;
494 }
495
496 memset(&outarg, 0, sizeof(outarg));
497 req->in.h.nodeid = get_node_id(dir);
498 req->out.numargs = 1;
499 if (fc->minor < 9)
500 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
501 else
502 req->out.args[0].size = sizeof(outarg);
503 req->out.args[0].value = &outarg;
504 fuse_request_send(fc, req);
505 err = req->out.h.error;
506 fuse_put_request(fc, req);
507 if (err)
508 goto out_put_forget_req;
509
510 err = -EIO;
511 if (invalid_nodeid(outarg.nodeid))
512 goto out_put_forget_req;
513
514 if ((outarg.attr.mode ^ mode) & S_IFMT)
515 goto out_put_forget_req;
516
517 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
518 &outarg.attr, entry_attr_timeout(&outarg), 0);
519 if (!inode) {
520 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
521 return -ENOMEM;
522 }
523 kfree(forget);
524
525 if (S_ISDIR(inode->i_mode)) {
526 struct dentry *alias;
527 mutex_lock(&fc->inst_mutex);
528 alias = d_find_alias(inode);
529 if (alias) {
530
531 mutex_unlock(&fc->inst_mutex);
532 dput(alias);
533 iput(inode);
534 return -EBUSY;
535 }
536 d_instantiate(entry, inode);
537 mutex_unlock(&fc->inst_mutex);
538 } else
539 d_instantiate(entry, inode);
540
541 fuse_change_entry_timeout(entry, &outarg);
542 fuse_invalidate_attr(dir);
543 return 0;
544
545 out_put_forget_req:
546 kfree(forget);
547 return err;
548}
549
550static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
551 dev_t rdev)
552{
553 struct fuse_mknod_in inarg;
554 struct fuse_conn *fc = get_fuse_conn(dir);
555 struct fuse_req *req = fuse_get_req(fc);
556 if (IS_ERR(req))
557 return PTR_ERR(req);
558
559 if (!fc->dont_mask)
560 mode &= ~current_umask();
561
562 memset(&inarg, 0, sizeof(inarg));
563 inarg.mode = mode;
564 inarg.rdev = new_encode_dev(rdev);
565 inarg.umask = current_umask();
566 req->in.h.opcode = FUSE_MKNOD;
567 req->in.numargs = 2;
568 req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
569 sizeof(inarg);
570 req->in.args[0].value = &inarg;
571 req->in.args[1].size = entry->d_name.len + 1;
572 req->in.args[1].value = entry->d_name.name;
573 return create_new_entry(fc, req, dir, entry, mode);
574}
575
576static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
577 struct nameidata *nd)
578{
579 if (nd && (nd->flags & LOOKUP_OPEN)) {
580 int err = fuse_create_open(dir, entry, mode, nd);
581 if (err != -ENOSYS)
582 return err;
583
584 }
585 return fuse_mknod(dir, entry, mode, 0);
586}
587
588static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
589{
590 struct fuse_mkdir_in inarg;
591 struct fuse_conn *fc = get_fuse_conn(dir);
592 struct fuse_req *req = fuse_get_req(fc);
593 if (IS_ERR(req))
594 return PTR_ERR(req);
595
596 if (!fc->dont_mask)
597 mode &= ~current_umask();
598
599 memset(&inarg, 0, sizeof(inarg));
600 inarg.mode = mode;
601 inarg.umask = current_umask();
602 req->in.h.opcode = FUSE_MKDIR;
603 req->in.numargs = 2;
604 req->in.args[0].size = sizeof(inarg);
605 req->in.args[0].value = &inarg;
606 req->in.args[1].size = entry->d_name.len + 1;
607 req->in.args[1].value = entry->d_name.name;
608 return create_new_entry(fc, req, dir, entry, S_IFDIR);
609}
610
611static int fuse_symlink(struct inode *dir, struct dentry *entry,
612 const char *link)
613{
614 struct fuse_conn *fc = get_fuse_conn(dir);
615 unsigned len = strlen(link) + 1;
616 struct fuse_req *req = fuse_get_req(fc);
617 if (IS_ERR(req))
618 return PTR_ERR(req);
619
620 req->in.h.opcode = FUSE_SYMLINK;
621 req->in.numargs = 2;
622 req->in.args[0].size = entry->d_name.len + 1;
623 req->in.args[0].value = entry->d_name.name;
624 req->in.args[1].size = len;
625 req->in.args[1].value = link;
626 return create_new_entry(fc, req, dir, entry, S_IFLNK);
627}
628
629static int fuse_unlink(struct inode *dir, struct dentry *entry)
630{
631 int err;
632 struct fuse_conn *fc = get_fuse_conn(dir);
633 struct fuse_req *req = fuse_get_req(fc);
634 if (IS_ERR(req))
635 return PTR_ERR(req);
636
637 req->in.h.opcode = FUSE_UNLINK;
638 req->in.h.nodeid = get_node_id(dir);
639 req->in.numargs = 1;
640 req->in.args[0].size = entry->d_name.len + 1;
641 req->in.args[0].value = entry->d_name.name;
642 fuse_request_send(fc, req);
643 err = req->out.h.error;
644 fuse_put_request(fc, req);
645 if (!err) {
646 struct inode *inode = entry->d_inode;
647
648
649
650
651
652
653 clear_nlink(inode);
654 fuse_invalidate_attr(inode);
655 fuse_invalidate_attr(dir);
656 fuse_invalidate_entry_cache(entry);
657 } else if (err == -EINTR)
658 fuse_invalidate_entry(entry);
659 return err;
660}
661
662static int fuse_rmdir(struct inode *dir, struct dentry *entry)
663{
664 int err;
665 struct fuse_conn *fc = get_fuse_conn(dir);
666 struct fuse_req *req = fuse_get_req(fc);
667 if (IS_ERR(req))
668 return PTR_ERR(req);
669
670 req->in.h.opcode = FUSE_RMDIR;
671 req->in.h.nodeid = get_node_id(dir);
672 req->in.numargs = 1;
673 req->in.args[0].size = entry->d_name.len + 1;
674 req->in.args[0].value = entry->d_name.name;
675 fuse_request_send(fc, req);
676 err = req->out.h.error;
677 fuse_put_request(fc, req);
678 if (!err) {
679 clear_nlink(entry->d_inode);
680 fuse_invalidate_attr(dir);
681 fuse_invalidate_entry_cache(entry);
682 } else if (err == -EINTR)
683 fuse_invalidate_entry(entry);
684 return err;
685}
686
687static int fuse_rename(struct inode *olddir, struct dentry *oldent,
688 struct inode *newdir, struct dentry *newent)
689{
690 int err;
691 struct fuse_rename_in inarg;
692 struct fuse_conn *fc = get_fuse_conn(olddir);
693 struct fuse_req *req = fuse_get_req(fc);
694 if (IS_ERR(req))
695 return PTR_ERR(req);
696
697 memset(&inarg, 0, sizeof(inarg));
698 inarg.newdir = get_node_id(newdir);
699 req->in.h.opcode = FUSE_RENAME;
700 req->in.h.nodeid = get_node_id(olddir);
701 req->in.numargs = 3;
702 req->in.args[0].size = sizeof(inarg);
703 req->in.args[0].value = &inarg;
704 req->in.args[1].size = oldent->d_name.len + 1;
705 req->in.args[1].value = oldent->d_name.name;
706 req->in.args[2].size = newent->d_name.len + 1;
707 req->in.args[2].value = newent->d_name.name;
708 fuse_request_send(fc, req);
709 err = req->out.h.error;
710 fuse_put_request(fc, req);
711 if (!err) {
712
713 fuse_invalidate_attr(oldent->d_inode);
714
715 fuse_invalidate_attr(olddir);
716 if (olddir != newdir)
717 fuse_invalidate_attr(newdir);
718
719
720 if (newent->d_inode) {
721 fuse_invalidate_attr(newent->d_inode);
722 fuse_invalidate_entry_cache(newent);
723 }
724 } else if (err == -EINTR) {
725
726
727
728
729
730 fuse_invalidate_entry(oldent);
731 if (newent->d_inode)
732 fuse_invalidate_entry(newent);
733 }
734
735 return err;
736}
737
738static int fuse_link(struct dentry *entry, struct inode *newdir,
739 struct dentry *newent)
740{
741 int err;
742 struct fuse_link_in inarg;
743 struct inode *inode = entry->d_inode;
744 struct fuse_conn *fc = get_fuse_conn(inode);
745 struct fuse_req *req = fuse_get_req(fc);
746 if (IS_ERR(req))
747 return PTR_ERR(req);
748
749 memset(&inarg, 0, sizeof(inarg));
750 inarg.oldnodeid = get_node_id(inode);
751 req->in.h.opcode = FUSE_LINK;
752 req->in.numargs = 2;
753 req->in.args[0].size = sizeof(inarg);
754 req->in.args[0].value = &inarg;
755 req->in.args[1].size = newent->d_name.len + 1;
756 req->in.args[1].value = newent->d_name.name;
757 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
758
759
760
761
762
763
764 if (!err || err == -EINTR)
765 fuse_invalidate_attr(inode);
766 return err;
767}
768
769static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
770 struct kstat *stat)
771{
772 stat->dev = inode->i_sb->s_dev;
773 stat->ino = attr->ino;
774 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
775 stat->nlink = attr->nlink;
776 stat->uid = attr->uid;
777 stat->gid = attr->gid;
778 stat->rdev = inode->i_rdev;
779 stat->atime.tv_sec = attr->atime;
780 stat->atime.tv_nsec = attr->atimensec;
781 stat->mtime.tv_sec = attr->mtime;
782 stat->mtime.tv_nsec = attr->mtimensec;
783 stat->ctime.tv_sec = attr->ctime;
784 stat->ctime.tv_nsec = attr->ctimensec;
785 stat->size = attr->size;
786 stat->blocks = attr->blocks;
787 stat->blksize = (1 << inode->i_blkbits);
788}
789
790static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
791 struct file *file)
792{
793 int err;
794 struct fuse_getattr_in inarg;
795 struct fuse_attr_out outarg;
796 struct fuse_conn *fc = get_fuse_conn(inode);
797 struct fuse_req *req;
798 u64 attr_version;
799
800 req = fuse_get_req(fc);
801 if (IS_ERR(req))
802 return PTR_ERR(req);
803
804 attr_version = fuse_get_attr_version(fc);
805
806 memset(&inarg, 0, sizeof(inarg));
807 memset(&outarg, 0, sizeof(outarg));
808
809 if (file && S_ISREG(inode->i_mode)) {
810 struct fuse_file *ff = file->private_data;
811
812 inarg.getattr_flags |= FUSE_GETATTR_FH;
813 inarg.fh = ff->fh;
814 }
815 req->in.h.opcode = FUSE_GETATTR;
816 req->in.h.nodeid = get_node_id(inode);
817 req->in.numargs = 1;
818 req->in.args[0].size = sizeof(inarg);
819 req->in.args[0].value = &inarg;
820 req->out.numargs = 1;
821 if (fc->minor < 9)
822 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
823 else
824 req->out.args[0].size = sizeof(outarg);
825 req->out.args[0].value = &outarg;
826 fuse_request_send(fc, req);
827 err = req->out.h.error;
828 fuse_put_request(fc, req);
829 if (!err) {
830 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
831 make_bad_inode(inode);
832 err = -EIO;
833 } else {
834 fuse_change_attributes(inode, &outarg.attr,
835 attr_timeout(&outarg),
836 attr_version);
837 if (stat)
838 fuse_fillattr(inode, &outarg.attr, stat);
839 }
840 }
841 return err;
842}
843
844int fuse_update_attributes(struct inode *inode, struct kstat *stat,
845 struct file *file, bool *refreshed)
846{
847 struct fuse_inode *fi = get_fuse_inode(inode);
848 int err;
849 bool r;
850
851 if (fi->i_time < get_jiffies_64()) {
852 r = true;
853 err = fuse_do_getattr(inode, stat, file);
854 } else {
855 r = false;
856 err = 0;
857 if (stat) {
858 generic_fillattr(inode, stat);
859 stat->mode = fi->orig_i_mode;
860 }
861 }
862
863 if (refreshed != NULL)
864 *refreshed = r;
865
866 return err;
867}
868
869int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
870 struct qstr *name)
871{
872 int err = -ENOTDIR;
873 struct inode *parent;
874 struct dentry *dir;
875 struct dentry *entry;
876
877 parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
878 if (!parent)
879 return -ENOENT;
880
881 mutex_lock(&parent->i_mutex);
882 if (!S_ISDIR(parent->i_mode))
883 goto unlock;
884
885 err = -ENOENT;
886 dir = d_find_alias(parent);
887 if (!dir)
888 goto unlock;
889
890 entry = d_lookup(dir, name);
891 dput(dir);
892 if (!entry)
893 goto unlock;
894
895 fuse_invalidate_attr(parent);
896 fuse_invalidate_entry(entry);
897 dput(entry);
898 err = 0;
899
900 unlock:
901 mutex_unlock(&parent->i_mutex);
902 iput(parent);
903 return err;
904}
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
920{
921 const struct cred *cred;
922 int ret;
923
924 if (fc->flags & FUSE_ALLOW_OTHER)
925 return 1;
926
927 rcu_read_lock();
928 ret = 0;
929 cred = __task_cred(task);
930 if (cred->euid == fc->user_id &&
931 cred->suid == fc->user_id &&
932 cred->uid == fc->user_id &&
933 cred->egid == fc->group_id &&
934 cred->sgid == fc->group_id &&
935 cred->gid == fc->group_id)
936 ret = 1;
937 rcu_read_unlock();
938
939 return ret;
940}
941
942static int fuse_access(struct inode *inode, int mask)
943{
944 struct fuse_conn *fc = get_fuse_conn(inode);
945 struct fuse_req *req;
946 struct fuse_access_in inarg;
947 int err;
948
949 if (fc->no_access)
950 return 0;
951
952 req = fuse_get_req(fc);
953 if (IS_ERR(req))
954 return PTR_ERR(req);
955
956 memset(&inarg, 0, sizeof(inarg));
957 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
958 req->in.h.opcode = FUSE_ACCESS;
959 req->in.h.nodeid = get_node_id(inode);
960 req->in.numargs = 1;
961 req->in.args[0].size = sizeof(inarg);
962 req->in.args[0].value = &inarg;
963 fuse_request_send(fc, req);
964 err = req->out.h.error;
965 fuse_put_request(fc, req);
966 if (err == -ENOSYS) {
967 fc->no_access = 1;
968 err = 0;
969 }
970 return err;
971}
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986static int fuse_permission(struct inode *inode, int mask, unsigned int flags)
987{
988 struct fuse_conn *fc = get_fuse_conn(inode);
989 bool refreshed = false;
990 int err = 0;
991
992 if (flags & IPERM_FLAG_RCU)
993 return -ECHILD;
994
995 if (!fuse_allow_task(fc, current))
996 return -EACCES;
997
998
999
1000
1001 if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1002 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1003 err = fuse_update_attributes(inode, NULL, NULL, &refreshed);
1004 if (err)
1005 return err;
1006 }
1007
1008 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1009 err = generic_permission(inode, mask, flags, NULL);
1010
1011
1012
1013
1014 if (err == -EACCES && !refreshed) {
1015 err = fuse_do_getattr(inode, NULL, NULL);
1016 if (!err)
1017 err = generic_permission(inode, mask,
1018 flags, NULL);
1019 }
1020
1021
1022
1023
1024
1025 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1026 err = fuse_access(inode, mask);
1027 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1028 if (!(inode->i_mode & S_IXUGO)) {
1029 if (refreshed)
1030 return -EACCES;
1031
1032 err = fuse_do_getattr(inode, NULL, NULL);
1033 if (!err && !(inode->i_mode & S_IXUGO))
1034 return -EACCES;
1035 }
1036 }
1037 return err;
1038}
1039
1040static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1041 void *dstbuf, filldir_t filldir)
1042{
1043 while (nbytes >= FUSE_NAME_OFFSET) {
1044 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1045 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1046 int over;
1047 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1048 return -EIO;
1049 if (reclen > nbytes)
1050 break;
1051
1052 over = filldir(dstbuf, dirent->name, dirent->namelen,
1053 file->f_pos, dirent->ino, dirent->type);
1054 if (over)
1055 break;
1056
1057 buf += reclen;
1058 nbytes -= reclen;
1059 file->f_pos = dirent->off;
1060 }
1061
1062 return 0;
1063}
1064
1065static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1066{
1067 int err;
1068 size_t nbytes;
1069 struct page *page;
1070 struct inode *inode = file->f_path.dentry->d_inode;
1071 struct fuse_conn *fc = get_fuse_conn(inode);
1072 struct fuse_req *req;
1073
1074 if (is_bad_inode(inode))
1075 return -EIO;
1076
1077 req = fuse_get_req(fc);
1078 if (IS_ERR(req))
1079 return PTR_ERR(req);
1080
1081 page = alloc_page(GFP_KERNEL);
1082 if (!page) {
1083 fuse_put_request(fc, req);
1084 return -ENOMEM;
1085 }
1086 req->out.argpages = 1;
1087 req->num_pages = 1;
1088 req->pages[0] = page;
1089 fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
1090 fuse_request_send(fc, req);
1091 nbytes = req->out.args[0].size;
1092 err = req->out.h.error;
1093 fuse_put_request(fc, req);
1094 if (!err)
1095 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
1096 filldir);
1097
1098 __free_page(page);
1099 fuse_invalidate_attr(inode);
1100 return err;
1101}
1102
1103static char *read_link(struct dentry *dentry)
1104{
1105 struct inode *inode = dentry->d_inode;
1106 struct fuse_conn *fc = get_fuse_conn(inode);
1107 struct fuse_req *req = fuse_get_req(fc);
1108 char *link;
1109
1110 if (IS_ERR(req))
1111 return ERR_CAST(req);
1112
1113 link = (char *) __get_free_page(GFP_KERNEL);
1114 if (!link) {
1115 link = ERR_PTR(-ENOMEM);
1116 goto out;
1117 }
1118 req->in.h.opcode = FUSE_READLINK;
1119 req->in.h.nodeid = get_node_id(inode);
1120 req->out.argvar = 1;
1121 req->out.numargs = 1;
1122 req->out.args[0].size = PAGE_SIZE - 1;
1123 req->out.args[0].value = link;
1124 fuse_request_send(fc, req);
1125 if (req->out.h.error) {
1126 free_page((unsigned long) link);
1127 link = ERR_PTR(req->out.h.error);
1128 } else
1129 link[req->out.args[0].size] = '\0';
1130 out:
1131 fuse_put_request(fc, req);
1132 fuse_invalidate_attr(inode);
1133 return link;
1134}
1135
1136static void free_link(char *link)
1137{
1138 if (!IS_ERR(link))
1139 free_page((unsigned long) link);
1140}
1141
1142static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1143{
1144 nd_set_link(nd, read_link(dentry));
1145 return NULL;
1146}
1147
1148static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1149{
1150 free_link(nd_get_link(nd));
1151}
1152
1153static int fuse_dir_open(struct inode *inode, struct file *file)
1154{
1155 return fuse_open_common(inode, file, true);
1156}
1157
1158static int fuse_dir_release(struct inode *inode, struct file *file)
1159{
1160 fuse_release_common(file, FUSE_RELEASEDIR);
1161
1162 return 0;
1163}
1164
1165static int fuse_dir_fsync(struct file *file, int datasync)
1166{
1167 return fuse_fsync_common(file, datasync, 1);
1168}
1169
1170static bool update_mtime(unsigned ivalid)
1171{
1172
1173 if (ivalid & ATTR_MTIME_SET)
1174 return true;
1175
1176
1177 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1178 return false;
1179
1180
1181 return true;
1182}
1183
1184static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1185{
1186 unsigned ivalid = iattr->ia_valid;
1187
1188 if (ivalid & ATTR_MODE)
1189 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1190 if (ivalid & ATTR_UID)
1191 arg->valid |= FATTR_UID, arg->uid = iattr->ia_uid;
1192 if (ivalid & ATTR_GID)
1193 arg->valid |= FATTR_GID, arg->gid = iattr->ia_gid;
1194 if (ivalid & ATTR_SIZE)
1195 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1196 if (ivalid & ATTR_ATIME) {
1197 arg->valid |= FATTR_ATIME;
1198 arg->atime = iattr->ia_atime.tv_sec;
1199 arg->atimensec = iattr->ia_atime.tv_nsec;
1200 if (!(ivalid & ATTR_ATIME_SET))
1201 arg->valid |= FATTR_ATIME_NOW;
1202 }
1203 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1204 arg->valid |= FATTR_MTIME;
1205 arg->mtime = iattr->ia_mtime.tv_sec;
1206 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1207 if (!(ivalid & ATTR_MTIME_SET))
1208 arg->valid |= FATTR_MTIME_NOW;
1209 }
1210}
1211
1212
1213
1214
1215
1216
1217
1218void fuse_set_nowrite(struct inode *inode)
1219{
1220 struct fuse_conn *fc = get_fuse_conn(inode);
1221 struct fuse_inode *fi = get_fuse_inode(inode);
1222
1223 BUG_ON(!mutex_is_locked(&inode->i_mutex));
1224
1225 spin_lock(&fc->lock);
1226 BUG_ON(fi->writectr < 0);
1227 fi->writectr += FUSE_NOWRITE;
1228 spin_unlock(&fc->lock);
1229 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1230}
1231
1232
1233
1234
1235
1236
1237
1238static void __fuse_release_nowrite(struct inode *inode)
1239{
1240 struct fuse_inode *fi = get_fuse_inode(inode);
1241
1242 BUG_ON(fi->writectr != FUSE_NOWRITE);
1243 fi->writectr = 0;
1244 fuse_flush_writepages(inode);
1245}
1246
1247void fuse_release_nowrite(struct inode *inode)
1248{
1249 struct fuse_conn *fc = get_fuse_conn(inode);
1250
1251 spin_lock(&fc->lock);
1252 __fuse_release_nowrite(inode);
1253 spin_unlock(&fc->lock);
1254}
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1265 struct file *file)
1266{
1267 struct inode *inode = entry->d_inode;
1268 struct fuse_conn *fc = get_fuse_conn(inode);
1269 struct fuse_req *req;
1270 struct fuse_setattr_in inarg;
1271 struct fuse_attr_out outarg;
1272 bool is_truncate = false;
1273 loff_t oldsize;
1274 int err;
1275
1276 if (!fuse_allow_task(fc, current))
1277 return -EACCES;
1278
1279 if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1280 attr->ia_valid |= ATTR_FORCE;
1281
1282 err = inode_change_ok(inode, attr);
1283 if (err)
1284 return err;
1285
1286 if (attr->ia_valid & ATTR_OPEN) {
1287 if (fc->atomic_o_trunc)
1288 return 0;
1289 file = NULL;
1290 }
1291
1292 if (attr->ia_valid & ATTR_SIZE)
1293 is_truncate = true;
1294
1295 req = fuse_get_req(fc);
1296 if (IS_ERR(req))
1297 return PTR_ERR(req);
1298
1299 if (is_truncate)
1300 fuse_set_nowrite(inode);
1301
1302 memset(&inarg, 0, sizeof(inarg));
1303 memset(&outarg, 0, sizeof(outarg));
1304 iattr_to_fattr(attr, &inarg);
1305 if (file) {
1306 struct fuse_file *ff = file->private_data;
1307 inarg.valid |= FATTR_FH;
1308 inarg.fh = ff->fh;
1309 }
1310 if (attr->ia_valid & ATTR_SIZE) {
1311
1312 inarg.valid |= FATTR_LOCKOWNER;
1313 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1314 }
1315 req->in.h.opcode = FUSE_SETATTR;
1316 req->in.h.nodeid = get_node_id(inode);
1317 req->in.numargs = 1;
1318 req->in.args[0].size = sizeof(inarg);
1319 req->in.args[0].value = &inarg;
1320 req->out.numargs = 1;
1321 if (fc->minor < 9)
1322 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1323 else
1324 req->out.args[0].size = sizeof(outarg);
1325 req->out.args[0].value = &outarg;
1326 fuse_request_send(fc, req);
1327 err = req->out.h.error;
1328 fuse_put_request(fc, req);
1329 if (err) {
1330 if (err == -EINTR)
1331 fuse_invalidate_attr(inode);
1332 goto error;
1333 }
1334
1335 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1336 make_bad_inode(inode);
1337 err = -EIO;
1338 goto error;
1339 }
1340
1341 spin_lock(&fc->lock);
1342 fuse_change_attributes_common(inode, &outarg.attr,
1343 attr_timeout(&outarg));
1344 oldsize = inode->i_size;
1345 i_size_write(inode, outarg.attr.size);
1346
1347 if (is_truncate) {
1348
1349 __fuse_release_nowrite(inode);
1350 }
1351 spin_unlock(&fc->lock);
1352
1353
1354
1355
1356
1357 if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1358 truncate_pagecache(inode, oldsize, outarg.attr.size);
1359 invalidate_inode_pages2(inode->i_mapping);
1360 }
1361
1362 return 0;
1363
1364error:
1365 if (is_truncate)
1366 fuse_release_nowrite(inode);
1367
1368 return err;
1369}
1370
1371static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1372{
1373 if (attr->ia_valid & ATTR_FILE)
1374 return fuse_do_setattr(entry, attr, attr->ia_file);
1375 else
1376 return fuse_do_setattr(entry, attr, NULL);
1377}
1378
1379static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1380 struct kstat *stat)
1381{
1382 struct inode *inode = entry->d_inode;
1383 struct fuse_conn *fc = get_fuse_conn(inode);
1384
1385 if (!fuse_allow_task(fc, current))
1386 return -EACCES;
1387
1388 return fuse_update_attributes(inode, stat, NULL, NULL);
1389}
1390
1391static int fuse_setxattr(struct dentry *entry, const char *name,
1392 const void *value, size_t size, int flags)
1393{
1394 struct inode *inode = entry->d_inode;
1395 struct fuse_conn *fc = get_fuse_conn(inode);
1396 struct fuse_req *req;
1397 struct fuse_setxattr_in inarg;
1398 int err;
1399
1400 if (fc->no_setxattr)
1401 return -EOPNOTSUPP;
1402
1403 req = fuse_get_req(fc);
1404 if (IS_ERR(req))
1405 return PTR_ERR(req);
1406
1407 memset(&inarg, 0, sizeof(inarg));
1408 inarg.size = size;
1409 inarg.flags = flags;
1410 req->in.h.opcode = FUSE_SETXATTR;
1411 req->in.h.nodeid = get_node_id(inode);
1412 req->in.numargs = 3;
1413 req->in.args[0].size = sizeof(inarg);
1414 req->in.args[0].value = &inarg;
1415 req->in.args[1].size = strlen(name) + 1;
1416 req->in.args[1].value = name;
1417 req->in.args[2].size = size;
1418 req->in.args[2].value = value;
1419 fuse_request_send(fc, req);
1420 err = req->out.h.error;
1421 fuse_put_request(fc, req);
1422 if (err == -ENOSYS) {
1423 fc->no_setxattr = 1;
1424 err = -EOPNOTSUPP;
1425 }
1426 return err;
1427}
1428
1429static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1430 void *value, size_t size)
1431{
1432 struct inode *inode = entry->d_inode;
1433 struct fuse_conn *fc = get_fuse_conn(inode);
1434 struct fuse_req *req;
1435 struct fuse_getxattr_in inarg;
1436 struct fuse_getxattr_out outarg;
1437 ssize_t ret;
1438
1439 if (fc->no_getxattr)
1440 return -EOPNOTSUPP;
1441
1442 req = fuse_get_req(fc);
1443 if (IS_ERR(req))
1444 return PTR_ERR(req);
1445
1446 memset(&inarg, 0, sizeof(inarg));
1447 inarg.size = size;
1448 req->in.h.opcode = FUSE_GETXATTR;
1449 req->in.h.nodeid = get_node_id(inode);
1450 req->in.numargs = 2;
1451 req->in.args[0].size = sizeof(inarg);
1452 req->in.args[0].value = &inarg;
1453 req->in.args[1].size = strlen(name) + 1;
1454 req->in.args[1].value = name;
1455
1456 req->out.numargs = 1;
1457 if (size) {
1458 req->out.argvar = 1;
1459 req->out.args[0].size = size;
1460 req->out.args[0].value = value;
1461 } else {
1462 req->out.args[0].size = sizeof(outarg);
1463 req->out.args[0].value = &outarg;
1464 }
1465 fuse_request_send(fc, req);
1466 ret = req->out.h.error;
1467 if (!ret)
1468 ret = size ? req->out.args[0].size : outarg.size;
1469 else {
1470 if (ret == -ENOSYS) {
1471 fc->no_getxattr = 1;
1472 ret = -EOPNOTSUPP;
1473 }
1474 }
1475 fuse_put_request(fc, req);
1476 return ret;
1477}
1478
1479static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1480{
1481 struct inode *inode = entry->d_inode;
1482 struct fuse_conn *fc = get_fuse_conn(inode);
1483 struct fuse_req *req;
1484 struct fuse_getxattr_in inarg;
1485 struct fuse_getxattr_out outarg;
1486 ssize_t ret;
1487
1488 if (!fuse_allow_task(fc, current))
1489 return -EACCES;
1490
1491 if (fc->no_listxattr)
1492 return -EOPNOTSUPP;
1493
1494 req = fuse_get_req(fc);
1495 if (IS_ERR(req))
1496 return PTR_ERR(req);
1497
1498 memset(&inarg, 0, sizeof(inarg));
1499 inarg.size = size;
1500 req->in.h.opcode = FUSE_LISTXATTR;
1501 req->in.h.nodeid = get_node_id(inode);
1502 req->in.numargs = 1;
1503 req->in.args[0].size = sizeof(inarg);
1504 req->in.args[0].value = &inarg;
1505
1506 req->out.numargs = 1;
1507 if (size) {
1508 req->out.argvar = 1;
1509 req->out.args[0].size = size;
1510 req->out.args[0].value = list;
1511 } else {
1512 req->out.args[0].size = sizeof(outarg);
1513 req->out.args[0].value = &outarg;
1514 }
1515 fuse_request_send(fc, req);
1516 ret = req->out.h.error;
1517 if (!ret)
1518 ret = size ? req->out.args[0].size : outarg.size;
1519 else {
1520 if (ret == -ENOSYS) {
1521 fc->no_listxattr = 1;
1522 ret = -EOPNOTSUPP;
1523 }
1524 }
1525 fuse_put_request(fc, req);
1526 return ret;
1527}
1528
1529static int fuse_removexattr(struct dentry *entry, const char *name)
1530{
1531 struct inode *inode = entry->d_inode;
1532 struct fuse_conn *fc = get_fuse_conn(inode);
1533 struct fuse_req *req;
1534 int err;
1535
1536 if (fc->no_removexattr)
1537 return -EOPNOTSUPP;
1538
1539 req = fuse_get_req(fc);
1540 if (IS_ERR(req))
1541 return PTR_ERR(req);
1542
1543 req->in.h.opcode = FUSE_REMOVEXATTR;
1544 req->in.h.nodeid = get_node_id(inode);
1545 req->in.numargs = 1;
1546 req->in.args[0].size = strlen(name) + 1;
1547 req->in.args[0].value = name;
1548 fuse_request_send(fc, req);
1549 err = req->out.h.error;
1550 fuse_put_request(fc, req);
1551 if (err == -ENOSYS) {
1552 fc->no_removexattr = 1;
1553 err = -EOPNOTSUPP;
1554 }
1555 return err;
1556}
1557
1558static const struct inode_operations fuse_dir_inode_operations = {
1559 .lookup = fuse_lookup,
1560 .mkdir = fuse_mkdir,
1561 .symlink = fuse_symlink,
1562 .unlink = fuse_unlink,
1563 .rmdir = fuse_rmdir,
1564 .rename = fuse_rename,
1565 .link = fuse_link,
1566 .setattr = fuse_setattr,
1567 .create = fuse_create,
1568 .mknod = fuse_mknod,
1569 .permission = fuse_permission,
1570 .getattr = fuse_getattr,
1571 .setxattr = fuse_setxattr,
1572 .getxattr = fuse_getxattr,
1573 .listxattr = fuse_listxattr,
1574 .removexattr = fuse_removexattr,
1575};
1576
1577static const struct file_operations fuse_dir_operations = {
1578 .llseek = generic_file_llseek,
1579 .read = generic_read_dir,
1580 .readdir = fuse_readdir,
1581 .open = fuse_dir_open,
1582 .release = fuse_dir_release,
1583 .fsync = fuse_dir_fsync,
1584};
1585
1586static const struct inode_operations fuse_common_inode_operations = {
1587 .setattr = fuse_setattr,
1588 .permission = fuse_permission,
1589 .getattr = fuse_getattr,
1590 .setxattr = fuse_setxattr,
1591 .getxattr = fuse_getxattr,
1592 .listxattr = fuse_listxattr,
1593 .removexattr = fuse_removexattr,
1594};
1595
1596static const struct inode_operations fuse_symlink_inode_operations = {
1597 .setattr = fuse_setattr,
1598 .follow_link = fuse_follow_link,
1599 .put_link = fuse_put_link,
1600 .readlink = generic_readlink,
1601 .getattr = fuse_getattr,
1602 .setxattr = fuse_setxattr,
1603 .getxattr = fuse_getxattr,
1604 .listxattr = fuse_listxattr,
1605 .removexattr = fuse_removexattr,
1606};
1607
1608void fuse_init_common(struct inode *inode)
1609{
1610 inode->i_op = &fuse_common_inode_operations;
1611}
1612
1613void fuse_init_dir(struct inode *inode)
1614{
1615 inode->i_op = &fuse_dir_inode_operations;
1616 inode->i_fop = &fuse_dir_operations;
1617}
1618
1619void fuse_init_symlink(struct inode *inode)
1620{
1621 inode->i_op = &fuse_symlink_inode_operations;
1622}
1623