xref: /openbmc/linux/fs/9p/vfs_inode.c (revision 9cdb81c7)
1 /*
2  *  linux/fs/9p/vfs_inode.c
3  *
4  * This file contains vfs inode ops for the 9P2000 protocol.
5  *
6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License version 2
11  *  as published by the Free Software Foundation.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to:
20  *  Free Software Foundation
21  *  51 Franklin Street, Fifth Floor
22  *  Boston, MA  02111-1301  USA
23  *
24  */
25 
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 
28 #include <linux/module.h>
29 #include <linux/errno.h>
30 #include <linux/fs.h>
31 #include <linux/file.h>
32 #include <linux/pagemap.h>
33 #include <linux/stat.h>
34 #include <linux/string.h>
35 #include <linux/inet.h>
36 #include <linux/namei.h>
37 #include <linux/idr.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/xattr.h>
41 #include <linux/posix_acl.h>
42 #include <net/9p/9p.h>
43 #include <net/9p/client.h>
44 
45 #include "v9fs.h"
46 #include "v9fs_vfs.h"
47 #include "fid.h"
48 #include "cache.h"
49 #include "xattr.h"
50 #include "acl.h"
51 
52 static const struct inode_operations v9fs_dir_inode_operations;
53 static const struct inode_operations v9fs_dir_inode_operations_dotu;
54 static const struct inode_operations v9fs_file_inode_operations;
55 static const struct inode_operations v9fs_symlink_inode_operations;
56 
57 /**
58  * unixmode2p9mode - convert unix mode bits to plan 9
59  * @v9ses: v9fs session information
60  * @mode: mode to convert
61  *
62  */
63 
64 static u32 unixmode2p9mode(struct v9fs_session_info *v9ses, umode_t mode)
65 {
66 	int res;
67 	res = mode & 0777;
68 	if (S_ISDIR(mode))
69 		res |= P9_DMDIR;
70 	if (v9fs_proto_dotu(v9ses)) {
71 		if (v9ses->nodev == 0) {
72 			if (S_ISSOCK(mode))
73 				res |= P9_DMSOCKET;
74 			if (S_ISFIFO(mode))
75 				res |= P9_DMNAMEDPIPE;
76 			if (S_ISBLK(mode))
77 				res |= P9_DMDEVICE;
78 			if (S_ISCHR(mode))
79 				res |= P9_DMDEVICE;
80 		}
81 
82 		if ((mode & S_ISUID) == S_ISUID)
83 			res |= P9_DMSETUID;
84 		if ((mode & S_ISGID) == S_ISGID)
85 			res |= P9_DMSETGID;
86 		if ((mode & S_ISVTX) == S_ISVTX)
87 			res |= P9_DMSETVTX;
88 	}
89 	return res;
90 }
91 
92 /**
93  * p9mode2perm- convert plan9 mode bits to unix permission bits
94  * @v9ses: v9fs session information
95  * @stat: p9_wstat from which mode need to be derived
96  *
97  */
98 static int p9mode2perm(struct v9fs_session_info *v9ses,
99 		       struct p9_wstat *stat)
100 {
101 	int res;
102 	int mode = stat->mode;
103 
104 	res = mode & S_IALLUGO;
105 	if (v9fs_proto_dotu(v9ses)) {
106 		if ((mode & P9_DMSETUID) == P9_DMSETUID)
107 			res |= S_ISUID;
108 
109 		if ((mode & P9_DMSETGID) == P9_DMSETGID)
110 			res |= S_ISGID;
111 
112 		if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
113 			res |= S_ISVTX;
114 	}
115 	return res;
116 }
117 
118 /**
119  * p9mode2unixmode- convert plan9 mode bits to unix mode bits
120  * @v9ses: v9fs session information
121  * @stat: p9_wstat from which mode need to be derived
122  * @rdev: major number, minor number in case of device files.
123  *
124  */
125 static umode_t p9mode2unixmode(struct v9fs_session_info *v9ses,
126 			       struct p9_wstat *stat, dev_t *rdev)
127 {
128 	int res;
129 	u32 mode = stat->mode;
130 
131 	*rdev = 0;
132 	res = p9mode2perm(v9ses, stat);
133 
134 	if ((mode & P9_DMDIR) == P9_DMDIR)
135 		res |= S_IFDIR;
136 	else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
137 		res |= S_IFLNK;
138 	else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
139 		 && (v9ses->nodev == 0))
140 		res |= S_IFSOCK;
141 	else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
142 		 && (v9ses->nodev == 0))
143 		res |= S_IFIFO;
144 	else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
145 		 && (v9ses->nodev == 0)) {
146 		char type = 0, ext[32];
147 		int major = -1, minor = -1;
148 
149 		strncpy(ext, stat->extension, sizeof(ext));
150 		sscanf(ext, "%c %u %u", &type, &major, &minor);
151 		switch (type) {
152 		case 'c':
153 			res |= S_IFCHR;
154 			break;
155 		case 'b':
156 			res |= S_IFBLK;
157 			break;
158 		default:
159 			p9_debug(P9_DEBUG_ERROR, "Unknown special type %c %s\n",
160 				 type, stat->extension);
161 		};
162 		*rdev = MKDEV(major, minor);
163 	} else
164 		res |= S_IFREG;
165 
166 	return res;
167 }
168 
169 /**
170  * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
171  * @uflags: flags to convert
172  * @extended: if .u extensions are active
173  */
174 
175 int v9fs_uflags2omode(int uflags, int extended)
176 {
177 	int ret;
178 
179 	ret = 0;
180 	switch (uflags&3) {
181 	default:
182 	case O_RDONLY:
183 		ret = P9_OREAD;
184 		break;
185 
186 	case O_WRONLY:
187 		ret = P9_OWRITE;
188 		break;
189 
190 	case O_RDWR:
191 		ret = P9_ORDWR;
192 		break;
193 	}
194 
195 	if (uflags & O_TRUNC)
196 		ret |= P9_OTRUNC;
197 
198 	if (extended) {
199 		if (uflags & O_EXCL)
200 			ret |= P9_OEXCL;
201 
202 		if (uflags & O_APPEND)
203 			ret |= P9_OAPPEND;
204 	}
205 
206 	return ret;
207 }
208 
209 /**
210  * v9fs_blank_wstat - helper function to setup a 9P stat structure
211  * @wstat: structure to initialize
212  *
213  */
214 
215 void
216 v9fs_blank_wstat(struct p9_wstat *wstat)
217 {
218 	wstat->type = ~0;
219 	wstat->dev = ~0;
220 	wstat->qid.type = ~0;
221 	wstat->qid.version = ~0;
222 	*((long long *)&wstat->qid.path) = ~0;
223 	wstat->mode = ~0;
224 	wstat->atime = ~0;
225 	wstat->mtime = ~0;
226 	wstat->length = ~0;
227 	wstat->name = NULL;
228 	wstat->uid = NULL;
229 	wstat->gid = NULL;
230 	wstat->muid = NULL;
231 	wstat->n_uid = ~0;
232 	wstat->n_gid = ~0;
233 	wstat->n_muid = ~0;
234 	wstat->extension = NULL;
235 }
236 
237 /**
238  * v9fs_alloc_inode - helper function to allocate an inode
239  *
240  */
241 struct inode *v9fs_alloc_inode(struct super_block *sb)
242 {
243 	struct v9fs_inode *v9inode;
244 	v9inode = (struct v9fs_inode *)kmem_cache_alloc(v9fs_inode_cache,
245 							GFP_KERNEL);
246 	if (!v9inode)
247 		return NULL;
248 #ifdef CONFIG_9P_FSCACHE
249 	v9inode->fscache = NULL;
250 	spin_lock_init(&v9inode->fscache_lock);
251 #endif
252 	v9inode->writeback_fid = NULL;
253 	v9inode->cache_validity = 0;
254 	mutex_init(&v9inode->v_mutex);
255 	return &v9inode->vfs_inode;
256 }
257 
258 /**
259  * v9fs_destroy_inode - destroy an inode
260  *
261  */
262 
263 static void v9fs_i_callback(struct rcu_head *head)
264 {
265 	struct inode *inode = container_of(head, struct inode, i_rcu);
266 	kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
267 }
268 
269 void v9fs_destroy_inode(struct inode *inode)
270 {
271 	call_rcu(&inode->i_rcu, v9fs_i_callback);
272 }
273 
274 int v9fs_init_inode(struct v9fs_session_info *v9ses,
275 		    struct inode *inode, umode_t mode, dev_t rdev)
276 {
277 	int err = 0;
278 
279 	inode_init_owner(inode, NULL, mode);
280 	inode->i_blocks = 0;
281 	inode->i_rdev = rdev;
282 	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
283 	inode->i_mapping->a_ops = &v9fs_addr_operations;
284 
285 	switch (mode & S_IFMT) {
286 	case S_IFIFO:
287 	case S_IFBLK:
288 	case S_IFCHR:
289 	case S_IFSOCK:
290 		if (v9fs_proto_dotl(v9ses)) {
291 			inode->i_op = &v9fs_file_inode_operations_dotl;
292 		} else if (v9fs_proto_dotu(v9ses)) {
293 			inode->i_op = &v9fs_file_inode_operations;
294 		} else {
295 			p9_debug(P9_DEBUG_ERROR,
296 				 "special files without extended mode\n");
297 			err = -EINVAL;
298 			goto error;
299 		}
300 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
301 		break;
302 	case S_IFREG:
303 		if (v9fs_proto_dotl(v9ses)) {
304 			inode->i_op = &v9fs_file_inode_operations_dotl;
305 			if (v9ses->cache)
306 				inode->i_fop =
307 					&v9fs_cached_file_operations_dotl;
308 			else
309 				inode->i_fop = &v9fs_file_operations_dotl;
310 		} else {
311 			inode->i_op = &v9fs_file_inode_operations;
312 			if (v9ses->cache)
313 				inode->i_fop = &v9fs_cached_file_operations;
314 			else
315 				inode->i_fop = &v9fs_file_operations;
316 		}
317 
318 		break;
319 	case S_IFLNK:
320 		if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
321 			p9_debug(P9_DEBUG_ERROR,
322 				 "extended modes used with legacy protocol\n");
323 			err = -EINVAL;
324 			goto error;
325 		}
326 
327 		if (v9fs_proto_dotl(v9ses))
328 			inode->i_op = &v9fs_symlink_inode_operations_dotl;
329 		else
330 			inode->i_op = &v9fs_symlink_inode_operations;
331 
332 		break;
333 	case S_IFDIR:
334 		inc_nlink(inode);
335 		if (v9fs_proto_dotl(v9ses))
336 			inode->i_op = &v9fs_dir_inode_operations_dotl;
337 		else if (v9fs_proto_dotu(v9ses))
338 			inode->i_op = &v9fs_dir_inode_operations_dotu;
339 		else
340 			inode->i_op = &v9fs_dir_inode_operations;
341 
342 		if (v9fs_proto_dotl(v9ses))
343 			inode->i_fop = &v9fs_dir_operations_dotl;
344 		else
345 			inode->i_fop = &v9fs_dir_operations;
346 
347 		break;
348 	default:
349 		p9_debug(P9_DEBUG_ERROR, "BAD mode 0x%hx S_IFMT 0x%x\n",
350 			 mode, mode & S_IFMT);
351 		err = -EINVAL;
352 		goto error;
353 	}
354 error:
355 	return err;
356 
357 }
358 
359 /**
360  * v9fs_get_inode - helper function to setup an inode
361  * @sb: superblock
362  * @mode: mode to setup inode with
363  *
364  */
365 
366 struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t rdev)
367 {
368 	int err;
369 	struct inode *inode;
370 	struct v9fs_session_info *v9ses = sb->s_fs_info;
371 
372 	p9_debug(P9_DEBUG_VFS, "super block: %p mode: %ho\n", sb, mode);
373 
374 	inode = new_inode(sb);
375 	if (!inode) {
376 		pr_warn("%s (%d): Problem allocating inode\n",
377 			__func__, task_pid_nr(current));
378 		return ERR_PTR(-ENOMEM);
379 	}
380 	err = v9fs_init_inode(v9ses, inode, mode, rdev);
381 	if (err) {
382 		iput(inode);
383 		return ERR_PTR(err);
384 	}
385 	return inode;
386 }
387 
388 /*
389 static struct v9fs_fid*
390 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
391 {
392 	int err;
393 	int nfid;
394 	struct v9fs_fid *ret;
395 	struct v9fs_fcall *fcall;
396 
397 	nfid = v9fs_get_idpool(&v9ses->fidpool);
398 	if (nfid < 0) {
399 		eprintk(KERN_WARNING, "no free fids available\n");
400 		return ERR_PTR(-ENOSPC);
401 	}
402 
403 	err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
404 		&fcall);
405 
406 	if (err < 0) {
407 		if (fcall && fcall->id == RWALK)
408 			goto clunk_fid;
409 
410 		PRINT_FCALL_ERROR("walk error", fcall);
411 		v9fs_put_idpool(nfid, &v9ses->fidpool);
412 		goto error;
413 	}
414 
415 	kfree(fcall);
416 	fcall = NULL;
417 	ret = v9fs_fid_create(v9ses, nfid);
418 	if (!ret) {
419 		err = -ENOMEM;
420 		goto clunk_fid;
421 	}
422 
423 	err = v9fs_fid_insert(ret, dentry);
424 	if (err < 0) {
425 		v9fs_fid_destroy(ret);
426 		goto clunk_fid;
427 	}
428 
429 	return ret;
430 
431 clunk_fid:
432 	v9fs_t_clunk(v9ses, nfid);
433 
434 error:
435 	kfree(fcall);
436 	return ERR_PTR(err);
437 }
438 */
439 
440 
441 /**
442  * v9fs_clear_inode - release an inode
443  * @inode: inode to release
444  *
445  */
446 void v9fs_evict_inode(struct inode *inode)
447 {
448 	struct v9fs_inode *v9inode = V9FS_I(inode);
449 
450 	truncate_inode_pages(inode->i_mapping, 0);
451 	end_writeback(inode);
452 	filemap_fdatawrite(inode->i_mapping);
453 
454 #ifdef CONFIG_9P_FSCACHE
455 	v9fs_cache_inode_put_cookie(inode);
456 #endif
457 	/* clunk the fid stashed in writeback_fid */
458 	if (v9inode->writeback_fid) {
459 		p9_client_clunk(v9inode->writeback_fid);
460 		v9inode->writeback_fid = NULL;
461 	}
462 }
463 
464 static int v9fs_test_inode(struct inode *inode, void *data)
465 {
466 	int umode;
467 	dev_t rdev;
468 	struct v9fs_inode *v9inode = V9FS_I(inode);
469 	struct p9_wstat *st = (struct p9_wstat *)data;
470 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
471 
472 	umode = p9mode2unixmode(v9ses, st, &rdev);
473 	/* don't match inode of different type */
474 	if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
475 		return 0;
476 
477 	/* compare qid details */
478 	if (memcmp(&v9inode->qid.version,
479 		   &st->qid.version, sizeof(v9inode->qid.version)))
480 		return 0;
481 
482 	if (v9inode->qid.type != st->qid.type)
483 		return 0;
484 	return 1;
485 }
486 
487 static int v9fs_test_new_inode(struct inode *inode, void *data)
488 {
489 	return 0;
490 }
491 
492 static int v9fs_set_inode(struct inode *inode,  void *data)
493 {
494 	struct v9fs_inode *v9inode = V9FS_I(inode);
495 	struct p9_wstat *st = (struct p9_wstat *)data;
496 
497 	memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
498 	return 0;
499 }
500 
501 static struct inode *v9fs_qid_iget(struct super_block *sb,
502 				   struct p9_qid *qid,
503 				   struct p9_wstat *st,
504 				   int new)
505 {
506 	dev_t rdev;
507 	int retval;
508 	umode_t umode;
509 	unsigned long i_ino;
510 	struct inode *inode;
511 	struct v9fs_session_info *v9ses = sb->s_fs_info;
512 	int (*test)(struct inode *, void *);
513 
514 	if (new)
515 		test = v9fs_test_new_inode;
516 	else
517 		test = v9fs_test_inode;
518 
519 	i_ino = v9fs_qid2ino(qid);
520 	inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
521 	if (!inode)
522 		return ERR_PTR(-ENOMEM);
523 	if (!(inode->i_state & I_NEW))
524 		return inode;
525 	/*
526 	 * initialize the inode with the stat info
527 	 * FIXME!! we may need support for stale inodes
528 	 * later.
529 	 */
530 	inode->i_ino = i_ino;
531 	umode = p9mode2unixmode(v9ses, st, &rdev);
532 	retval = v9fs_init_inode(v9ses, inode, umode, rdev);
533 	if (retval)
534 		goto error;
535 
536 	v9fs_stat2inode(st, inode, sb);
537 #ifdef CONFIG_9P_FSCACHE
538 	v9fs_cache_inode_get_cookie(inode);
539 #endif
540 	unlock_new_inode(inode);
541 	return inode;
542 error:
543 	unlock_new_inode(inode);
544 	iput(inode);
545 	return ERR_PTR(retval);
546 
547 }
548 
549 struct inode *
550 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
551 		    struct super_block *sb, int new)
552 {
553 	struct p9_wstat *st;
554 	struct inode *inode = NULL;
555 
556 	st = p9_client_stat(fid);
557 	if (IS_ERR(st))
558 		return ERR_CAST(st);
559 
560 	inode = v9fs_qid_iget(sb, &st->qid, st, new);
561 	p9stat_free(st);
562 	kfree(st);
563 	return inode;
564 }
565 
566 /**
567  * v9fs_at_to_dotl_flags- convert Linux specific AT flags to
568  * plan 9 AT flag.
569  * @flags: flags to convert
570  */
571 static int v9fs_at_to_dotl_flags(int flags)
572 {
573 	int rflags = 0;
574 	if (flags & AT_REMOVEDIR)
575 		rflags |= P9_DOTL_AT_REMOVEDIR;
576 	return rflags;
577 }
578 
579 /**
580  * v9fs_remove - helper function to remove files and directories
581  * @dir: directory inode that is being deleted
582  * @dentry:  dentry that is being deleted
583  * @rmdir: removing a directory
584  *
585  */
586 
587 static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
588 {
589 	struct inode *inode;
590 	int retval = -EOPNOTSUPP;
591 	struct p9_fid *v9fid, *dfid;
592 	struct v9fs_session_info *v9ses;
593 
594 	p9_debug(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
595 		 dir, dentry, flags);
596 
597 	v9ses = v9fs_inode2v9ses(dir);
598 	inode = dentry->d_inode;
599 	dfid = v9fs_fid_lookup(dentry->d_parent);
600 	if (IS_ERR(dfid)) {
601 		retval = PTR_ERR(dfid);
602 		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
603 		return retval;
604 	}
605 	if (v9fs_proto_dotl(v9ses))
606 		retval = p9_client_unlinkat(dfid, dentry->d_name.name,
607 					    v9fs_at_to_dotl_flags(flags));
608 	if (retval == -EOPNOTSUPP) {
609 		/* Try the one based on path */
610 		v9fid = v9fs_fid_clone(dentry);
611 		if (IS_ERR(v9fid))
612 			return PTR_ERR(v9fid);
613 		retval = p9_client_remove(v9fid);
614 	}
615 	if (!retval) {
616 		/*
617 		 * directories on unlink should have zero
618 		 * link count
619 		 */
620 		if (flags & AT_REMOVEDIR) {
621 			clear_nlink(inode);
622 			drop_nlink(dir);
623 		} else
624 			drop_nlink(inode);
625 
626 		v9fs_invalidate_inode_attr(inode);
627 		v9fs_invalidate_inode_attr(dir);
628 	}
629 	return retval;
630 }
631 
632 /**
633  * v9fs_create - Create a file
634  * @v9ses: session information
635  * @dir: directory that dentry is being created in
636  * @dentry:  dentry that is being created
637  * @extension: 9p2000.u extension string to support devices, etc.
638  * @perm: create permissions
639  * @mode: open mode
640  *
641  */
642 static struct p9_fid *
643 v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
644 		struct dentry *dentry, char *extension, u32 perm, u8 mode)
645 {
646 	int err;
647 	char *name;
648 	struct p9_fid *dfid, *ofid, *fid;
649 	struct inode *inode;
650 
651 	p9_debug(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
652 
653 	err = 0;
654 	ofid = NULL;
655 	fid = NULL;
656 	name = (char *) dentry->d_name.name;
657 	dfid = v9fs_fid_lookup(dentry->d_parent);
658 	if (IS_ERR(dfid)) {
659 		err = PTR_ERR(dfid);
660 		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
661 		return ERR_PTR(err);
662 	}
663 
664 	/* clone a fid to use for creation */
665 	ofid = p9_client_walk(dfid, 0, NULL, 1);
666 	if (IS_ERR(ofid)) {
667 		err = PTR_ERR(ofid);
668 		p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
669 		return ERR_PTR(err);
670 	}
671 
672 	err = p9_client_fcreate(ofid, name, perm, mode, extension);
673 	if (err < 0) {
674 		p9_debug(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
675 		goto error;
676 	}
677 
678 	if (!(perm & P9_DMLINK)) {
679 		/* now walk from the parent so we can get unopened fid */
680 		fid = p9_client_walk(dfid, 1, &name, 1);
681 		if (IS_ERR(fid)) {
682 			err = PTR_ERR(fid);
683 			p9_debug(P9_DEBUG_VFS,
684 				   "p9_client_walk failed %d\n", err);
685 			fid = NULL;
686 			goto error;
687 		}
688 		/*
689 		 * instantiate inode and assign the unopened fid to the dentry
690 		 */
691 		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
692 		if (IS_ERR(inode)) {
693 			err = PTR_ERR(inode);
694 			p9_debug(P9_DEBUG_VFS,
695 				   "inode creation failed %d\n", err);
696 			goto error;
697 		}
698 		err = v9fs_fid_add(dentry, fid);
699 		if (err < 0)
700 			goto error;
701 		d_instantiate(dentry, inode);
702 	}
703 	return ofid;
704 error:
705 	if (ofid)
706 		p9_client_clunk(ofid);
707 
708 	if (fid)
709 		p9_client_clunk(fid);
710 
711 	return ERR_PTR(err);
712 }
713 
714 /**
715  * v9fs_vfs_create - VFS hook to create files
716  * @dir: directory inode that is being created
717  * @dentry:  dentry that is being deleted
718  * @mode: create permissions
719  * @nd: path information
720  *
721  */
722 
723 static int
724 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
725 		struct nameidata *nd)
726 {
727 	int err;
728 	u32 perm;
729 	int flags;
730 	struct file *filp;
731 	struct v9fs_inode *v9inode;
732 	struct v9fs_session_info *v9ses;
733 	struct p9_fid *fid, *inode_fid;
734 
735 	err = 0;
736 	fid = NULL;
737 	v9ses = v9fs_inode2v9ses(dir);
738 	perm = unixmode2p9mode(v9ses, mode);
739 	if (nd)
740 		flags = nd->intent.open.flags;
741 	else
742 		flags = O_RDWR;
743 
744 	fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
745 				v9fs_uflags2omode(flags,
746 						v9fs_proto_dotu(v9ses)));
747 	if (IS_ERR(fid)) {
748 		err = PTR_ERR(fid);
749 		fid = NULL;
750 		goto error;
751 	}
752 
753 	v9fs_invalidate_inode_attr(dir);
754 	/* if we are opening a file, assign the open fid to the file */
755 	if (nd) {
756 		v9inode = V9FS_I(dentry->d_inode);
757 		mutex_lock(&v9inode->v_mutex);
758 		if (v9ses->cache && !v9inode->writeback_fid &&
759 		    ((flags & O_ACCMODE) != O_RDONLY)) {
760 			/*
761 			 * clone a fid and add it to writeback_fid
762 			 * we do it during open time instead of
763 			 * page dirty time via write_begin/page_mkwrite
764 			 * because we want write after unlink usecase
765 			 * to work.
766 			 */
767 			inode_fid = v9fs_writeback_fid(dentry);
768 			if (IS_ERR(inode_fid)) {
769 				err = PTR_ERR(inode_fid);
770 				mutex_unlock(&v9inode->v_mutex);
771 				goto error;
772 			}
773 			v9inode->writeback_fid = (void *) inode_fid;
774 		}
775 		mutex_unlock(&v9inode->v_mutex);
776 		filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
777 		if (IS_ERR(filp)) {
778 			err = PTR_ERR(filp);
779 			goto error;
780 		}
781 
782 		filp->private_data = fid;
783 #ifdef CONFIG_9P_FSCACHE
784 		if (v9ses->cache)
785 			v9fs_cache_inode_set_cookie(dentry->d_inode, filp);
786 #endif
787 	} else
788 		p9_client_clunk(fid);
789 
790 	return 0;
791 
792 error:
793 	if (fid)
794 		p9_client_clunk(fid);
795 
796 	return err;
797 }
798 
799 /**
800  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
801  * @dir:  inode that is being unlinked
802  * @dentry: dentry that is being unlinked
803  * @mode: mode for new directory
804  *
805  */
806 
807 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
808 {
809 	int err;
810 	u32 perm;
811 	struct p9_fid *fid;
812 	struct v9fs_session_info *v9ses;
813 
814 	p9_debug(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
815 	err = 0;
816 	v9ses = v9fs_inode2v9ses(dir);
817 	perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
818 	fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
819 	if (IS_ERR(fid)) {
820 		err = PTR_ERR(fid);
821 		fid = NULL;
822 	} else {
823 		inc_nlink(dir);
824 		v9fs_invalidate_inode_attr(dir);
825 	}
826 
827 	if (fid)
828 		p9_client_clunk(fid);
829 
830 	return err;
831 }
832 
833 /**
834  * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
835  * @dir:  inode that is being walked from
836  * @dentry: dentry that is being walked to?
837  * @nameidata: path data
838  *
839  */
840 
841 struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
842 				      struct nameidata *nameidata)
843 {
844 	struct dentry *res;
845 	struct super_block *sb;
846 	struct v9fs_session_info *v9ses;
847 	struct p9_fid *dfid, *fid;
848 	struct inode *inode;
849 	char *name;
850 	int result = 0;
851 
852 	p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
853 		 dir, dentry->d_name.name, dentry, nameidata);
854 
855 	if (dentry->d_name.len > NAME_MAX)
856 		return ERR_PTR(-ENAMETOOLONG);
857 
858 	sb = dir->i_sb;
859 	v9ses = v9fs_inode2v9ses(dir);
860 	/* We can walk d_parent because we hold the dir->i_mutex */
861 	dfid = v9fs_fid_lookup(dentry->d_parent);
862 	if (IS_ERR(dfid))
863 		return ERR_CAST(dfid);
864 
865 	name = (char *) dentry->d_name.name;
866 	fid = p9_client_walk(dfid, 1, &name, 1);
867 	if (IS_ERR(fid)) {
868 		result = PTR_ERR(fid);
869 		if (result == -ENOENT) {
870 			inode = NULL;
871 			goto inst_out;
872 		}
873 
874 		return ERR_PTR(result);
875 	}
876 	/*
877 	 * Make sure we don't use a wrong inode due to parallel
878 	 * unlink. For cached mode create calls request for new
879 	 * inode. But with cache disabled, lookup should do this.
880 	 */
881 	if (v9ses->cache)
882 		inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
883 	else
884 		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
885 	if (IS_ERR(inode)) {
886 		result = PTR_ERR(inode);
887 		inode = NULL;
888 		goto error;
889 	}
890 	result = v9fs_fid_add(dentry, fid);
891 	if (result < 0)
892 		goto error_iput;
893 inst_out:
894 	/*
895 	 * If we had a rename on the server and a parallel lookup
896 	 * for the new name, then make sure we instantiate with
897 	 * the new name. ie look up for a/b, while on server somebody
898 	 * moved b under k and client parallely did a lookup for
899 	 * k/b.
900 	 */
901 	res = d_materialise_unique(dentry, inode);
902 	if (!IS_ERR(res))
903 		return res;
904 	result = PTR_ERR(res);
905 error_iput:
906 	iput(inode);
907 error:
908 	p9_client_clunk(fid);
909 
910 	return ERR_PTR(result);
911 }
912 
913 /**
914  * v9fs_vfs_unlink - VFS unlink hook to delete an inode
915  * @i:  inode that is being unlinked
916  * @d: dentry that is being unlinked
917  *
918  */
919 
920 int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
921 {
922 	return v9fs_remove(i, d, 0);
923 }
924 
925 /**
926  * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
927  * @i:  inode that is being unlinked
928  * @d: dentry that is being unlinked
929  *
930  */
931 
932 int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
933 {
934 	return v9fs_remove(i, d, AT_REMOVEDIR);
935 }
936 
937 /**
938  * v9fs_vfs_rename - VFS hook to rename an inode
939  * @old_dir:  old dir inode
940  * @old_dentry: old dentry
941  * @new_dir: new dir inode
942  * @new_dentry: new dentry
943  *
944  */
945 
946 int
947 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
948 		struct inode *new_dir, struct dentry *new_dentry)
949 {
950 	int retval;
951 	struct inode *old_inode;
952 	struct inode *new_inode;
953 	struct v9fs_session_info *v9ses;
954 	struct p9_fid *oldfid;
955 	struct p9_fid *olddirfid;
956 	struct p9_fid *newdirfid;
957 	struct p9_wstat wstat;
958 
959 	p9_debug(P9_DEBUG_VFS, "\n");
960 	retval = 0;
961 	old_inode = old_dentry->d_inode;
962 	new_inode = new_dentry->d_inode;
963 	v9ses = v9fs_inode2v9ses(old_inode);
964 	oldfid = v9fs_fid_lookup(old_dentry);
965 	if (IS_ERR(oldfid))
966 		return PTR_ERR(oldfid);
967 
968 	olddirfid = v9fs_fid_clone(old_dentry->d_parent);
969 	if (IS_ERR(olddirfid)) {
970 		retval = PTR_ERR(olddirfid);
971 		goto done;
972 	}
973 
974 	newdirfid = v9fs_fid_clone(new_dentry->d_parent);
975 	if (IS_ERR(newdirfid)) {
976 		retval = PTR_ERR(newdirfid);
977 		goto clunk_olddir;
978 	}
979 
980 	down_write(&v9ses->rename_sem);
981 	if (v9fs_proto_dotl(v9ses)) {
982 		retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
983 					    newdirfid, new_dentry->d_name.name);
984 		if (retval == -EOPNOTSUPP)
985 			retval = p9_client_rename(oldfid, newdirfid,
986 						  new_dentry->d_name.name);
987 		if (retval != -EOPNOTSUPP)
988 			goto clunk_newdir;
989 	}
990 	if (old_dentry->d_parent != new_dentry->d_parent) {
991 		/*
992 		 * 9P .u can only handle file rename in the same directory
993 		 */
994 
995 		p9_debug(P9_DEBUG_ERROR, "old dir and new dir are different\n");
996 		retval = -EXDEV;
997 		goto clunk_newdir;
998 	}
999 	v9fs_blank_wstat(&wstat);
1000 	wstat.muid = v9ses->uname;
1001 	wstat.name = (char *) new_dentry->d_name.name;
1002 	retval = p9_client_wstat(oldfid, &wstat);
1003 
1004 clunk_newdir:
1005 	if (!retval) {
1006 		if (new_inode) {
1007 			if (S_ISDIR(new_inode->i_mode))
1008 				clear_nlink(new_inode);
1009 			else
1010 				drop_nlink(new_inode);
1011 		}
1012 		if (S_ISDIR(old_inode->i_mode)) {
1013 			if (!new_inode)
1014 				inc_nlink(new_dir);
1015 			drop_nlink(old_dir);
1016 		}
1017 		v9fs_invalidate_inode_attr(old_inode);
1018 		v9fs_invalidate_inode_attr(old_dir);
1019 		v9fs_invalidate_inode_attr(new_dir);
1020 
1021 		/* successful rename */
1022 		d_move(old_dentry, new_dentry);
1023 	}
1024 	up_write(&v9ses->rename_sem);
1025 	p9_client_clunk(newdirfid);
1026 
1027 clunk_olddir:
1028 	p9_client_clunk(olddirfid);
1029 
1030 done:
1031 	return retval;
1032 }
1033 
1034 /**
1035  * v9fs_vfs_getattr - retrieve file metadata
1036  * @mnt: mount information
1037  * @dentry: file to get attributes on
1038  * @stat: metadata structure to populate
1039  *
1040  */
1041 
1042 static int
1043 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1044 		 struct kstat *stat)
1045 {
1046 	int err;
1047 	struct v9fs_session_info *v9ses;
1048 	struct p9_fid *fid;
1049 	struct p9_wstat *st;
1050 
1051 	p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1052 	err = -EPERM;
1053 	v9ses = v9fs_dentry2v9ses(dentry);
1054 	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1055 		generic_fillattr(dentry->d_inode, stat);
1056 		return 0;
1057 	}
1058 	fid = v9fs_fid_lookup(dentry);
1059 	if (IS_ERR(fid))
1060 		return PTR_ERR(fid);
1061 
1062 	st = p9_client_stat(fid);
1063 	if (IS_ERR(st))
1064 		return PTR_ERR(st);
1065 
1066 	v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
1067 	generic_fillattr(dentry->d_inode, stat);
1068 
1069 	p9stat_free(st);
1070 	kfree(st);
1071 	return 0;
1072 }
1073 
1074 /**
1075  * v9fs_vfs_setattr - set file metadata
1076  * @dentry: file whose metadata to set
1077  * @iattr: metadata assignment structure
1078  *
1079  */
1080 
1081 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
1082 {
1083 	int retval;
1084 	struct v9fs_session_info *v9ses;
1085 	struct p9_fid *fid;
1086 	struct p9_wstat wstat;
1087 
1088 	p9_debug(P9_DEBUG_VFS, "\n");
1089 	retval = inode_change_ok(dentry->d_inode, iattr);
1090 	if (retval)
1091 		return retval;
1092 
1093 	retval = -EPERM;
1094 	v9ses = v9fs_dentry2v9ses(dentry);
1095 	fid = v9fs_fid_lookup(dentry);
1096 	if(IS_ERR(fid))
1097 		return PTR_ERR(fid);
1098 
1099 	v9fs_blank_wstat(&wstat);
1100 	if (iattr->ia_valid & ATTR_MODE)
1101 		wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
1102 
1103 	if (iattr->ia_valid & ATTR_MTIME)
1104 		wstat.mtime = iattr->ia_mtime.tv_sec;
1105 
1106 	if (iattr->ia_valid & ATTR_ATIME)
1107 		wstat.atime = iattr->ia_atime.tv_sec;
1108 
1109 	if (iattr->ia_valid & ATTR_SIZE)
1110 		wstat.length = iattr->ia_size;
1111 
1112 	if (v9fs_proto_dotu(v9ses)) {
1113 		if (iattr->ia_valid & ATTR_UID)
1114 			wstat.n_uid = iattr->ia_uid;
1115 
1116 		if (iattr->ia_valid & ATTR_GID)
1117 			wstat.n_gid = iattr->ia_gid;
1118 	}
1119 
1120 	/* Write all dirty data */
1121 	if (S_ISREG(dentry->d_inode->i_mode))
1122 		filemap_write_and_wait(dentry->d_inode->i_mapping);
1123 
1124 	retval = p9_client_wstat(fid, &wstat);
1125 	if (retval < 0)
1126 		return retval;
1127 
1128 	if ((iattr->ia_valid & ATTR_SIZE) &&
1129 	    iattr->ia_size != i_size_read(dentry->d_inode))
1130 		truncate_setsize(dentry->d_inode, iattr->ia_size);
1131 
1132 	v9fs_invalidate_inode_attr(dentry->d_inode);
1133 
1134 	setattr_copy(dentry->d_inode, iattr);
1135 	mark_inode_dirty(dentry->d_inode);
1136 	return 0;
1137 }
1138 
1139 /**
1140  * v9fs_stat2inode - populate an inode structure with mistat info
1141  * @stat: Plan 9 metadata (mistat) structure
1142  * @inode: inode to populate
1143  * @sb: superblock of filesystem
1144  *
1145  */
1146 
1147 void
1148 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
1149 	struct super_block *sb)
1150 {
1151 	umode_t mode;
1152 	char ext[32];
1153 	char tag_name[14];
1154 	unsigned int i_nlink;
1155 	struct v9fs_session_info *v9ses = sb->s_fs_info;
1156 	struct v9fs_inode *v9inode = V9FS_I(inode);
1157 
1158 	set_nlink(inode, 1);
1159 
1160 	inode->i_atime.tv_sec = stat->atime;
1161 	inode->i_mtime.tv_sec = stat->mtime;
1162 	inode->i_ctime.tv_sec = stat->mtime;
1163 
1164 	inode->i_uid = v9ses->dfltuid;
1165 	inode->i_gid = v9ses->dfltgid;
1166 
1167 	if (v9fs_proto_dotu(v9ses)) {
1168 		inode->i_uid = stat->n_uid;
1169 		inode->i_gid = stat->n_gid;
1170 	}
1171 	if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1172 		if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1173 			/*
1174 			 * Hadlink support got added later to
1175 			 * to the .u extension. So there can be
1176 			 * server out there that doesn't support
1177 			 * this even with .u extension. So check
1178 			 * for non NULL stat->extension
1179 			 */
1180 			strncpy(ext, stat->extension, sizeof(ext));
1181 			/* HARDLINKCOUNT %u */
1182 			sscanf(ext, "%13s %u", tag_name, &i_nlink);
1183 			if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
1184 				set_nlink(inode, i_nlink);
1185 		}
1186 	}
1187 	mode = p9mode2perm(v9ses, stat);
1188 	mode |= inode->i_mode & ~S_IALLUGO;
1189 	inode->i_mode = mode;
1190 	i_size_write(inode, stat->length);
1191 
1192 	/* not real number of blocks, but 512 byte ones ... */
1193 	inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
1194 	v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
1195 }
1196 
1197 /**
1198  * v9fs_qid2ino - convert qid into inode number
1199  * @qid: qid to hash
1200  *
1201  * BUG: potential for inode number collisions?
1202  */
1203 
1204 ino_t v9fs_qid2ino(struct p9_qid *qid)
1205 {
1206 	u64 path = qid->path + 2;
1207 	ino_t i = 0;
1208 
1209 	if (sizeof(ino_t) == sizeof(path))
1210 		memcpy(&i, &path, sizeof(ino_t));
1211 	else
1212 		i = (ino_t) (path ^ (path >> 32));
1213 
1214 	return i;
1215 }
1216 
1217 /**
1218  * v9fs_readlink - read a symlink's location (internal version)
1219  * @dentry: dentry for symlink
1220  * @buffer: buffer to load symlink location into
1221  * @buflen: length of buffer
1222  *
1223  */
1224 
1225 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1226 {
1227 	int retval;
1228 
1229 	struct v9fs_session_info *v9ses;
1230 	struct p9_fid *fid;
1231 	struct p9_wstat *st;
1232 
1233 	p9_debug(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
1234 	retval = -EPERM;
1235 	v9ses = v9fs_dentry2v9ses(dentry);
1236 	fid = v9fs_fid_lookup(dentry);
1237 	if (IS_ERR(fid))
1238 		return PTR_ERR(fid);
1239 
1240 	if (!v9fs_proto_dotu(v9ses))
1241 		return -EBADF;
1242 
1243 	st = p9_client_stat(fid);
1244 	if (IS_ERR(st))
1245 		return PTR_ERR(st);
1246 
1247 	if (!(st->mode & P9_DMSYMLINK)) {
1248 		retval = -EINVAL;
1249 		goto done;
1250 	}
1251 
1252 	/* copy extension buffer into buffer */
1253 	strncpy(buffer, st->extension, buflen);
1254 
1255 	p9_debug(P9_DEBUG_VFS, "%s -> %s (%s)\n",
1256 		 dentry->d_name.name, st->extension, buffer);
1257 
1258 	retval = strnlen(buffer, buflen);
1259 done:
1260 	p9stat_free(st);
1261 	kfree(st);
1262 	return retval;
1263 }
1264 
1265 /**
1266  * v9fs_vfs_follow_link - follow a symlink path
1267  * @dentry: dentry for symlink
1268  * @nd: nameidata
1269  *
1270  */
1271 
1272 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1273 {
1274 	int len = 0;
1275 	char *link = __getname();
1276 
1277 	p9_debug(P9_DEBUG_VFS, "%s\n", dentry->d_name.name);
1278 
1279 	if (!link)
1280 		link = ERR_PTR(-ENOMEM);
1281 	else {
1282 		len = v9fs_readlink(dentry, link, PATH_MAX);
1283 
1284 		if (len < 0) {
1285 			__putname(link);
1286 			link = ERR_PTR(len);
1287 		} else
1288 			link[min(len, PATH_MAX-1)] = 0;
1289 	}
1290 	nd_set_link(nd, link);
1291 
1292 	return NULL;
1293 }
1294 
1295 /**
1296  * v9fs_vfs_put_link - release a symlink path
1297  * @dentry: dentry for symlink
1298  * @nd: nameidata
1299  * @p: unused
1300  *
1301  */
1302 
1303 void
1304 v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1305 {
1306 	char *s = nd_get_link(nd);
1307 
1308 	p9_debug(P9_DEBUG_VFS, " %s %s\n",
1309 		 dentry->d_name.name, IS_ERR(s) ? "<error>" : s);
1310 	if (!IS_ERR(s))
1311 		__putname(s);
1312 }
1313 
1314 /**
1315  * v9fs_vfs_mkspecial - create a special file
1316  * @dir: inode to create special file in
1317  * @dentry: dentry to create
1318  * @mode: mode to create special file
1319  * @extension: 9p2000.u format extension string representing special file
1320  *
1321  */
1322 
1323 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1324 	u32 perm, const char *extension)
1325 {
1326 	struct p9_fid *fid;
1327 	struct v9fs_session_info *v9ses;
1328 
1329 	v9ses = v9fs_inode2v9ses(dir);
1330 	if (!v9fs_proto_dotu(v9ses)) {
1331 		p9_debug(P9_DEBUG_ERROR, "not extended\n");
1332 		return -EPERM;
1333 	}
1334 
1335 	fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1336 								P9_OREAD);
1337 	if (IS_ERR(fid))
1338 		return PTR_ERR(fid);
1339 
1340 	v9fs_invalidate_inode_attr(dir);
1341 	p9_client_clunk(fid);
1342 	return 0;
1343 }
1344 
1345 /**
1346  * v9fs_vfs_symlink - helper function to create symlinks
1347  * @dir: directory inode containing symlink
1348  * @dentry: dentry for symlink
1349  * @symname: symlink data
1350  *
1351  * See Also: 9P2000.u RFC for more information
1352  *
1353  */
1354 
1355 static int
1356 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1357 {
1358 	p9_debug(P9_DEBUG_VFS, " %lu,%s,%s\n",
1359 		 dir->i_ino, dentry->d_name.name, symname);
1360 
1361 	return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
1362 }
1363 
1364 /**
1365  * v9fs_vfs_link - create a hardlink
1366  * @old_dentry: dentry for file to link to
1367  * @dir: inode destination for new link
1368  * @dentry: dentry for link
1369  *
1370  */
1371 
1372 static int
1373 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1374 	      struct dentry *dentry)
1375 {
1376 	int retval;
1377 	char *name;
1378 	struct p9_fid *oldfid;
1379 
1380 	p9_debug(P9_DEBUG_VFS, " %lu,%s,%s\n",
1381 		 dir->i_ino, dentry->d_name.name, old_dentry->d_name.name);
1382 
1383 	oldfid = v9fs_fid_clone(old_dentry);
1384 	if (IS_ERR(oldfid))
1385 		return PTR_ERR(oldfid);
1386 
1387 	name = __getname();
1388 	if (unlikely(!name)) {
1389 		retval = -ENOMEM;
1390 		goto clunk_fid;
1391 	}
1392 
1393 	sprintf(name, "%d\n", oldfid->fid);
1394 	retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1395 	__putname(name);
1396 	if (!retval) {
1397 		v9fs_refresh_inode(oldfid, old_dentry->d_inode);
1398 		v9fs_invalidate_inode_attr(dir);
1399 	}
1400 clunk_fid:
1401 	p9_client_clunk(oldfid);
1402 	return retval;
1403 }
1404 
1405 /**
1406  * v9fs_vfs_mknod - create a special file
1407  * @dir: inode destination for new link
1408  * @dentry: dentry for file
1409  * @mode: mode for creation
1410  * @rdev: device associated with special file
1411  *
1412  */
1413 
1414 static int
1415 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
1416 {
1417 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
1418 	int retval;
1419 	char *name;
1420 	u32 perm;
1421 
1422 	p9_debug(P9_DEBUG_VFS, " %lu,%s mode: %hx MAJOR: %u MINOR: %u\n",
1423 		 dir->i_ino, dentry->d_name.name, mode,
1424 		 MAJOR(rdev), MINOR(rdev));
1425 
1426 	if (!new_valid_dev(rdev))
1427 		return -EINVAL;
1428 
1429 	name = __getname();
1430 	if (!name)
1431 		return -ENOMEM;
1432 	/* build extension */
1433 	if (S_ISBLK(mode))
1434 		sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1435 	else if (S_ISCHR(mode))
1436 		sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1437 	else if (S_ISFIFO(mode))
1438 		*name = 0;
1439 	else if (S_ISSOCK(mode))
1440 		*name = 0;
1441 	else {
1442 		__putname(name);
1443 		return -EINVAL;
1444 	}
1445 
1446 	perm = unixmode2p9mode(v9ses, mode);
1447 	retval = v9fs_vfs_mkspecial(dir, dentry, perm, name);
1448 	__putname(name);
1449 
1450 	return retval;
1451 }
1452 
1453 int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
1454 {
1455 	int umode;
1456 	dev_t rdev;
1457 	loff_t i_size;
1458 	struct p9_wstat *st;
1459 	struct v9fs_session_info *v9ses;
1460 
1461 	v9ses = v9fs_inode2v9ses(inode);
1462 	st = p9_client_stat(fid);
1463 	if (IS_ERR(st))
1464 		return PTR_ERR(st);
1465 	/*
1466 	 * Don't update inode if the file type is different
1467 	 */
1468 	umode = p9mode2unixmode(v9ses, st, &rdev);
1469 	if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
1470 		goto out;
1471 
1472 	spin_lock(&inode->i_lock);
1473 	/*
1474 	 * We don't want to refresh inode->i_size,
1475 	 * because we may have cached data
1476 	 */
1477 	i_size = inode->i_size;
1478 	v9fs_stat2inode(st, inode, inode->i_sb);
1479 	if (v9ses->cache)
1480 		inode->i_size = i_size;
1481 	spin_unlock(&inode->i_lock);
1482 out:
1483 	p9stat_free(st);
1484 	kfree(st);
1485 	return 0;
1486 }
1487 
1488 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1489 	.create = v9fs_vfs_create,
1490 	.lookup = v9fs_vfs_lookup,
1491 	.symlink = v9fs_vfs_symlink,
1492 	.link = v9fs_vfs_link,
1493 	.unlink = v9fs_vfs_unlink,
1494 	.mkdir = v9fs_vfs_mkdir,
1495 	.rmdir = v9fs_vfs_rmdir,
1496 	.mknod = v9fs_vfs_mknod,
1497 	.rename = v9fs_vfs_rename,
1498 	.getattr = v9fs_vfs_getattr,
1499 	.setattr = v9fs_vfs_setattr,
1500 };
1501 
1502 static const struct inode_operations v9fs_dir_inode_operations = {
1503 	.create = v9fs_vfs_create,
1504 	.lookup = v9fs_vfs_lookup,
1505 	.unlink = v9fs_vfs_unlink,
1506 	.mkdir = v9fs_vfs_mkdir,
1507 	.rmdir = v9fs_vfs_rmdir,
1508 	.mknod = v9fs_vfs_mknod,
1509 	.rename = v9fs_vfs_rename,
1510 	.getattr = v9fs_vfs_getattr,
1511 	.setattr = v9fs_vfs_setattr,
1512 };
1513 
1514 static const struct inode_operations v9fs_file_inode_operations = {
1515 	.getattr = v9fs_vfs_getattr,
1516 	.setattr = v9fs_vfs_setattr,
1517 };
1518 
1519 static const struct inode_operations v9fs_symlink_inode_operations = {
1520 	.readlink = generic_readlink,
1521 	.follow_link = v9fs_vfs_follow_link,
1522 	.put_link = v9fs_vfs_put_link,
1523 	.getattr = v9fs_vfs_getattr,
1524 	.setattr = v9fs_vfs_setattr,
1525 };
1526 
1527