xref: /openbmc/linux/fs/fuse/dir.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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 
17 static 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 
24 static 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 
39 static 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;
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);
49 		struct fuse_req *req = fuse_get_request(fc);
50 		if (!req)
51 			return 0;
52 
53 		fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
54 		request_send(fc, req);
55 		err = req->out.h.error;
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 		}
63 		fuse_put_request(fc, req);
64 		if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
65 			return 0;
66 
67 		fuse_change_attributes(inode, &outarg.attr);
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 
76 static struct dentry_operations fuse_dentry_operations = {
77 	.d_revalidate	= fuse_dentry_revalidate,
78 };
79 
80 static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
81 			    struct inode **inodep)
82 {
83 	int err;
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)
94 		return -EINTR;
95 
96 	fuse_lookup_init(req, dir, entry, &outarg);
97 	request_send(fc, req);
98 	err = req->out.h.error;
99 	if (!err && (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID))
100 		err = -EIO;
101 	if (!err) {
102 		inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
103 				  &outarg.attr);
104 		if (!inode) {
105 			fuse_send_forget(fc, req, outarg.nodeid, 1);
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 
126 void fuse_invalidate_attr(struct inode *inode)
127 {
128 	get_fuse_inode(inode)->i_time = jiffies - 1;
129 }
130 
131 static void fuse_invalidate_entry(struct dentry *entry)
132 {
133 	d_invalidate(entry);
134 	entry->d_time = jiffies - 1;
135 }
136 
137 static 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 	}
157 	if (!outarg.nodeid || outarg.nodeid == FUSE_ROOT_ID) {
158 		fuse_put_request(fc, req);
159 		return -EIO;
160 	}
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 
187 static 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)
194 		return -EINTR;
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 
208 static 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 
214 static 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)
220 		return -EINTR;
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 
233 static 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)
245 		return -EINTR;
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 
256 static 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)
262 		return -EINTR;
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 
287 static 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)
293 		return -EINTR;
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 
312 static 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)
320 		return -EINTR;
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 
356 static 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)
365 		return -EINTR;
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 
388 int 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)
395 		return -EINTR;
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 
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  */
433 static 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 
449 static 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 
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))
459 		return 0;
460 
461 	return fuse_do_getattr(inode);
462 }
463 
464 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
465 {
466 	struct fuse_conn *fc = get_fuse_conn(inode);
467 
468 	if (!fuse_allow_task(fc, current))
469 		return -EACCES;
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 {
493 		int mode = inode->i_mode;
494 		if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
495                     (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
496                         return -EROFS;
497 		if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
498 			return -EACCES;
499 		return 0;
500 	}
501 }
502 
503 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
504 			 void *dstbuf, filldir_t filldir)
505 {
506 	while (nbytes >= FUSE_NAME_OFFSET) {
507 		struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
508 		size_t reclen = FUSE_DIRENT_SIZE(dirent);
509 		int over;
510 		if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
511 			return -EIO;
512 		if (reclen > nbytes)
513 			break;
514 
515 		over = filldir(dstbuf, dirent->name, dirent->namelen,
516 			       file->f_pos, dirent->ino, dirent->type);
517 		if (over)
518 			break;
519 
520 		buf += reclen;
521 		nbytes -= reclen;
522 		file->f_pos = dirent->off;
523 	}
524 
525 	return 0;
526 }
527 
528 static inline size_t fuse_send_readdir(struct fuse_req *req, struct file *file,
529 				       struct inode *inode, loff_t pos,
530 				       size_t count)
531 {
532 	return fuse_send_read_common(req, file, inode, pos, count, 1);
533 }
534 
535 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
536 {
537 	int err;
538 	size_t nbytes;
539 	struct page *page;
540 	struct inode *inode = file->f_dentry->d_inode;
541 	struct fuse_conn *fc = get_fuse_conn(inode);
542 	struct fuse_req *req = fuse_get_request(fc);
543 	if (!req)
544 		return -EINTR;
545 
546 	page = alloc_page(GFP_KERNEL);
547 	if (!page) {
548 		fuse_put_request(fc, req);
549 		return -ENOMEM;
550 	}
551 	req->num_pages = 1;
552 	req->pages[0] = page;
553 	nbytes = fuse_send_readdir(req, file, inode, file->f_pos, PAGE_SIZE);
554 	err = req->out.h.error;
555 	fuse_put_request(fc, req);
556 	if (!err)
557 		err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
558 				    filldir);
559 
560 	__free_page(page);
561 	fuse_invalidate_attr(inode); /* atime changed */
562 	return err;
563 }
564 
565 static char *read_link(struct dentry *dentry)
566 {
567 	struct inode *inode = dentry->d_inode;
568 	struct fuse_conn *fc = get_fuse_conn(inode);
569 	struct fuse_req *req = fuse_get_request(fc);
570 	char *link;
571 
572 	if (!req)
573 		return ERR_PTR(-EINTR);
574 
575 	link = (char *) __get_free_page(GFP_KERNEL);
576 	if (!link) {
577 		link = ERR_PTR(-ENOMEM);
578 		goto out;
579 	}
580 	req->in.h.opcode = FUSE_READLINK;
581 	req->in.h.nodeid = get_node_id(inode);
582 	req->inode = inode;
583 	req->out.argvar = 1;
584 	req->out.numargs = 1;
585 	req->out.args[0].size = PAGE_SIZE - 1;
586 	req->out.args[0].value = link;
587 	request_send(fc, req);
588 	if (req->out.h.error) {
589 		free_page((unsigned long) link);
590 		link = ERR_PTR(req->out.h.error);
591 	} else
592 		link[req->out.args[0].size] = '\0';
593  out:
594 	fuse_put_request(fc, req);
595 	fuse_invalidate_attr(inode); /* atime changed */
596 	return link;
597 }
598 
599 static void free_link(char *link)
600 {
601 	if (!IS_ERR(link))
602 		free_page((unsigned long) link);
603 }
604 
605 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
606 {
607 	nd_set_link(nd, read_link(dentry));
608 	return NULL;
609 }
610 
611 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
612 {
613 	free_link(nd_get_link(nd));
614 }
615 
616 static int fuse_dir_open(struct inode *inode, struct file *file)
617 {
618 	return fuse_open_common(inode, file, 1);
619 }
620 
621 static int fuse_dir_release(struct inode *inode, struct file *file)
622 {
623 	return fuse_release_common(inode, file, 1);
624 }
625 
626 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
627 {
628 	/* nfsd can call this with no file */
629 	return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
630 }
631 
632 static unsigned iattr_to_fattr(struct iattr *iattr, struct fuse_attr *fattr)
633 {
634 	unsigned ivalid = iattr->ia_valid;
635 	unsigned fvalid = 0;
636 
637 	memset(fattr, 0, sizeof(*fattr));
638 
639 	if (ivalid & ATTR_MODE)
640 		fvalid |= FATTR_MODE,   fattr->mode = iattr->ia_mode;
641 	if (ivalid & ATTR_UID)
642 		fvalid |= FATTR_UID,    fattr->uid = iattr->ia_uid;
643 	if (ivalid & ATTR_GID)
644 		fvalid |= FATTR_GID,    fattr->gid = iattr->ia_gid;
645 	if (ivalid & ATTR_SIZE)
646 		fvalid |= FATTR_SIZE,   fattr->size = iattr->ia_size;
647 	/* You can only _set_ these together (they may change by themselves) */
648 	if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
649 		fvalid |= FATTR_ATIME | FATTR_MTIME;
650 		fattr->atime = iattr->ia_atime.tv_sec;
651 		fattr->mtime = iattr->ia_mtime.tv_sec;
652 	}
653 
654 	return fvalid;
655 }
656 
657 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
658 {
659 	struct inode *inode = entry->d_inode;
660 	struct fuse_conn *fc = get_fuse_conn(inode);
661 	struct fuse_inode *fi = get_fuse_inode(inode);
662 	struct fuse_req *req;
663 	struct fuse_setattr_in inarg;
664 	struct fuse_attr_out outarg;
665 	int err;
666 	int is_truncate = 0;
667 
668 	if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
669 		err = inode_change_ok(inode, attr);
670 		if (err)
671 			return err;
672 	}
673 
674 	if (attr->ia_valid & ATTR_SIZE) {
675 		unsigned long limit;
676 		is_truncate = 1;
677 		limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
678 		if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
679 			send_sig(SIGXFSZ, current, 0);
680 			return -EFBIG;
681 		}
682 	}
683 
684 	req = fuse_get_request(fc);
685 	if (!req)
686 		return -EINTR;
687 
688 	memset(&inarg, 0, sizeof(inarg));
689 	inarg.valid = iattr_to_fattr(attr, &inarg.attr);
690 	req->in.h.opcode = FUSE_SETATTR;
691 	req->in.h.nodeid = get_node_id(inode);
692 	req->inode = inode;
693 	req->in.numargs = 1;
694 	req->in.args[0].size = sizeof(inarg);
695 	req->in.args[0].value = &inarg;
696 	req->out.numargs = 1;
697 	req->out.args[0].size = sizeof(outarg);
698 	req->out.args[0].value = &outarg;
699 	request_send(fc, req);
700 	err = req->out.h.error;
701 	fuse_put_request(fc, req);
702 	if (!err) {
703 		if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
704 			make_bad_inode(inode);
705 			err = -EIO;
706 		} else {
707 			if (is_truncate) {
708 				loff_t origsize = i_size_read(inode);
709 				i_size_write(inode, outarg.attr.size);
710 				if (origsize > outarg.attr.size)
711 					vmtruncate(inode, outarg.attr.size);
712 			}
713 			fuse_change_attributes(inode, &outarg.attr);
714 			fi->i_time = time_to_jiffies(outarg.attr_valid,
715 						     outarg.attr_valid_nsec);
716 		}
717 	} else if (err == -EINTR)
718 		fuse_invalidate_attr(inode);
719 
720 	return err;
721 }
722 
723 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
724 			struct kstat *stat)
725 {
726 	struct inode *inode = entry->d_inode;
727 	int err = fuse_revalidate(entry);
728 	if (!err)
729 		generic_fillattr(inode, stat);
730 
731 	return err;
732 }
733 
734 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
735 				  struct nameidata *nd)
736 {
737 	struct inode *inode;
738 	int err = fuse_lookup_iget(dir, entry, &inode);
739 	if (err)
740 		return ERR_PTR(err);
741 	if (inode && S_ISDIR(inode->i_mode)) {
742 		/* Don't allow creating an alias to a directory  */
743 		struct dentry *alias = d_find_alias(inode);
744 		if (alias) {
745 			dput(alias);
746 			iput(inode);
747 			return ERR_PTR(-EIO);
748 		}
749 	}
750 	d_add(entry, inode);
751 	return NULL;
752 }
753 
754 static int fuse_setxattr(struct dentry *entry, const char *name,
755 			 const void *value, size_t size, int flags)
756 {
757 	struct inode *inode = entry->d_inode;
758 	struct fuse_conn *fc = get_fuse_conn(inode);
759 	struct fuse_req *req;
760 	struct fuse_setxattr_in inarg;
761 	int err;
762 
763 	if (size > FUSE_XATTR_SIZE_MAX)
764 		return -E2BIG;
765 
766 	if (fc->no_setxattr)
767 		return -EOPNOTSUPP;
768 
769 	req = fuse_get_request(fc);
770 	if (!req)
771 		return -EINTR;
772 
773 	memset(&inarg, 0, sizeof(inarg));
774 	inarg.size = size;
775 	inarg.flags = flags;
776 	req->in.h.opcode = FUSE_SETXATTR;
777 	req->in.h.nodeid = get_node_id(inode);
778 	req->inode = inode;
779 	req->in.numargs = 3;
780 	req->in.args[0].size = sizeof(inarg);
781 	req->in.args[0].value = &inarg;
782 	req->in.args[1].size = strlen(name) + 1;
783 	req->in.args[1].value = name;
784 	req->in.args[2].size = size;
785 	req->in.args[2].value = value;
786 	request_send(fc, req);
787 	err = req->out.h.error;
788 	fuse_put_request(fc, req);
789 	if (err == -ENOSYS) {
790 		fc->no_setxattr = 1;
791 		err = -EOPNOTSUPP;
792 	}
793 	return err;
794 }
795 
796 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
797 			     void *value, size_t size)
798 {
799 	struct inode *inode = entry->d_inode;
800 	struct fuse_conn *fc = get_fuse_conn(inode);
801 	struct fuse_req *req;
802 	struct fuse_getxattr_in inarg;
803 	struct fuse_getxattr_out outarg;
804 	ssize_t ret;
805 
806 	if (fc->no_getxattr)
807 		return -EOPNOTSUPP;
808 
809 	req = fuse_get_request(fc);
810 	if (!req)
811 		return -EINTR;
812 
813 	memset(&inarg, 0, sizeof(inarg));
814 	inarg.size = size;
815 	req->in.h.opcode = FUSE_GETXATTR;
816 	req->in.h.nodeid = get_node_id(inode);
817 	req->inode = inode;
818 	req->in.numargs = 2;
819 	req->in.args[0].size = sizeof(inarg);
820 	req->in.args[0].value = &inarg;
821 	req->in.args[1].size = strlen(name) + 1;
822 	req->in.args[1].value = name;
823 	/* This is really two different operations rolled into one */
824 	req->out.numargs = 1;
825 	if (size) {
826 		req->out.argvar = 1;
827 		req->out.args[0].size = size;
828 		req->out.args[0].value = value;
829 	} else {
830 		req->out.args[0].size = sizeof(outarg);
831 		req->out.args[0].value = &outarg;
832 	}
833 	request_send(fc, req);
834 	ret = req->out.h.error;
835 	if (!ret)
836 		ret = size ? req->out.args[0].size : outarg.size;
837 	else {
838 		if (ret == -ENOSYS) {
839 			fc->no_getxattr = 1;
840 			ret = -EOPNOTSUPP;
841 		}
842 	}
843 	fuse_put_request(fc, req);
844 	return ret;
845 }
846 
847 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
848 {
849 	struct inode *inode = entry->d_inode;
850 	struct fuse_conn *fc = get_fuse_conn(inode);
851 	struct fuse_req *req;
852 	struct fuse_getxattr_in inarg;
853 	struct fuse_getxattr_out outarg;
854 	ssize_t ret;
855 
856 	if (fc->no_listxattr)
857 		return -EOPNOTSUPP;
858 
859 	req = fuse_get_request(fc);
860 	if (!req)
861 		return -EINTR;
862 
863 	memset(&inarg, 0, sizeof(inarg));
864 	inarg.size = size;
865 	req->in.h.opcode = FUSE_LISTXATTR;
866 	req->in.h.nodeid = get_node_id(inode);
867 	req->inode = inode;
868 	req->in.numargs = 1;
869 	req->in.args[0].size = sizeof(inarg);
870 	req->in.args[0].value = &inarg;
871 	/* This is really two different operations rolled into one */
872 	req->out.numargs = 1;
873 	if (size) {
874 		req->out.argvar = 1;
875 		req->out.args[0].size = size;
876 		req->out.args[0].value = list;
877 	} else {
878 		req->out.args[0].size = sizeof(outarg);
879 		req->out.args[0].value = &outarg;
880 	}
881 	request_send(fc, req);
882 	ret = req->out.h.error;
883 	if (!ret)
884 		ret = size ? req->out.args[0].size : outarg.size;
885 	else {
886 		if (ret == -ENOSYS) {
887 			fc->no_listxattr = 1;
888 			ret = -EOPNOTSUPP;
889 		}
890 	}
891 	fuse_put_request(fc, req);
892 	return ret;
893 }
894 
895 static int fuse_removexattr(struct dentry *entry, const char *name)
896 {
897 	struct inode *inode = entry->d_inode;
898 	struct fuse_conn *fc = get_fuse_conn(inode);
899 	struct fuse_req *req;
900 	int err;
901 
902 	if (fc->no_removexattr)
903 		return -EOPNOTSUPP;
904 
905 	req = fuse_get_request(fc);
906 	if (!req)
907 		return -EINTR;
908 
909 	req->in.h.opcode = FUSE_REMOVEXATTR;
910 	req->in.h.nodeid = get_node_id(inode);
911 	req->inode = inode;
912 	req->in.numargs = 1;
913 	req->in.args[0].size = strlen(name) + 1;
914 	req->in.args[0].value = name;
915 	request_send(fc, req);
916 	err = req->out.h.error;
917 	fuse_put_request(fc, req);
918 	if (err == -ENOSYS) {
919 		fc->no_removexattr = 1;
920 		err = -EOPNOTSUPP;
921 	}
922 	return err;
923 }
924 
925 static struct inode_operations fuse_dir_inode_operations = {
926 	.lookup		= fuse_lookup,
927 	.mkdir		= fuse_mkdir,
928 	.symlink	= fuse_symlink,
929 	.unlink		= fuse_unlink,
930 	.rmdir		= fuse_rmdir,
931 	.rename		= fuse_rename,
932 	.link		= fuse_link,
933 	.setattr	= fuse_setattr,
934 	.create		= fuse_create,
935 	.mknod		= fuse_mknod,
936 	.permission	= fuse_permission,
937 	.getattr	= fuse_getattr,
938 	.setxattr	= fuse_setxattr,
939 	.getxattr	= fuse_getxattr,
940 	.listxattr	= fuse_listxattr,
941 	.removexattr	= fuse_removexattr,
942 };
943 
944 static struct file_operations fuse_dir_operations = {
945 	.llseek		= generic_file_llseek,
946 	.read		= generic_read_dir,
947 	.readdir	= fuse_readdir,
948 	.open		= fuse_dir_open,
949 	.release	= fuse_dir_release,
950 	.fsync		= fuse_dir_fsync,
951 };
952 
953 static struct inode_operations fuse_common_inode_operations = {
954 	.setattr	= fuse_setattr,
955 	.permission	= fuse_permission,
956 	.getattr	= fuse_getattr,
957 	.setxattr	= fuse_setxattr,
958 	.getxattr	= fuse_getxattr,
959 	.listxattr	= fuse_listxattr,
960 	.removexattr	= fuse_removexattr,
961 };
962 
963 static struct inode_operations fuse_symlink_inode_operations = {
964 	.setattr	= fuse_setattr,
965 	.follow_link	= fuse_follow_link,
966 	.put_link	= fuse_put_link,
967 	.readlink	= generic_readlink,
968 	.getattr	= fuse_getattr,
969 	.setxattr	= fuse_setxattr,
970 	.getxattr	= fuse_getxattr,
971 	.listxattr	= fuse_listxattr,
972 	.removexattr	= fuse_removexattr,
973 };
974 
975 void fuse_init_common(struct inode *inode)
976 {
977 	inode->i_op = &fuse_common_inode_operations;
978 }
979 
980 void fuse_init_dir(struct inode *inode)
981 {
982 	inode->i_op = &fuse_dir_inode_operations;
983 	inode->i_fop = &fuse_dir_operations;
984 }
985 
986 void fuse_init_symlink(struct inode *inode)
987 {
988 	inode->i_op = &fuse_symlink_inode_operations;
989 }
990