xref: /openbmc/linux/fs/fuse/dir.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2   FUSE: Filesystem in Userspace
3   Copyright (C) 2001-2006  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_timeout(struct dentry *entry, struct fuse_entry_out *o)
67 {
68 	fuse_dentry_settime(entry,
69 		time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
70 	if (entry->d_inode)
71 		get_fuse_inode(entry->d_inode)->i_time =
72 			time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
73 }
74 
75 /*
76  * Mark the attributes as stale, so that at the next call to
77  * ->getattr() they will be fetched from userspace
78  */
79 void fuse_invalidate_attr(struct inode *inode)
80 {
81 	get_fuse_inode(inode)->i_time = 0;
82 }
83 
84 /*
85  * Just mark the entry as stale, so that a next attempt to look it up
86  * will result in a new lookup call to userspace
87  *
88  * This is called when a dentry is about to become negative and the
89  * timeout is unknown (unlink, rmdir, rename and in some cases
90  * lookup)
91  */
92 static void fuse_invalidate_entry_cache(struct dentry *entry)
93 {
94 	fuse_dentry_settime(entry, 0);
95 }
96 
97 /*
98  * Same as fuse_invalidate_entry_cache(), but also try to remove the
99  * dentry from the hash
100  */
101 static void fuse_invalidate_entry(struct dentry *entry)
102 {
103 	d_invalidate(entry);
104 	fuse_invalidate_entry_cache(entry);
105 }
106 
107 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
108 			     struct dentry *entry,
109 			     struct fuse_entry_out *outarg)
110 {
111 	req->in.h.opcode = FUSE_LOOKUP;
112 	req->in.h.nodeid = get_node_id(dir);
113 	req->in.numargs = 1;
114 	req->in.args[0].size = entry->d_name.len + 1;
115 	req->in.args[0].value = entry->d_name.name;
116 	req->out.numargs = 1;
117 	req->out.args[0].size = sizeof(struct fuse_entry_out);
118 	req->out.args[0].value = outarg;
119 }
120 
121 /*
122  * Check whether the dentry is still valid
123  *
124  * If the entry validity timeout has expired and the dentry is
125  * positive, try to redo the lookup.  If the lookup results in a
126  * different inode, then let the VFS invalidate the dentry and redo
127  * the lookup once more.  If the lookup results in the same inode,
128  * then refresh the attributes, timeouts and mark the dentry valid.
129  */
130 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
131 {
132 	struct inode *inode = entry->d_inode;
133 
134 	if (inode && is_bad_inode(inode))
135 		return 0;
136 	else if (fuse_dentry_time(entry) < get_jiffies_64()) {
137 		int err;
138 		struct fuse_entry_out outarg;
139 		struct fuse_conn *fc;
140 		struct fuse_req *req;
141 		struct fuse_req *forget_req;
142 		struct dentry *parent;
143 
144 		/* For negative dentries, always do a fresh lookup */
145 		if (!inode)
146 			return 0;
147 
148 		fc = get_fuse_conn(inode);
149 		req = fuse_get_req(fc);
150 		if (IS_ERR(req))
151 			return 0;
152 
153 		forget_req = fuse_get_req(fc);
154 		if (IS_ERR(forget_req)) {
155 			fuse_put_request(fc, req);
156 			return 0;
157 		}
158 
159 		parent = dget_parent(entry);
160 		fuse_lookup_init(req, parent->d_inode, entry, &outarg);
161 		request_send(fc, req);
162 		dput(parent);
163 		err = req->out.h.error;
164 		fuse_put_request(fc, req);
165 		/* Zero nodeid is same as -ENOENT */
166 		if (!err && !outarg.nodeid)
167 			err = -ENOENT;
168 		if (!err) {
169 			struct fuse_inode *fi = get_fuse_inode(inode);
170 			if (outarg.nodeid != get_node_id(inode)) {
171 				fuse_send_forget(fc, forget_req,
172 						 outarg.nodeid, 1);
173 				return 0;
174 			}
175 			spin_lock(&fc->lock);
176 			fi->nlookup ++;
177 			spin_unlock(&fc->lock);
178 		}
179 		fuse_put_request(fc, forget_req);
180 		if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
181 			return 0;
182 
183 		fuse_change_attributes(inode, &outarg.attr);
184 		fuse_change_timeout(entry, &outarg);
185 	}
186 	return 1;
187 }
188 
189 static int invalid_nodeid(u64 nodeid)
190 {
191 	return !nodeid || nodeid == FUSE_ROOT_ID;
192 }
193 
194 static struct dentry_operations fuse_dentry_operations = {
195 	.d_revalidate	= fuse_dentry_revalidate,
196 };
197 
198 int fuse_valid_type(int m)
199 {
200 	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
201 		S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
202 }
203 
204 /*
205  * Add a directory inode to a dentry, ensuring that no other dentry
206  * refers to this inode.  Called with fc->inst_mutex.
207  */
208 static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
209 {
210 	struct dentry *alias = d_find_alias(inode);
211 	if (alias) {
212 		/* This tries to shrink the subtree below alias */
213 		fuse_invalidate_entry(alias);
214 		dput(alias);
215 		if (!list_empty(&inode->i_dentry))
216 			return -EBUSY;
217 	}
218 	d_add(entry, inode);
219 	return 0;
220 }
221 
222 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
223 				  struct nameidata *nd)
224 {
225 	int err;
226 	struct fuse_entry_out outarg;
227 	struct inode *inode = NULL;
228 	struct fuse_conn *fc = get_fuse_conn(dir);
229 	struct fuse_req *req;
230 	struct fuse_req *forget_req;
231 
232 	if (entry->d_name.len > FUSE_NAME_MAX)
233 		return ERR_PTR(-ENAMETOOLONG);
234 
235 	req = fuse_get_req(fc);
236 	if (IS_ERR(req))
237 		return ERR_PTR(PTR_ERR(req));
238 
239 	forget_req = fuse_get_req(fc);
240 	if (IS_ERR(forget_req)) {
241 		fuse_put_request(fc, req);
242 		return ERR_PTR(PTR_ERR(forget_req));
243 	}
244 
245 	fuse_lookup_init(req, dir, entry, &outarg);
246 	request_send(fc, req);
247 	err = req->out.h.error;
248 	fuse_put_request(fc, req);
249 	/* Zero nodeid is same as -ENOENT, but with valid timeout */
250 	if (!err && outarg.nodeid &&
251 	    (invalid_nodeid(outarg.nodeid) ||
252 	     !fuse_valid_type(outarg.attr.mode)))
253 		err = -EIO;
254 	if (!err && outarg.nodeid) {
255 		inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
256 				  &outarg.attr);
257 		if (!inode) {
258 			fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
259 			return ERR_PTR(-ENOMEM);
260 		}
261 	}
262 	fuse_put_request(fc, forget_req);
263 	if (err && err != -ENOENT)
264 		return ERR_PTR(err);
265 
266 	if (inode && S_ISDIR(inode->i_mode)) {
267 		mutex_lock(&fc->inst_mutex);
268 		err = fuse_d_add_directory(entry, inode);
269 		mutex_unlock(&fc->inst_mutex);
270 		if (err) {
271 			iput(inode);
272 			return ERR_PTR(err);
273 		}
274 	} else
275 		d_add(entry, inode);
276 
277 	entry->d_op = &fuse_dentry_operations;
278 	if (!err)
279 		fuse_change_timeout(entry, &outarg);
280 	else
281 		fuse_invalidate_entry_cache(entry);
282 	return NULL;
283 }
284 
285 /*
286  * Synchronous release for the case when something goes wrong in CREATE_OPEN
287  */
288 static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
289 			      u64 nodeid, int flags)
290 {
291 	struct fuse_req *req;
292 
293 	req = fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
294 	req->force = 1;
295 	request_send(fc, req);
296 	fuse_put_request(fc, req);
297 }
298 
299 /*
300  * Atomic create+open operation
301  *
302  * If the filesystem doesn't support this, then fall back to separate
303  * 'mknod' + 'open' requests.
304  */
305 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
306 			    struct nameidata *nd)
307 {
308 	int err;
309 	struct inode *inode;
310 	struct fuse_conn *fc = get_fuse_conn(dir);
311 	struct fuse_req *req;
312 	struct fuse_req *forget_req;
313 	struct fuse_open_in inarg;
314 	struct fuse_open_out outopen;
315 	struct fuse_entry_out outentry;
316 	struct fuse_file *ff;
317 	struct file *file;
318 	int flags = nd->intent.open.flags - 1;
319 
320 	if (fc->no_create)
321 		return -ENOSYS;
322 
323 	forget_req = fuse_get_req(fc);
324 	if (IS_ERR(forget_req))
325 		return PTR_ERR(forget_req);
326 
327 	req = fuse_get_req(fc);
328 	err = PTR_ERR(req);
329 	if (IS_ERR(req))
330 		goto out_put_forget_req;
331 
332 	err = -ENOMEM;
333 	ff = fuse_file_alloc();
334 	if (!ff)
335 		goto out_put_request;
336 
337 	flags &= ~O_NOCTTY;
338 	memset(&inarg, 0, sizeof(inarg));
339 	inarg.flags = flags;
340 	inarg.mode = mode;
341 	req->in.h.opcode = FUSE_CREATE;
342 	req->in.h.nodeid = get_node_id(dir);
343 	req->in.numargs = 2;
344 	req->in.args[0].size = sizeof(inarg);
345 	req->in.args[0].value = &inarg;
346 	req->in.args[1].size = entry->d_name.len + 1;
347 	req->in.args[1].value = entry->d_name.name;
348 	req->out.numargs = 2;
349 	req->out.args[0].size = sizeof(outentry);
350 	req->out.args[0].value = &outentry;
351 	req->out.args[1].size = sizeof(outopen);
352 	req->out.args[1].value = &outopen;
353 	request_send(fc, req);
354 	err = req->out.h.error;
355 	if (err) {
356 		if (err == -ENOSYS)
357 			fc->no_create = 1;
358 		goto out_free_ff;
359 	}
360 
361 	err = -EIO;
362 	if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
363 		goto out_free_ff;
364 
365 	fuse_put_request(fc, req);
366 	inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
367 			  &outentry.attr);
368 	if (!inode) {
369 		flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
370 		ff->fh = outopen.fh;
371 		fuse_sync_release(fc, ff, outentry.nodeid, flags);
372 		fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
373 		return -ENOMEM;
374 	}
375 	fuse_put_request(fc, forget_req);
376 	d_instantiate(entry, inode);
377 	fuse_change_timeout(entry, &outentry);
378 	file = lookup_instantiate_filp(nd, entry, generic_file_open);
379 	if (IS_ERR(file)) {
380 		ff->fh = outopen.fh;
381 		fuse_sync_release(fc, ff, outentry.nodeid, flags);
382 		return PTR_ERR(file);
383 	}
384 	fuse_finish_open(inode, file, ff, &outopen);
385 	return 0;
386 
387  out_free_ff:
388 	fuse_file_free(ff);
389  out_put_request:
390 	fuse_put_request(fc, req);
391  out_put_forget_req:
392 	fuse_put_request(fc, forget_req);
393 	return err;
394 }
395 
396 /*
397  * Code shared between mknod, mkdir, symlink and link
398  */
399 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
400 			    struct inode *dir, struct dentry *entry,
401 			    int mode)
402 {
403 	struct fuse_entry_out outarg;
404 	struct inode *inode;
405 	int err;
406 	struct fuse_req *forget_req;
407 
408 	forget_req = fuse_get_req(fc);
409 	if (IS_ERR(forget_req)) {
410 		fuse_put_request(fc, req);
411 		return PTR_ERR(forget_req);
412 	}
413 
414 	req->in.h.nodeid = get_node_id(dir);
415 	req->out.numargs = 1;
416 	req->out.args[0].size = sizeof(outarg);
417 	req->out.args[0].value = &outarg;
418 	request_send(fc, req);
419 	err = req->out.h.error;
420 	fuse_put_request(fc, req);
421 	if (err)
422 		goto out_put_forget_req;
423 
424 	err = -EIO;
425 	if (invalid_nodeid(outarg.nodeid))
426 		goto out_put_forget_req;
427 
428 	if ((outarg.attr.mode ^ mode) & S_IFMT)
429 		goto out_put_forget_req;
430 
431 	inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
432 			  &outarg.attr);
433 	if (!inode) {
434 		fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
435 		return -ENOMEM;
436 	}
437 	fuse_put_request(fc, forget_req);
438 
439 	if (S_ISDIR(inode->i_mode)) {
440 		struct dentry *alias;
441 		mutex_lock(&fc->inst_mutex);
442 		alias = d_find_alias(inode);
443 		if (alias) {
444 			/* New directory must have moved since mkdir */
445 			mutex_unlock(&fc->inst_mutex);
446 			dput(alias);
447 			iput(inode);
448 			return -EBUSY;
449 		}
450 		d_instantiate(entry, inode);
451 		mutex_unlock(&fc->inst_mutex);
452 	} else
453 		d_instantiate(entry, inode);
454 
455 	fuse_change_timeout(entry, &outarg);
456 	fuse_invalidate_attr(dir);
457 	return 0;
458 
459  out_put_forget_req:
460 	fuse_put_request(fc, forget_req);
461 	return err;
462 }
463 
464 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
465 		      dev_t rdev)
466 {
467 	struct fuse_mknod_in inarg;
468 	struct fuse_conn *fc = get_fuse_conn(dir);
469 	struct fuse_req *req = fuse_get_req(fc);
470 	if (IS_ERR(req))
471 		return PTR_ERR(req);
472 
473 	memset(&inarg, 0, sizeof(inarg));
474 	inarg.mode = mode;
475 	inarg.rdev = new_encode_dev(rdev);
476 	req->in.h.opcode = FUSE_MKNOD;
477 	req->in.numargs = 2;
478 	req->in.args[0].size = sizeof(inarg);
479 	req->in.args[0].value = &inarg;
480 	req->in.args[1].size = entry->d_name.len + 1;
481 	req->in.args[1].value = entry->d_name.name;
482 	return create_new_entry(fc, req, dir, entry, mode);
483 }
484 
485 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
486 		       struct nameidata *nd)
487 {
488 	if (nd && (nd->flags & LOOKUP_CREATE)) {
489 		int err = fuse_create_open(dir, entry, mode, nd);
490 		if (err != -ENOSYS)
491 			return err;
492 		/* Fall back on mknod */
493 	}
494 	return fuse_mknod(dir, entry, mode, 0);
495 }
496 
497 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
498 {
499 	struct fuse_mkdir_in inarg;
500 	struct fuse_conn *fc = get_fuse_conn(dir);
501 	struct fuse_req *req = fuse_get_req(fc);
502 	if (IS_ERR(req))
503 		return PTR_ERR(req);
504 
505 	memset(&inarg, 0, sizeof(inarg));
506 	inarg.mode = mode;
507 	req->in.h.opcode = FUSE_MKDIR;
508 	req->in.numargs = 2;
509 	req->in.args[0].size = sizeof(inarg);
510 	req->in.args[0].value = &inarg;
511 	req->in.args[1].size = entry->d_name.len + 1;
512 	req->in.args[1].value = entry->d_name.name;
513 	return create_new_entry(fc, req, dir, entry, S_IFDIR);
514 }
515 
516 static int fuse_symlink(struct inode *dir, struct dentry *entry,
517 			const char *link)
518 {
519 	struct fuse_conn *fc = get_fuse_conn(dir);
520 	unsigned len = strlen(link) + 1;
521 	struct fuse_req *req = fuse_get_req(fc);
522 	if (IS_ERR(req))
523 		return PTR_ERR(req);
524 
525 	req->in.h.opcode = FUSE_SYMLINK;
526 	req->in.numargs = 2;
527 	req->in.args[0].size = entry->d_name.len + 1;
528 	req->in.args[0].value = entry->d_name.name;
529 	req->in.args[1].size = len;
530 	req->in.args[1].value = link;
531 	return create_new_entry(fc, req, dir, entry, S_IFLNK);
532 }
533 
534 static int fuse_unlink(struct inode *dir, struct dentry *entry)
535 {
536 	int err;
537 	struct fuse_conn *fc = get_fuse_conn(dir);
538 	struct fuse_req *req = fuse_get_req(fc);
539 	if (IS_ERR(req))
540 		return PTR_ERR(req);
541 
542 	req->in.h.opcode = FUSE_UNLINK;
543 	req->in.h.nodeid = get_node_id(dir);
544 	req->in.numargs = 1;
545 	req->in.args[0].size = entry->d_name.len + 1;
546 	req->in.args[0].value = entry->d_name.name;
547 	request_send(fc, req);
548 	err = req->out.h.error;
549 	fuse_put_request(fc, req);
550 	if (!err) {
551 		struct inode *inode = entry->d_inode;
552 
553 		/* Set nlink to zero so the inode can be cleared, if
554                    the inode does have more links this will be
555                    discovered at the next lookup/getattr */
556 		clear_nlink(inode);
557 		fuse_invalidate_attr(inode);
558 		fuse_invalidate_attr(dir);
559 		fuse_invalidate_entry_cache(entry);
560 	} else if (err == -EINTR)
561 		fuse_invalidate_entry(entry);
562 	return err;
563 }
564 
565 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
566 {
567 	int err;
568 	struct fuse_conn *fc = get_fuse_conn(dir);
569 	struct fuse_req *req = fuse_get_req(fc);
570 	if (IS_ERR(req))
571 		return PTR_ERR(req);
572 
573 	req->in.h.opcode = FUSE_RMDIR;
574 	req->in.h.nodeid = get_node_id(dir);
575 	req->in.numargs = 1;
576 	req->in.args[0].size = entry->d_name.len + 1;
577 	req->in.args[0].value = entry->d_name.name;
578 	request_send(fc, req);
579 	err = req->out.h.error;
580 	fuse_put_request(fc, req);
581 	if (!err) {
582 		clear_nlink(entry->d_inode);
583 		fuse_invalidate_attr(dir);
584 		fuse_invalidate_entry_cache(entry);
585 	} else if (err == -EINTR)
586 		fuse_invalidate_entry(entry);
587 	return err;
588 }
589 
590 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
591 		       struct inode *newdir, struct dentry *newent)
592 {
593 	int err;
594 	struct fuse_rename_in inarg;
595 	struct fuse_conn *fc = get_fuse_conn(olddir);
596 	struct fuse_req *req = fuse_get_req(fc);
597 	if (IS_ERR(req))
598 		return PTR_ERR(req);
599 
600 	memset(&inarg, 0, sizeof(inarg));
601 	inarg.newdir = get_node_id(newdir);
602 	req->in.h.opcode = FUSE_RENAME;
603 	req->in.h.nodeid = get_node_id(olddir);
604 	req->in.numargs = 3;
605 	req->in.args[0].size = sizeof(inarg);
606 	req->in.args[0].value = &inarg;
607 	req->in.args[1].size = oldent->d_name.len + 1;
608 	req->in.args[1].value = oldent->d_name.name;
609 	req->in.args[2].size = newent->d_name.len + 1;
610 	req->in.args[2].value = newent->d_name.name;
611 	request_send(fc, req);
612 	err = req->out.h.error;
613 	fuse_put_request(fc, req);
614 	if (!err) {
615 		fuse_invalidate_attr(olddir);
616 		if (olddir != newdir)
617 			fuse_invalidate_attr(newdir);
618 
619 		/* newent will end up negative */
620 		if (newent->d_inode)
621 			fuse_invalidate_entry_cache(newent);
622 	} else if (err == -EINTR) {
623 		/* If request was interrupted, DEITY only knows if the
624 		   rename actually took place.  If the invalidation
625 		   fails (e.g. some process has CWD under the renamed
626 		   directory), then there can be inconsistency between
627 		   the dcache and the real filesystem.  Tough luck. */
628 		fuse_invalidate_entry(oldent);
629 		if (newent->d_inode)
630 			fuse_invalidate_entry(newent);
631 	}
632 
633 	return err;
634 }
635 
636 static int fuse_link(struct dentry *entry, struct inode *newdir,
637 		     struct dentry *newent)
638 {
639 	int err;
640 	struct fuse_link_in inarg;
641 	struct inode *inode = entry->d_inode;
642 	struct fuse_conn *fc = get_fuse_conn(inode);
643 	struct fuse_req *req = fuse_get_req(fc);
644 	if (IS_ERR(req))
645 		return PTR_ERR(req);
646 
647 	memset(&inarg, 0, sizeof(inarg));
648 	inarg.oldnodeid = get_node_id(inode);
649 	req->in.h.opcode = FUSE_LINK;
650 	req->in.numargs = 2;
651 	req->in.args[0].size = sizeof(inarg);
652 	req->in.args[0].value = &inarg;
653 	req->in.args[1].size = newent->d_name.len + 1;
654 	req->in.args[1].value = newent->d_name.name;
655 	err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
656 	/* Contrary to "normal" filesystems it can happen that link
657 	   makes two "logical" inodes point to the same "physical"
658 	   inode.  We invalidate the attributes of the old one, so it
659 	   will reflect changes in the backing inode (link count,
660 	   etc.)
661 	*/
662 	if (!err || err == -EINTR)
663 		fuse_invalidate_attr(inode);
664 	return err;
665 }
666 
667 int fuse_do_getattr(struct inode *inode)
668 {
669 	int err;
670 	struct fuse_attr_out arg;
671 	struct fuse_conn *fc = get_fuse_conn(inode);
672 	struct fuse_req *req = fuse_get_req(fc);
673 	if (IS_ERR(req))
674 		return PTR_ERR(req);
675 
676 	req->in.h.opcode = FUSE_GETATTR;
677 	req->in.h.nodeid = get_node_id(inode);
678 	req->out.numargs = 1;
679 	req->out.args[0].size = sizeof(arg);
680 	req->out.args[0].value = &arg;
681 	request_send(fc, req);
682 	err = req->out.h.error;
683 	fuse_put_request(fc, req);
684 	if (!err) {
685 		if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
686 			make_bad_inode(inode);
687 			err = -EIO;
688 		} else {
689 			struct fuse_inode *fi = get_fuse_inode(inode);
690 			fuse_change_attributes(inode, &arg.attr);
691 			fi->i_time = time_to_jiffies(arg.attr_valid,
692 						     arg.attr_valid_nsec);
693 		}
694 	}
695 	return err;
696 }
697 
698 /*
699  * Calling into a user-controlled filesystem gives the filesystem
700  * daemon ptrace-like capabilities over the requester process.  This
701  * means, that the filesystem daemon is able to record the exact
702  * filesystem operations performed, and can also control the behavior
703  * of the requester process in otherwise impossible ways.  For example
704  * it can delay the operation for arbitrary length of time allowing
705  * DoS against the requester.
706  *
707  * For this reason only those processes can call into the filesystem,
708  * for which the owner of the mount has ptrace privilege.  This
709  * excludes processes started by other users, suid or sgid processes.
710  */
711 static int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
712 {
713 	if (fc->flags & FUSE_ALLOW_OTHER)
714 		return 1;
715 
716 	if (task->euid == fc->user_id &&
717 	    task->suid == fc->user_id &&
718 	    task->uid == fc->user_id &&
719 	    task->egid == fc->group_id &&
720 	    task->sgid == fc->group_id &&
721 	    task->gid == fc->group_id)
722 		return 1;
723 
724 	return 0;
725 }
726 
727 /*
728  * Check whether the inode attributes are still valid
729  *
730  * If the attribute validity timeout has expired, then fetch the fresh
731  * attributes with a 'getattr' request
732  *
733  * I'm not sure why cached attributes are never returned for the root
734  * inode, this is probably being too cautious.
735  */
736 static int fuse_revalidate(struct dentry *entry)
737 {
738 	struct inode *inode = entry->d_inode;
739 	struct fuse_inode *fi = get_fuse_inode(inode);
740 	struct fuse_conn *fc = get_fuse_conn(inode);
741 
742 	if (!fuse_allow_task(fc, current))
743 		return -EACCES;
744 	if (get_node_id(inode) != FUSE_ROOT_ID &&
745 	    fi->i_time >= get_jiffies_64())
746 		return 0;
747 
748 	return fuse_do_getattr(inode);
749 }
750 
751 static int fuse_access(struct inode *inode, int mask)
752 {
753 	struct fuse_conn *fc = get_fuse_conn(inode);
754 	struct fuse_req *req;
755 	struct fuse_access_in inarg;
756 	int err;
757 
758 	if (fc->no_access)
759 		return 0;
760 
761 	req = fuse_get_req(fc);
762 	if (IS_ERR(req))
763 		return PTR_ERR(req);
764 
765 	memset(&inarg, 0, sizeof(inarg));
766 	inarg.mask = mask;
767 	req->in.h.opcode = FUSE_ACCESS;
768 	req->in.h.nodeid = get_node_id(inode);
769 	req->in.numargs = 1;
770 	req->in.args[0].size = sizeof(inarg);
771 	req->in.args[0].value = &inarg;
772 	request_send(fc, req);
773 	err = req->out.h.error;
774 	fuse_put_request(fc, req);
775 	if (err == -ENOSYS) {
776 		fc->no_access = 1;
777 		err = 0;
778 	}
779 	return err;
780 }
781 
782 /*
783  * Check permission.  The two basic access models of FUSE are:
784  *
785  * 1) Local access checking ('default_permissions' mount option) based
786  * on file mode.  This is the plain old disk filesystem permission
787  * modell.
788  *
789  * 2) "Remote" access checking, where server is responsible for
790  * checking permission in each inode operation.  An exception to this
791  * is if ->permission() was invoked from sys_access() in which case an
792  * access request is sent.  Execute permission is still checked
793  * locally based on file mode.
794  */
795 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
796 {
797 	struct fuse_conn *fc = get_fuse_conn(inode);
798 
799 	if (!fuse_allow_task(fc, current))
800 		return -EACCES;
801 	else if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
802 		int err = generic_permission(inode, mask, NULL);
803 
804 		/* If permission is denied, try to refresh file
805 		   attributes.  This is also needed, because the root
806 		   node will at first have no permissions */
807 		if (err == -EACCES) {
808 		 	err = fuse_do_getattr(inode);
809 			if (!err)
810 				err = generic_permission(inode, mask, NULL);
811 		}
812 
813 		/* Note: the opposite of the above test does not
814 		   exist.  So if permissions are revoked this won't be
815 		   noticed immediately, only after the attribute
816 		   timeout has expired */
817 
818 		return err;
819 	} else {
820 		int mode = inode->i_mode;
821 		if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
822 			return -EACCES;
823 
824 		if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR)))
825 			return fuse_access(inode, mask);
826 		return 0;
827 	}
828 }
829 
830 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
831 			 void *dstbuf, filldir_t filldir)
832 {
833 	while (nbytes >= FUSE_NAME_OFFSET) {
834 		struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
835 		size_t reclen = FUSE_DIRENT_SIZE(dirent);
836 		int over;
837 		if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
838 			return -EIO;
839 		if (reclen > nbytes)
840 			break;
841 
842 		over = filldir(dstbuf, dirent->name, dirent->namelen,
843 			       file->f_pos, dirent->ino, dirent->type);
844 		if (over)
845 			break;
846 
847 		buf += reclen;
848 		nbytes -= reclen;
849 		file->f_pos = dirent->off;
850 	}
851 
852 	return 0;
853 }
854 
855 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
856 {
857 	int err;
858 	size_t nbytes;
859 	struct page *page;
860 	struct inode *inode = file->f_path.dentry->d_inode;
861 	struct fuse_conn *fc = get_fuse_conn(inode);
862 	struct fuse_req *req;
863 
864 	if (is_bad_inode(inode))
865 		return -EIO;
866 
867 	req = fuse_get_req(fc);
868 	if (IS_ERR(req))
869 		return PTR_ERR(req);
870 
871 	page = alloc_page(GFP_KERNEL);
872 	if (!page) {
873 		fuse_put_request(fc, req);
874 		return -ENOMEM;
875 	}
876 	req->num_pages = 1;
877 	req->pages[0] = page;
878 	fuse_read_fill(req, file, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
879 	request_send(fc, req);
880 	nbytes = req->out.args[0].size;
881 	err = req->out.h.error;
882 	fuse_put_request(fc, req);
883 	if (!err)
884 		err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
885 				    filldir);
886 
887 	__free_page(page);
888 	fuse_invalidate_attr(inode); /* atime changed */
889 	return err;
890 }
891 
892 static char *read_link(struct dentry *dentry)
893 {
894 	struct inode *inode = dentry->d_inode;
895 	struct fuse_conn *fc = get_fuse_conn(inode);
896 	struct fuse_req *req = fuse_get_req(fc);
897 	char *link;
898 
899 	if (IS_ERR(req))
900 		return ERR_PTR(PTR_ERR(req));
901 
902 	link = (char *) __get_free_page(GFP_KERNEL);
903 	if (!link) {
904 		link = ERR_PTR(-ENOMEM);
905 		goto out;
906 	}
907 	req->in.h.opcode = FUSE_READLINK;
908 	req->in.h.nodeid = get_node_id(inode);
909 	req->out.argvar = 1;
910 	req->out.numargs = 1;
911 	req->out.args[0].size = PAGE_SIZE - 1;
912 	req->out.args[0].value = link;
913 	request_send(fc, req);
914 	if (req->out.h.error) {
915 		free_page((unsigned long) link);
916 		link = ERR_PTR(req->out.h.error);
917 	} else
918 		link[req->out.args[0].size] = '\0';
919  out:
920 	fuse_put_request(fc, req);
921 	fuse_invalidate_attr(inode); /* atime changed */
922 	return link;
923 }
924 
925 static void free_link(char *link)
926 {
927 	if (!IS_ERR(link))
928 		free_page((unsigned long) link);
929 }
930 
931 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
932 {
933 	nd_set_link(nd, read_link(dentry));
934 	return NULL;
935 }
936 
937 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
938 {
939 	free_link(nd_get_link(nd));
940 }
941 
942 static int fuse_dir_open(struct inode *inode, struct file *file)
943 {
944 	return fuse_open_common(inode, file, 1);
945 }
946 
947 static int fuse_dir_release(struct inode *inode, struct file *file)
948 {
949 	return fuse_release_common(inode, file, 1);
950 }
951 
952 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
953 {
954 	/* nfsd can call this with no file */
955 	return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
956 }
957 
958 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
959 {
960 	unsigned ivalid = iattr->ia_valid;
961 
962 	if (ivalid & ATTR_MODE)
963 		arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
964 	if (ivalid & ATTR_UID)
965 		arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
966 	if (ivalid & ATTR_GID)
967 		arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
968 	if (ivalid & ATTR_SIZE)
969 		arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
970 	/* You can only _set_ these together (they may change by themselves) */
971 	if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
972 		arg->valid |= FATTR_ATIME | FATTR_MTIME;
973 		arg->atime = iattr->ia_atime.tv_sec;
974 		arg->mtime = iattr->ia_mtime.tv_sec;
975 	}
976 	if (ivalid & ATTR_FILE) {
977 		struct fuse_file *ff = iattr->ia_file->private_data;
978 		arg->valid |= FATTR_FH;
979 		arg->fh = ff->fh;
980 	}
981 }
982 
983 static void fuse_vmtruncate(struct inode *inode, loff_t offset)
984 {
985 	struct fuse_conn *fc = get_fuse_conn(inode);
986 	int need_trunc;
987 
988 	spin_lock(&fc->lock);
989 	need_trunc = inode->i_size > offset;
990 	i_size_write(inode, offset);
991 	spin_unlock(&fc->lock);
992 
993 	if (need_trunc) {
994 		struct address_space *mapping = inode->i_mapping;
995 		unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
996 		truncate_inode_pages(mapping, offset);
997 	}
998 }
999 
1000 /*
1001  * Set attributes, and at the same time refresh them.
1002  *
1003  * Truncation is slightly complicated, because the 'truncate' request
1004  * may fail, in which case we don't want to touch the mapping.
1005  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1006  * and the actual truncation by hand.
1007  */
1008 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1009 {
1010 	struct inode *inode = entry->d_inode;
1011 	struct fuse_conn *fc = get_fuse_conn(inode);
1012 	struct fuse_inode *fi = get_fuse_inode(inode);
1013 	struct fuse_req *req;
1014 	struct fuse_setattr_in inarg;
1015 	struct fuse_attr_out outarg;
1016 	int err;
1017 	int is_truncate = 0;
1018 
1019 	if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1020 		err = inode_change_ok(inode, attr);
1021 		if (err)
1022 			return err;
1023 	}
1024 
1025 	if (attr->ia_valid & ATTR_SIZE) {
1026 		unsigned long limit;
1027 		is_truncate = 1;
1028 		if (IS_SWAPFILE(inode))
1029 			return -ETXTBSY;
1030 		limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1031 		if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1032 			send_sig(SIGXFSZ, current, 0);
1033 			return -EFBIG;
1034 		}
1035 	}
1036 
1037 	req = fuse_get_req(fc);
1038 	if (IS_ERR(req))
1039 		return PTR_ERR(req);
1040 
1041 	memset(&inarg, 0, sizeof(inarg));
1042 	iattr_to_fattr(attr, &inarg);
1043 	req->in.h.opcode = FUSE_SETATTR;
1044 	req->in.h.nodeid = get_node_id(inode);
1045 	req->in.numargs = 1;
1046 	req->in.args[0].size = sizeof(inarg);
1047 	req->in.args[0].value = &inarg;
1048 	req->out.numargs = 1;
1049 	req->out.args[0].size = sizeof(outarg);
1050 	req->out.args[0].value = &outarg;
1051 	request_send(fc, req);
1052 	err = req->out.h.error;
1053 	fuse_put_request(fc, req);
1054 	if (!err) {
1055 		if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1056 			make_bad_inode(inode);
1057 			err = -EIO;
1058 		} else {
1059 			if (is_truncate)
1060 				fuse_vmtruncate(inode, outarg.attr.size);
1061 			fuse_change_attributes(inode, &outarg.attr);
1062 			fi->i_time = time_to_jiffies(outarg.attr_valid,
1063 						     outarg.attr_valid_nsec);
1064 		}
1065 	} else if (err == -EINTR)
1066 		fuse_invalidate_attr(inode);
1067 
1068 	return err;
1069 }
1070 
1071 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1072 			struct kstat *stat)
1073 {
1074 	struct inode *inode = entry->d_inode;
1075 	int err = fuse_revalidate(entry);
1076 	if (!err)
1077 		generic_fillattr(inode, stat);
1078 
1079 	return err;
1080 }
1081 
1082 static int fuse_setxattr(struct dentry *entry, const char *name,
1083 			 const void *value, size_t size, int flags)
1084 {
1085 	struct inode *inode = entry->d_inode;
1086 	struct fuse_conn *fc = get_fuse_conn(inode);
1087 	struct fuse_req *req;
1088 	struct fuse_setxattr_in inarg;
1089 	int err;
1090 
1091 	if (fc->no_setxattr)
1092 		return -EOPNOTSUPP;
1093 
1094 	req = fuse_get_req(fc);
1095 	if (IS_ERR(req))
1096 		return PTR_ERR(req);
1097 
1098 	memset(&inarg, 0, sizeof(inarg));
1099 	inarg.size = size;
1100 	inarg.flags = flags;
1101 	req->in.h.opcode = FUSE_SETXATTR;
1102 	req->in.h.nodeid = get_node_id(inode);
1103 	req->in.numargs = 3;
1104 	req->in.args[0].size = sizeof(inarg);
1105 	req->in.args[0].value = &inarg;
1106 	req->in.args[1].size = strlen(name) + 1;
1107 	req->in.args[1].value = name;
1108 	req->in.args[2].size = size;
1109 	req->in.args[2].value = value;
1110 	request_send(fc, req);
1111 	err = req->out.h.error;
1112 	fuse_put_request(fc, req);
1113 	if (err == -ENOSYS) {
1114 		fc->no_setxattr = 1;
1115 		err = -EOPNOTSUPP;
1116 	}
1117 	return err;
1118 }
1119 
1120 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1121 			     void *value, size_t size)
1122 {
1123 	struct inode *inode = entry->d_inode;
1124 	struct fuse_conn *fc = get_fuse_conn(inode);
1125 	struct fuse_req *req;
1126 	struct fuse_getxattr_in inarg;
1127 	struct fuse_getxattr_out outarg;
1128 	ssize_t ret;
1129 
1130 	if (fc->no_getxattr)
1131 		return -EOPNOTSUPP;
1132 
1133 	req = fuse_get_req(fc);
1134 	if (IS_ERR(req))
1135 		return PTR_ERR(req);
1136 
1137 	memset(&inarg, 0, sizeof(inarg));
1138 	inarg.size = size;
1139 	req->in.h.opcode = FUSE_GETXATTR;
1140 	req->in.h.nodeid = get_node_id(inode);
1141 	req->in.numargs = 2;
1142 	req->in.args[0].size = sizeof(inarg);
1143 	req->in.args[0].value = &inarg;
1144 	req->in.args[1].size = strlen(name) + 1;
1145 	req->in.args[1].value = name;
1146 	/* This is really two different operations rolled into one */
1147 	req->out.numargs = 1;
1148 	if (size) {
1149 		req->out.argvar = 1;
1150 		req->out.args[0].size = size;
1151 		req->out.args[0].value = value;
1152 	} else {
1153 		req->out.args[0].size = sizeof(outarg);
1154 		req->out.args[0].value = &outarg;
1155 	}
1156 	request_send(fc, req);
1157 	ret = req->out.h.error;
1158 	if (!ret)
1159 		ret = size ? req->out.args[0].size : outarg.size;
1160 	else {
1161 		if (ret == -ENOSYS) {
1162 			fc->no_getxattr = 1;
1163 			ret = -EOPNOTSUPP;
1164 		}
1165 	}
1166 	fuse_put_request(fc, req);
1167 	return ret;
1168 }
1169 
1170 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1171 {
1172 	struct inode *inode = entry->d_inode;
1173 	struct fuse_conn *fc = get_fuse_conn(inode);
1174 	struct fuse_req *req;
1175 	struct fuse_getxattr_in inarg;
1176 	struct fuse_getxattr_out outarg;
1177 	ssize_t ret;
1178 
1179 	if (fc->no_listxattr)
1180 		return -EOPNOTSUPP;
1181 
1182 	req = fuse_get_req(fc);
1183 	if (IS_ERR(req))
1184 		return PTR_ERR(req);
1185 
1186 	memset(&inarg, 0, sizeof(inarg));
1187 	inarg.size = size;
1188 	req->in.h.opcode = FUSE_LISTXATTR;
1189 	req->in.h.nodeid = get_node_id(inode);
1190 	req->in.numargs = 1;
1191 	req->in.args[0].size = sizeof(inarg);
1192 	req->in.args[0].value = &inarg;
1193 	/* This is really two different operations rolled into one */
1194 	req->out.numargs = 1;
1195 	if (size) {
1196 		req->out.argvar = 1;
1197 		req->out.args[0].size = size;
1198 		req->out.args[0].value = list;
1199 	} else {
1200 		req->out.args[0].size = sizeof(outarg);
1201 		req->out.args[0].value = &outarg;
1202 	}
1203 	request_send(fc, req);
1204 	ret = req->out.h.error;
1205 	if (!ret)
1206 		ret = size ? req->out.args[0].size : outarg.size;
1207 	else {
1208 		if (ret == -ENOSYS) {
1209 			fc->no_listxattr = 1;
1210 			ret = -EOPNOTSUPP;
1211 		}
1212 	}
1213 	fuse_put_request(fc, req);
1214 	return ret;
1215 }
1216 
1217 static int fuse_removexattr(struct dentry *entry, const char *name)
1218 {
1219 	struct inode *inode = entry->d_inode;
1220 	struct fuse_conn *fc = get_fuse_conn(inode);
1221 	struct fuse_req *req;
1222 	int err;
1223 
1224 	if (fc->no_removexattr)
1225 		return -EOPNOTSUPP;
1226 
1227 	req = fuse_get_req(fc);
1228 	if (IS_ERR(req))
1229 		return PTR_ERR(req);
1230 
1231 	req->in.h.opcode = FUSE_REMOVEXATTR;
1232 	req->in.h.nodeid = get_node_id(inode);
1233 	req->in.numargs = 1;
1234 	req->in.args[0].size = strlen(name) + 1;
1235 	req->in.args[0].value = name;
1236 	request_send(fc, req);
1237 	err = req->out.h.error;
1238 	fuse_put_request(fc, req);
1239 	if (err == -ENOSYS) {
1240 		fc->no_removexattr = 1;
1241 		err = -EOPNOTSUPP;
1242 	}
1243 	return err;
1244 }
1245 
1246 static const struct inode_operations fuse_dir_inode_operations = {
1247 	.lookup		= fuse_lookup,
1248 	.mkdir		= fuse_mkdir,
1249 	.symlink	= fuse_symlink,
1250 	.unlink		= fuse_unlink,
1251 	.rmdir		= fuse_rmdir,
1252 	.rename		= fuse_rename,
1253 	.link		= fuse_link,
1254 	.setattr	= fuse_setattr,
1255 	.create		= fuse_create,
1256 	.mknod		= fuse_mknod,
1257 	.permission	= fuse_permission,
1258 	.getattr	= fuse_getattr,
1259 	.setxattr	= fuse_setxattr,
1260 	.getxattr	= fuse_getxattr,
1261 	.listxattr	= fuse_listxattr,
1262 	.removexattr	= fuse_removexattr,
1263 };
1264 
1265 static const struct file_operations fuse_dir_operations = {
1266 	.llseek		= generic_file_llseek,
1267 	.read		= generic_read_dir,
1268 	.readdir	= fuse_readdir,
1269 	.open		= fuse_dir_open,
1270 	.release	= fuse_dir_release,
1271 	.fsync		= fuse_dir_fsync,
1272 };
1273 
1274 static const struct inode_operations fuse_common_inode_operations = {
1275 	.setattr	= fuse_setattr,
1276 	.permission	= fuse_permission,
1277 	.getattr	= fuse_getattr,
1278 	.setxattr	= fuse_setxattr,
1279 	.getxattr	= fuse_getxattr,
1280 	.listxattr	= fuse_listxattr,
1281 	.removexattr	= fuse_removexattr,
1282 };
1283 
1284 static const struct inode_operations fuse_symlink_inode_operations = {
1285 	.setattr	= fuse_setattr,
1286 	.follow_link	= fuse_follow_link,
1287 	.put_link	= fuse_put_link,
1288 	.readlink	= generic_readlink,
1289 	.getattr	= fuse_getattr,
1290 	.setxattr	= fuse_setxattr,
1291 	.getxattr	= fuse_getxattr,
1292 	.listxattr	= fuse_listxattr,
1293 	.removexattr	= fuse_removexattr,
1294 };
1295 
1296 void fuse_init_common(struct inode *inode)
1297 {
1298 	inode->i_op = &fuse_common_inode_operations;
1299 }
1300 
1301 void fuse_init_dir(struct inode *inode)
1302 {
1303 	inode->i_op = &fuse_dir_inode_operations;
1304 	inode->i_fop = &fuse_dir_operations;
1305 }
1306 
1307 void fuse_init_symlink(struct inode *inode)
1308 {
1309 	inode->i_op = &fuse_symlink_inode_operations;
1310 }
1311