projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] FUSE: bump interface minor version
[deliverable/linux.git] / fs / fuse / dir.c
CommitLineData
e5e5558e
MS		 1/*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2005 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
17static inline unsigned long time_to_jiffies(unsigned long sec,
18 unsigned long nsec)
19{
20 struct timespec ts = {sec, nsec};
21 return jiffies + timespec_to_jiffies(&ts);
22}
23
24static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
25 struct dentry *entry,
26 struct fuse_entry_out *outarg)
27{
28 req->in.h.opcode = FUSE_LOOKUP;
29 req->in.h.nodeid = get_node_id(dir);
30 req->inode = dir;
31 req->in.numargs = 1;
32 req->in.args[0].size = entry->d_name.len + 1;
33 req->in.args[0].value = entry->d_name.name;
34 req->out.numargs = 1;
35 req->out.args[0].size = sizeof(struct fuse_entry_out);
36 req->out.args[0].value = outarg;
37}
38
39static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
40{
41 if (!entry->d_inode || is_bad_inode(entry->d_inode))
42 return 0;
43 else if (time_after(jiffies, entry->d_time)) {
44 int err;
e5e5558e
MS		 45 struct fuse_entry_out outarg;
46 struct inode *inode = entry->d_inode;
47 struct fuse_inode *fi = get_fuse_inode(inode);
48 struct fuse_conn *fc = get_fuse_conn(inode);
7c352bdf 49 struct fuse_req *req = fuse_get_request(fc);
e5e5558e
MS		 50 if (!req)
51 return 0;
52
53 fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
7c352bdf 54 request_send(fc, req);
e5e5558e 55 err = req->out.h.error;
9e6268db
MS		 56 if (!err) {
57 if (outarg.nodeid != get_node_id(inode)) {
58 fuse_send_forget(fc, req, outarg.nodeid, 1);
59 return 0;
60 }
61 fi->nlookup ++;
62 }
e5e5558e 63 fuse_put_request(fc, req);
9e6268db 64 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
e5e5558e
MS		 65 return 0;
66
67 fuse_change_attributes(inode, &outarg.attr);
e5e5558e
MS		 68 entry->d_time = time_to_jiffies(outarg.entry_valid,
69 outarg.entry_valid_nsec);
70 fi->i_time = time_to_jiffies(outarg.attr_valid,
71 outarg.attr_valid_nsec);
72 }
73 return 1;
74}
75
76static struct dentry_operations fuse_dentry_operations = {
77 .d_revalidate = fuse_dentry_revalidate,
78};
79
80static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
81 struct inode **inodep)
82{
83 int err;
e5e5558e
MS		 84 struct fuse_entry_out outarg;
85 struct inode *inode = NULL;
86 struct fuse_conn *fc = get_fuse_conn(dir);
87 struct fuse_req *req;
88
89 if (entry->d_name.len > FUSE_NAME_MAX)
90 return -ENAMETOOLONG;
91
92 req = fuse_get_request(fc);
93 if (!req)
7c352bdf 94 return -EINTR;
e5e5558e
MS		 95
96 fuse_lookup_init(req, dir, entry, &outarg);
97 request_send(fc, req);
e5e5558e 98 err = req->out.h.error;
ee4e5271
MS		 99 if (!err && (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID))
100 err = -EIO;
e5e5558e
MS		 101 if (!err) {
102 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
9e6268db 103 &outarg.attr);
e5e5558e 104 if (!inode) {
9e6268db 105 fuse_send_forget(fc, req, outarg.nodeid, 1);
e5e5558e
MS		 106 return -ENOMEM;
107 }
108 }
109 fuse_put_request(fc, req);
110 if (err && err != -ENOENT)
111 return err;
112
113 if (inode) {
114 struct fuse_inode *fi = get_fuse_inode(inode);
115 entry->d_time = time_to_jiffies(outarg.entry_valid,
116 outarg.entry_valid_nsec);
117 fi->i_time = time_to_jiffies(outarg.attr_valid,
118 outarg.attr_valid_nsec);
119 }
120
121 entry->d_op = &fuse_dentry_operations;
122 *inodep = inode;
123 return 0;
124}
125
9e6268db
MS		 126void fuse_invalidate_attr(struct inode *inode)
127{
128 get_fuse_inode(inode)->i_time = jiffies - 1;
129}
130
131static void fuse_invalidate_entry(struct dentry *entry)
132{
133 d_invalidate(entry);
134 entry->d_time = jiffies - 1;
135}
136
137static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
138 struct inode *dir, struct dentry *entry,
139 int mode)
140{
141 struct fuse_entry_out outarg;
142 struct inode *inode;
143 struct fuse_inode *fi;
144 int err;
145
146 req->in.h.nodeid = get_node_id(dir);
147 req->inode = dir;
148 req->out.numargs = 1;
149 req->out.args[0].size = sizeof(outarg);
150 req->out.args[0].value = &outarg;
151 request_send(fc, req);
152 err = req->out.h.error;
153 if (err) {
154 fuse_put_request(fc, req);
155 return err;
156 }
ee4e5271
MS		 157 if (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID) {
158 fuse_put_request(fc, req);
159 return -EIO;
160 }
9e6268db
MS		 161 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
162 &outarg.attr);
163 if (!inode) {
164 fuse_send_forget(fc, req, outarg.nodeid, 1);
165 return -ENOMEM;
166 }
167 fuse_put_request(fc, req);
168
169 /* Don't allow userspace to do really stupid things... */
170 if ((inode->i_mode ^ mode) & S_IFMT) {
171 iput(inode);
172 return -EIO;
173 }
174
175 entry->d_time = time_to_jiffies(outarg.entry_valid,
176 outarg.entry_valid_nsec);
177
178 fi = get_fuse_inode(inode);
179 fi->i_time = time_to_jiffies(outarg.attr_valid,
180 outarg.attr_valid_nsec);
181
182 d_instantiate(entry, inode);
183 fuse_invalidate_attr(dir);
184 return 0;
185}
186
187static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
188 dev_t rdev)
189{
190 struct fuse_mknod_in inarg;
191 struct fuse_conn *fc = get_fuse_conn(dir);
192 struct fuse_req *req = fuse_get_request(fc);
193 if (!req)
7c352bdf 194 return -EINTR;
9e6268db
MS		 195
196 memset(&inarg, 0, sizeof(inarg));
197 inarg.mode = mode;
198 inarg.rdev = new_encode_dev(rdev);
199 req->in.h.opcode = FUSE_MKNOD;
200 req->in.numargs = 2;
201 req->in.args[0].size = sizeof(inarg);
202 req->in.args[0].value = &inarg;
203 req->in.args[1].size = entry->d_name.len + 1;
204 req->in.args[1].value = entry->d_name.name;
205 return create_new_entry(fc, req, dir, entry, mode);
206}
207
208static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
209 struct nameidata *nd)
210{
211 return fuse_mknod(dir, entry, mode, 0);
212}
213
214static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
215{
216 struct fuse_mkdir_in inarg;
217 struct fuse_conn *fc = get_fuse_conn(dir);
218 struct fuse_req *req = fuse_get_request(fc);
219 if (!req)
7c352bdf 220 return -EINTR;
9e6268db
MS		 221
222 memset(&inarg, 0, sizeof(inarg));
223 inarg.mode = mode;
224 req->in.h.opcode = FUSE_MKDIR;
225 req->in.numargs = 2;
226 req->in.args[0].size = sizeof(inarg);
227 req->in.args[0].value = &inarg;
228 req->in.args[1].size = entry->d_name.len + 1;
229 req->in.args[1].value = entry->d_name.name;
230 return create_new_entry(fc, req, dir, entry, S_IFDIR);
231}
232
233static int fuse_symlink(struct inode *dir, struct dentry *entry,
234 const char *link)
235{
236 struct fuse_conn *fc = get_fuse_conn(dir);
237 unsigned len = strlen(link) + 1;
238 struct fuse_req *req;
239
240 if (len > FUSE_SYMLINK_MAX)
241 return -ENAMETOOLONG;
242
243 req = fuse_get_request(fc);
244 if (!req)
7c352bdf 245 return -EINTR;
9e6268db
MS		 246
247 req->in.h.opcode = FUSE_SYMLINK;
248 req->in.numargs = 2;
249 req->in.args[0].size = entry->d_name.len + 1;
250 req->in.args[0].value = entry->d_name.name;
251 req->in.args[1].size = len;
252 req->in.args[1].value = link;
253 return create_new_entry(fc, req, dir, entry, S_IFLNK);
254}
255
256static int fuse_unlink(struct inode *dir, struct dentry *entry)
257{
258 int err;
259 struct fuse_conn *fc = get_fuse_conn(dir);
260 struct fuse_req *req = fuse_get_request(fc);
261 if (!req)
7c352bdf 262 return -EINTR;
9e6268db
MS		 263
264 req->in.h.opcode = FUSE_UNLINK;
265 req->in.h.nodeid = get_node_id(dir);
266 req->inode = dir;
267 req->in.numargs = 1;
268 req->in.args[0].size = entry->d_name.len + 1;
269 req->in.args[0].value = entry->d_name.name;
270 request_send(fc, req);
271 err = req->out.h.error;
272 fuse_put_request(fc, req);
273 if (!err) {
274 struct inode *inode = entry->d_inode;
275
276 /* Set nlink to zero so the inode can be cleared, if
277 the inode does have more links this will be
278 discovered at the next lookup/getattr */
279 inode->i_nlink = 0;
280 fuse_invalidate_attr(inode);
281 fuse_invalidate_attr(dir);
282 } else if (err == -EINTR)
283 fuse_invalidate_entry(entry);
284 return err;
285}
286
287static int fuse_rmdir(struct inode *dir, struct dentry *entry)
288{
289 int err;
290 struct fuse_conn *fc = get_fuse_conn(dir);
291 struct fuse_req *req = fuse_get_request(fc);
292 if (!req)
7c352bdf 293 return -EINTR;
9e6268db
MS		 294
295 req->in.h.opcode = FUSE_RMDIR;
296 req->in.h.nodeid = get_node_id(dir);
297 req->inode = dir;
298 req->in.numargs = 1;
299 req->in.args[0].size = entry->d_name.len + 1;
300 req->in.args[0].value = entry->d_name.name;
301 request_send(fc, req);
302 err = req->out.h.error;
303 fuse_put_request(fc, req);
304 if (!err) {
305 entry->d_inode->i_nlink = 0;
306 fuse_invalidate_attr(dir);
307 } else if (err == -EINTR)
308 fuse_invalidate_entry(entry);
309 return err;
310}
311
312static int fuse_rename(struct inode *olddir, struct dentry *oldent,
313 struct inode *newdir, struct dentry *newent)
314{
315 int err;
316 struct fuse_rename_in inarg;
317 struct fuse_conn *fc = get_fuse_conn(olddir);
318 struct fuse_req *req = fuse_get_request(fc);
319 if (!req)
7c352bdf 320 return -EINTR;
9e6268db
MS		 321
322 memset(&inarg, 0, sizeof(inarg));
323 inarg.newdir = get_node_id(newdir);
324 req->in.h.opcode = FUSE_RENAME;
325 req->in.h.nodeid = get_node_id(olddir);
326 req->inode = olddir;
327 req->inode2 = newdir;
328 req->in.numargs = 3;
329 req->in.args[0].size = sizeof(inarg);
330 req->in.args[0].value = &inarg;
331 req->in.args[1].size = oldent->d_name.len + 1;
332 req->in.args[1].value = oldent->d_name.name;
333 req->in.args[2].size = newent->d_name.len + 1;
334 req->in.args[2].value = newent->d_name.name;
335 request_send(fc, req);
336 err = req->out.h.error;
337 fuse_put_request(fc, req);
338 if (!err) {
339 fuse_invalidate_attr(olddir);
340 if (olddir != newdir)
341 fuse_invalidate_attr(newdir);
342 } else if (err == -EINTR) {
343 /* If request was interrupted, DEITY only knows if the
344 rename actually took place. If the invalidation
345 fails (e.g. some process has CWD under the renamed
346 directory), then there can be inconsistency between
347 the dcache and the real filesystem. Tough luck. */
348 fuse_invalidate_entry(oldent);
349 if (newent->d_inode)
350 fuse_invalidate_entry(newent);
351 }
352
353 return err;
354}
355
356static int fuse_link(struct dentry *entry, struct inode *newdir,
357 struct dentry *newent)
358{
359 int err;
360 struct fuse_link_in inarg;
361 struct inode *inode = entry->d_inode;
362 struct fuse_conn *fc = get_fuse_conn(inode);
363 struct fuse_req *req = fuse_get_request(fc);
364 if (!req)
7c352bdf 365 return -EINTR;
9e6268db
MS		 366
367 memset(&inarg, 0, sizeof(inarg));
368 inarg.oldnodeid = get_node_id(inode);
369 req->in.h.opcode = FUSE_LINK;
370 req->inode2 = inode;
371 req->in.numargs = 2;
372 req->in.args[0].size = sizeof(inarg);
373 req->in.args[0].value = &inarg;
374 req->in.args[1].size = newent->d_name.len + 1;
375 req->in.args[1].value = newent->d_name.name;
376 err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
377 /* Contrary to "normal" filesystems it can happen that link
378 makes two "logical" inodes point to the same "physical"
379 inode. We invalidate the attributes of the old one, so it
380 will reflect changes in the backing inode (link count,
381 etc.)
382 */
383 if (!err || err == -EINTR)
384 fuse_invalidate_attr(inode);
385 return err;
386}
387
e5e5558e
MS		 388int fuse_do_getattr(struct inode *inode)
389{
390 int err;
391 struct fuse_attr_out arg;
392 struct fuse_conn *fc = get_fuse_conn(inode);
393 struct fuse_req *req = fuse_get_request(fc);
394 if (!req)
7c352bdf 395 return -EINTR;
e5e5558e
MS		 396
397 req->in.h.opcode = FUSE_GETATTR;
398 req->in.h.nodeid = get_node_id(inode);
399 req->inode = inode;
400 req->out.numargs = 1;
401 req->out.args[0].size = sizeof(arg);
402 req->out.args[0].value = &arg;
403 request_send(fc, req);
404 err = req->out.h.error;
405 fuse_put_request(fc, req);
406 if (!err) {
407 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
408 make_bad_inode(inode);
409 err = -EIO;
410 } else {
411 struct fuse_inode *fi = get_fuse_inode(inode);
412 fuse_change_attributes(inode, &arg.attr);
413 fi->i_time = time_to_jiffies(arg.attr_valid,
414 arg.attr_valid_nsec);
415 }
416 }
417 return err;
418}
419
87729a55
MS		 420/*
421 * Calling into a user-controlled filesystem gives the filesystem
422 * daemon ptrace-like capabilities over the requester process. This
423 * means, that the filesystem daemon is able to record the exact
424 * filesystem operations performed, and can also control the behavior
425 * of the requester process in otherwise impossible ways. For example
426 * it can delay the operation for arbitrary length of time allowing
427 * DoS against the requester.
428 *
429 * For this reason only those processes can call into the filesystem,
430 * for which the owner of the mount has ptrace privilege. This
431 * excludes processes started by other users, suid or sgid processes.
432 */
433static int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
434{
435 if (fc->flags & FUSE_ALLOW_OTHER)
436 return 1;
437
438 if (task->euid == fc->user_id &&
439 task->suid == fc->user_id &&
440 task->uid == fc->user_id &&
441 task->egid == fc->group_id &&
442 task->sgid == fc->group_id &&
443 task->gid == fc->group_id)
444 return 1;
445
446 return 0;
447}
448
e5e5558e
MS		 449static int fuse_revalidate(struct dentry *entry)
450{
451 struct inode *inode = entry->d_inode;
452 struct fuse_inode *fi = get_fuse_inode(inode);
453 struct fuse_conn *fc = get_fuse_conn(inode);
454
87729a55
MS		 455 if (!fuse_allow_task(fc, current))
456 return -EACCES;
457 if (get_node_id(inode) != FUSE_ROOT_ID &&
458 time_before_eq(jiffies, fi->i_time))
e5e5558e
MS		 459 return 0;
460
461 return fuse_do_getattr(inode);
462}
463
464static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
465{
466 struct fuse_conn *fc = get_fuse_conn(inode);
467
87729a55 468 if (!fuse_allow_task(fc, current))
e5e5558e 469 return -EACCES;
1e9a4ed9
MS		 470 else if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
471 int err = generic_permission(inode, mask, NULL);
472
473 /* If permission is denied, try to refresh file
474 attributes. This is also needed, because the root
475 node will at first have no permissions */
476 if (err == -EACCES) {
477 err = fuse_do_getattr(inode);
478 if (!err)
479 err = generic_permission(inode, mask, NULL);
480 }
481
482 /* FIXME: Need some mechanism to revoke permissions:
483 currently if the filesystem suddenly changes the
484 file mode, we will not be informed about it, and
485 continue to allow access to the file/directory.
486
487 This is actually not so grave, since the user can
488 simply keep access to the file/directory anyway by
489 keeping it open... */
490
491 return err;
492 } else {
e5e5558e 493 int mode = inode->i_mode;
e5e5558e
MS		 494 if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
495 return -EACCES;
496 return 0;
497 }
498}
499
500static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
501 void *dstbuf, filldir_t filldir)
502{
503 while (nbytes >= FUSE_NAME_OFFSET) {
504 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
505 size_t reclen = FUSE_DIRENT_SIZE(dirent);
506 int over;
507 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
508 return -EIO;
509 if (reclen > nbytes)
510 break;
511
512 over = filldir(dstbuf, dirent->name, dirent->namelen,
513 file->f_pos, dirent->ino, dirent->type);
514 if (over)
515 break;
516
517 buf += reclen;
518 nbytes -= reclen;
519 file->f_pos = dirent->off;
520 }
521
522 return 0;
523}
524
04730fef
MS		 525static inline size_t fuse_send_readdir(struct fuse_req *req, struct file *file,
526 struct inode *inode, loff_t pos,
527 size_t count)
e5e5558e 528{
04730fef 529 return fuse_send_read_common(req, file, inode, pos, count, 1);
e5e5558e
MS		 530}
531
04730fef 532static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
e5e5558e 533{
04730fef
MS		 534 int err;
535 size_t nbytes;
536 struct page *page;
e5e5558e
MS		 537 struct inode *inode = file->f_dentry->d_inode;
538 struct fuse_conn *fc = get_fuse_conn(inode);
7c352bdf 539 struct fuse_req *req = fuse_get_request(fc);
e5e5558e 540 if (!req)
04730fef 541 return -EINTR;
e5e5558e 542
04730fef
MS		 543 page = alloc_page(GFP_KERNEL);
544 if (!page) {
545 fuse_put_request(fc, req);
546 return -ENOMEM;
547 }
548 req->num_pages = 1;
549 req->pages[0] = page;
550 nbytes = fuse_send_readdir(req, file, inode, file->f_pos, PAGE_SIZE);
e5e5558e
MS		 551 err = req->out.h.error;
552 fuse_put_request(fc, req);
553 if (!err)
04730fef
MS		 554 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
555 filldir);
e5e5558e 556
04730fef 557 __free_page(page);
b36c31ba 558 fuse_invalidate_attr(inode); /* atime changed */
04730fef 559 return err;
e5e5558e
MS		 560}
561
562static char *read_link(struct dentry *dentry)
563{
564 struct inode *inode = dentry->d_inode;
565 struct fuse_conn *fc = get_fuse_conn(inode);
566 struct fuse_req *req = fuse_get_request(fc);
567 char *link;
568
569 if (!req)
7c352bdf 570 return ERR_PTR(-EINTR);
e5e5558e
MS		 571
572 link = (char *) __get_free_page(GFP_KERNEL);
573 if (!link) {
574 link = ERR_PTR(-ENOMEM);
575 goto out;
576 }
577 req->in.h.opcode = FUSE_READLINK;
578 req->in.h.nodeid = get_node_id(inode);
579 req->inode = inode;
580 req->out.argvar = 1;
581 req->out.numargs = 1;
582 req->out.args[0].size = PAGE_SIZE - 1;
583 req->out.args[0].value = link;
584 request_send(fc, req);
585 if (req->out.h.error) {
586 free_page((unsigned long) link);
587 link = ERR_PTR(req->out.h.error);
588 } else
589 link[req->out.args[0].size] = '\0';
590 out:
591 fuse_put_request(fc, req);
b36c31ba 592 fuse_invalidate_attr(inode); /* atime changed */
e5e5558e
MS		 593 return link;
594}
595
596static void free_link(char *link)
597{
598 if (!IS_ERR(link))
599 free_page((unsigned long) link);
600}
601
602static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
603{
604 nd_set_link(nd, read_link(dentry));
605 return NULL;
606}
607
608static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
609{
610 free_link(nd_get_link(nd));
611}
612
613static int fuse_dir_open(struct inode *inode, struct file *file)
614{
04730fef 615 return fuse_open_common(inode, file, 1);
e5e5558e
MS		 616}
617
618static int fuse_dir_release(struct inode *inode, struct file *file)
619{
04730fef 620 return fuse_release_common(inode, file, 1);
e5e5558e
MS		 621}
622
82547981
MS		 623static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
624{
625 /* nfsd can call this with no file */
626 return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
627}
628
9e6268db
MS		 629static unsigned iattr_to_fattr(struct iattr *iattr, struct fuse_attr *fattr)
630{
631 unsigned ivalid = iattr->ia_valid;
632 unsigned fvalid = 0;
633
634 memset(fattr, 0, sizeof(*fattr));
635
636 if (ivalid & ATTR_MODE)
637 fvalid |= FATTR_MODE, fattr->mode = iattr->ia_mode;
638 if (ivalid & ATTR_UID)
639 fvalid |= FATTR_UID, fattr->uid = iattr->ia_uid;
640 if (ivalid & ATTR_GID)
641 fvalid |= FATTR_GID, fattr->gid = iattr->ia_gid;
642 if (ivalid & ATTR_SIZE)
643 fvalid |= FATTR_SIZE, fattr->size = iattr->ia_size;
644 /* You can only _set_ these together (they may change by themselves) */
645 if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
646 fvalid |= FATTR_ATIME | FATTR_MTIME;
647 fattr->atime = iattr->ia_atime.tv_sec;
648 fattr->mtime = iattr->ia_mtime.tv_sec;
649 }
650
651 return fvalid;
652}
653
654static int fuse_setattr(struct dentry *entry, struct iattr *attr)
655{
656 struct inode *inode = entry->d_inode;
657 struct fuse_conn *fc = get_fuse_conn(inode);
658 struct fuse_inode *fi = get_fuse_inode(inode);
659 struct fuse_req *req;
660 struct fuse_setattr_in inarg;
661 struct fuse_attr_out outarg;
662 int err;
663 int is_truncate = 0;
664
1e9a4ed9
MS		 665 if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
666 err = inode_change_ok(inode, attr);
667 if (err)
668 return err;
669 }
670
9e6268db
MS		 671 if (attr->ia_valid & ATTR_SIZE) {
672 unsigned long limit;
673 is_truncate = 1;
674 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
675 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
676 send_sig(SIGXFSZ, current, 0);
677 return -EFBIG;
678 }
679 }
680
681 req = fuse_get_request(fc);
682 if (!req)
7c352bdf 683 return -EINTR;
9e6268db
MS		 684
685 memset(&inarg, 0, sizeof(inarg));
686 inarg.valid = iattr_to_fattr(attr, &inarg.attr);
687 req->in.h.opcode = FUSE_SETATTR;
688 req->in.h.nodeid = get_node_id(inode);
689 req->inode = inode;
690 req->in.numargs = 1;
691 req->in.args[0].size = sizeof(inarg);
692 req->in.args[0].value = &inarg;
693 req->out.numargs = 1;
694 req->out.args[0].size = sizeof(outarg);
695 req->out.args[0].value = &outarg;
696 request_send(fc, req);
697 err = req->out.h.error;
698 fuse_put_request(fc, req);
699 if (!err) {
700 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
701 make_bad_inode(inode);
702 err = -EIO;
703 } else {
704 if (is_truncate) {
705 loff_t origsize = i_size_read(inode);
706 i_size_write(inode, outarg.attr.size);
707 if (origsize > outarg.attr.size)
708 vmtruncate(inode, outarg.attr.size);
709 }
710 fuse_change_attributes(inode, &outarg.attr);
711 fi->i_time = time_to_jiffies(outarg.attr_valid,
712 outarg.attr_valid_nsec);
713 }
714 } else if (err == -EINTR)
715 fuse_invalidate_attr(inode);
716
717 return err;
718}
719
e5e5558e
MS		 720static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
721 struct kstat *stat)
722{
723 struct inode *inode = entry->d_inode;
724 int err = fuse_revalidate(entry);
725 if (!err)
726 generic_fillattr(inode, stat);
727
728 return err;
729}
730
731static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
732 struct nameidata *nd)
733{
734 struct inode *inode;
735 int err = fuse_lookup_iget(dir, entry, &inode);
736 if (err)
737 return ERR_PTR(err);
738 if (inode && S_ISDIR(inode->i_mode)) {
739 /* Don't allow creating an alias to a directory */
740 struct dentry *alias = d_find_alias(inode);
f12ec440 741 if (alias) {
e5e5558e
MS		 742 dput(alias);
743 iput(inode);
744 return ERR_PTR(-EIO);
745 }
746 }
f12ec440
MS		 747 d_add(entry, inode);
748 return NULL;
e5e5558e
MS		 749}
750
92a8780e
MS		 751static int fuse_setxattr(struct dentry *entry, const char *name,
752 const void *value, size_t size, int flags)
753{
754 struct inode *inode = entry->d_inode;
755 struct fuse_conn *fc = get_fuse_conn(inode);
756 struct fuse_req *req;
757 struct fuse_setxattr_in inarg;
758 int err;
759
760 if (size > FUSE_XATTR_SIZE_MAX)
761 return -E2BIG;
762
763 if (fc->no_setxattr)
764 return -EOPNOTSUPP;
765
766 req = fuse_get_request(fc);
767 if (!req)
7c352bdf 768 return -EINTR;
92a8780e
MS		 769
770 memset(&inarg, 0, sizeof(inarg));
771 inarg.size = size;
772 inarg.flags = flags;
773 req->in.h.opcode = FUSE_SETXATTR;
774 req->in.h.nodeid = get_node_id(inode);
775 req->inode = inode;
776 req->in.numargs = 3;
777 req->in.args[0].size = sizeof(inarg);
778 req->in.args[0].value = &inarg;
779 req->in.args[1].size = strlen(name) + 1;
780 req->in.args[1].value = name;
781 req->in.args[2].size = size;
782 req->in.args[2].value = value;
783 request_send(fc, req);
784 err = req->out.h.error;
785 fuse_put_request(fc, req);
786 if (err == -ENOSYS) {
787 fc->no_setxattr = 1;
788 err = -EOPNOTSUPP;
789 }
790 return err;
791}
792
793static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
794 void *value, size_t size)
795{
796 struct inode *inode = entry->d_inode;
797 struct fuse_conn *fc = get_fuse_conn(inode);
798 struct fuse_req *req;
799 struct fuse_getxattr_in inarg;
800 struct fuse_getxattr_out outarg;
801 ssize_t ret;
802
803 if (fc->no_getxattr)
804 return -EOPNOTSUPP;
805
806 req = fuse_get_request(fc);
807 if (!req)
7c352bdf 808 return -EINTR;
92a8780e
MS		 809
810 memset(&inarg, 0, sizeof(inarg));
811 inarg.size = size;
812 req->in.h.opcode = FUSE_GETXATTR;
813 req->in.h.nodeid = get_node_id(inode);
814 req->inode = inode;
815 req->in.numargs = 2;
816 req->in.args[0].size = sizeof(inarg);
817 req->in.args[0].value = &inarg;
818 req->in.args[1].size = strlen(name) + 1;
819 req->in.args[1].value = name;
820 /* This is really two different operations rolled into one */
821 req->out.numargs = 1;
822 if (size) {
823 req->out.argvar = 1;
824 req->out.args[0].size = size;
825 req->out.args[0].value = value;
826 } else {
827 req->out.args[0].size = sizeof(outarg);
828 req->out.args[0].value = &outarg;
829 }
830 request_send(fc, req);
831 ret = req->out.h.error;
832 if (!ret)
833 ret = size ? req->out.args[0].size : outarg.size;
834 else {
835 if (ret == -ENOSYS) {
836 fc->no_getxattr = 1;
837 ret = -EOPNOTSUPP;
838 }
839 }
840 fuse_put_request(fc, req);
841 return ret;
842}
843
844static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
845{
846 struct inode *inode = entry->d_inode;
847 struct fuse_conn *fc = get_fuse_conn(inode);
848 struct fuse_req *req;
849 struct fuse_getxattr_in inarg;
850 struct fuse_getxattr_out outarg;
851 ssize_t ret;
852
853 if (fc->no_listxattr)
854 return -EOPNOTSUPP;
855
856 req = fuse_get_request(fc);
857 if (!req)
7c352bdf 858 return -EINTR;
92a8780e
MS		 859
860 memset(&inarg, 0, sizeof(inarg));
861 inarg.size = size;
862 req->in.h.opcode = FUSE_LISTXATTR;
863 req->in.h.nodeid = get_node_id(inode);
864 req->inode = inode;
865 req->in.numargs = 1;
866 req->in.args[0].size = sizeof(inarg);
867 req->in.args[0].value = &inarg;
868 /* This is really two different operations rolled into one */
869 req->out.numargs = 1;
870 if (size) {
871 req->out.argvar = 1;
872 req->out.args[0].size = size;
873 req->out.args[0].value = list;
874 } else {
875 req->out.args[0].size = sizeof(outarg);
876 req->out.args[0].value = &outarg;
877 }
878 request_send(fc, req);
879 ret = req->out.h.error;
880 if (!ret)
881 ret = size ? req->out.args[0].size : outarg.size;
882 else {
883 if (ret == -ENOSYS) {
884 fc->no_listxattr = 1;
885 ret = -EOPNOTSUPP;
886 }
887 }
888 fuse_put_request(fc, req);
889 return ret;
890}
891
892static int fuse_removexattr(struct dentry *entry, const char *name)
893{
894 struct inode *inode = entry->d_inode;
895 struct fuse_conn *fc = get_fuse_conn(inode);
896 struct fuse_req *req;
897 int err;
898
899 if (fc->no_removexattr)
900 return -EOPNOTSUPP;
901
902 req = fuse_get_request(fc);
903 if (!req)
7c352bdf 904 return -EINTR;
92a8780e
MS		 905
906 req->in.h.opcode = FUSE_REMOVEXATTR;
907 req->in.h.nodeid = get_node_id(inode);
908 req->inode = inode;
909 req->in.numargs = 1;
910 req->in.args[0].size = strlen(name) + 1;
911 req->in.args[0].value = name;
912 request_send(fc, req);
913 err = req->out.h.error;
914 fuse_put_request(fc, req);
915 if (err == -ENOSYS) {
916 fc->no_removexattr = 1;
917 err = -EOPNOTSUPP;
918 }
919 return err;
920}
921
e5e5558e
MS		 922static struct inode_operations fuse_dir_inode_operations = {
923 .lookup = fuse_lookup,
9e6268db
MS		 924 .mkdir = fuse_mkdir,
925 .symlink = fuse_symlink,
926 .unlink = fuse_unlink,
927 .rmdir = fuse_rmdir,
928 .rename = fuse_rename,
929 .link = fuse_link,
930 .setattr = fuse_setattr,
931 .create = fuse_create,
932 .mknod = fuse_mknod,
e5e5558e
MS		 933 .permission = fuse_permission,
934 .getattr = fuse_getattr,
92a8780e
MS		 935 .setxattr = fuse_setxattr,
936 .getxattr = fuse_getxattr,
937 .listxattr = fuse_listxattr,
938 .removexattr = fuse_removexattr,
e5e5558e
MS		 939};
940
941static struct file_operations fuse_dir_operations = {
b6aeaded 942 .llseek = generic_file_llseek,
e5e5558e
MS		 943 .read = generic_read_dir,
944 .readdir = fuse_readdir,
945 .open = fuse_dir_open,
946 .release = fuse_dir_release,
82547981 947 .fsync = fuse_dir_fsync,
e5e5558e
MS		 948};
949
950static struct inode_operations fuse_common_inode_operations = {
9e6268db 951 .setattr = fuse_setattr,
e5e5558e
MS		 952 .permission = fuse_permission,
953 .getattr = fuse_getattr,
92a8780e
MS		 954 .setxattr = fuse_setxattr,
955 .getxattr = fuse_getxattr,
956 .listxattr = fuse_listxattr,
957 .removexattr = fuse_removexattr,
e5e5558e
MS		 958};
959
960static struct inode_operations fuse_symlink_inode_operations = {
9e6268db 961 .setattr = fuse_setattr,
e5e5558e
MS		 962 .follow_link = fuse_follow_link,
963 .put_link = fuse_put_link,
964 .readlink = generic_readlink,
965 .getattr = fuse_getattr,
92a8780e
MS		 966 .setxattr = fuse_setxattr,
967 .getxattr = fuse_getxattr,
968 .listxattr = fuse_listxattr,
969 .removexattr = fuse_removexattr,
e5e5558e
MS		 970};
971
972void fuse_init_common(struct inode *inode)
973{
974 inode->i_op = &fuse_common_inode_operations;
975}
976
977void fuse_init_dir(struct inode *inode)
978{
979 inode->i_op = &fuse_dir_inode_operations;
980 inode->i_fop = &fuse_dir_operations;
981}
982
983void fuse_init_symlink(struct inode *inode)
984{
985 inode->i_op = &fuse_symlink_inode_operations;
986}
Linux kernel - Deliverables
This page took 0.080904 seconds and 5 git commands to generate.