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 
unixmode2p9mode(struct v9fs_session_info * v9ses,umode_t mode)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  */
p9mode2perm(struct v9fs_session_info * v9ses,struct p9_wstat * stat)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  */
p9mode2unixmode(struct v9fs_session_info * v9ses,struct p9_wstat * stat,dev_t * rdev)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 		strlcpy(ext, stat->extension, sizeof(ext));
150 		sscanf(ext, "%c %i %i", &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 
v9fs_uflags2omode(int uflags,int extended)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 (extended) {
196 		if (uflags & O_EXCL)
197 			ret |= P9_OEXCL;
198 
199 		if (uflags & O_APPEND)
200 			ret |= P9_OAPPEND;
201 	}
202 
203 	return ret;
204 }
205 
206 /**
207  * v9fs_blank_wstat - helper function to setup a 9P stat structure
208  * @wstat: structure to initialize
209  *
210  */
211 
212 void
v9fs_blank_wstat(struct p9_wstat * wstat)213 v9fs_blank_wstat(struct p9_wstat *wstat)
214 {
215 	wstat->type = ~0;
216 	wstat->dev = ~0;
217 	wstat->qid.type = ~0;
218 	wstat->qid.version = ~0;
219 	*((long long *)&wstat->qid.path) = ~0;
220 	wstat->mode = ~0;
221 	wstat->atime = ~0;
222 	wstat->mtime = ~0;
223 	wstat->length = ~0;
224 	wstat->name = NULL;
225 	wstat->uid = NULL;
226 	wstat->gid = NULL;
227 	wstat->muid = NULL;
228 	wstat->n_uid = INVALID_UID;
229 	wstat->n_gid = INVALID_GID;
230 	wstat->n_muid = INVALID_UID;
231 	wstat->extension = NULL;
232 }
233 
234 /**
235  * v9fs_alloc_inode - helper function to allocate an inode
236  *
237  */
v9fs_alloc_inode(struct super_block * sb)238 struct inode *v9fs_alloc_inode(struct super_block *sb)
239 {
240 	struct v9fs_inode *v9inode;
241 	v9inode = (struct v9fs_inode *)kmem_cache_alloc(v9fs_inode_cache,
242 							GFP_KERNEL);
243 	if (!v9inode)
244 		return NULL;
245 #ifdef CONFIG_9P_FSCACHE
246 	v9inode->fscache = NULL;
247 	mutex_init(&v9inode->fscache_lock);
248 #endif
249 	v9inode->writeback_fid = NULL;
250 	v9inode->cache_validity = 0;
251 	mutex_init(&v9inode->v_mutex);
252 	return &v9inode->vfs_inode;
253 }
254 
255 /**
256  * v9fs_destroy_inode - destroy an inode
257  *
258  */
259 
v9fs_i_callback(struct rcu_head * head)260 static void v9fs_i_callback(struct rcu_head *head)
261 {
262 	struct inode *inode = container_of(head, struct inode, i_rcu);
263 	kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
264 }
265 
v9fs_destroy_inode(struct inode * inode)266 void v9fs_destroy_inode(struct inode *inode)
267 {
268 	call_rcu(&inode->i_rcu, v9fs_i_callback);
269 }
270 
v9fs_init_inode(struct v9fs_session_info * v9ses,struct inode * inode,umode_t mode,dev_t rdev)271 int v9fs_init_inode(struct v9fs_session_info *v9ses,
272 		    struct inode *inode, umode_t mode, dev_t rdev)
273 {
274 	int err = 0;
275 
276 	inode_init_owner(inode, NULL, mode);
277 	inode->i_blocks = 0;
278 	inode->i_rdev = rdev;
279 	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
280 	inode->i_mapping->a_ops = &v9fs_addr_operations;
281 
282 	switch (mode & S_IFMT) {
283 	case S_IFIFO:
284 	case S_IFBLK:
285 	case S_IFCHR:
286 	case S_IFSOCK:
287 		if (v9fs_proto_dotl(v9ses)) {
288 			inode->i_op = &v9fs_file_inode_operations_dotl;
289 		} else if (v9fs_proto_dotu(v9ses)) {
290 			inode->i_op = &v9fs_file_inode_operations;
291 		} else {
292 			p9_debug(P9_DEBUG_ERROR,
293 				 "special files without extended mode\n");
294 			err = -EINVAL;
295 			goto error;
296 		}
297 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
298 		break;
299 	case S_IFREG:
300 		if (v9fs_proto_dotl(v9ses)) {
301 			inode->i_op = &v9fs_file_inode_operations_dotl;
302 			if (v9ses->cache == CACHE_LOOSE ||
303 			    v9ses->cache == CACHE_FSCACHE)
304 				inode->i_fop =
305 					&v9fs_cached_file_operations_dotl;
306 			else if (v9ses->cache == CACHE_MMAP)
307 				inode->i_fop = &v9fs_mmap_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 == CACHE_LOOSE ||
313 			    v9ses->cache == CACHE_FSCACHE)
314 				inode->i_fop =
315 					&v9fs_cached_file_operations;
316 			else if (v9ses->cache == CACHE_MMAP)
317 				inode->i_fop = &v9fs_mmap_file_operations;
318 			else
319 				inode->i_fop = &v9fs_file_operations;
320 		}
321 
322 		break;
323 	case S_IFLNK:
324 		if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
325 			p9_debug(P9_DEBUG_ERROR,
326 				 "extended modes used with legacy protocol\n");
327 			err = -EINVAL;
328 			goto error;
329 		}
330 
331 		if (v9fs_proto_dotl(v9ses))
332 			inode->i_op = &v9fs_symlink_inode_operations_dotl;
333 		else
334 			inode->i_op = &v9fs_symlink_inode_operations;
335 
336 		break;
337 	case S_IFDIR:
338 		inc_nlink(inode);
339 		if (v9fs_proto_dotl(v9ses))
340 			inode->i_op = &v9fs_dir_inode_operations_dotl;
341 		else if (v9fs_proto_dotu(v9ses))
342 			inode->i_op = &v9fs_dir_inode_operations_dotu;
343 		else
344 			inode->i_op = &v9fs_dir_inode_operations;
345 
346 		if (v9fs_proto_dotl(v9ses))
347 			inode->i_fop = &v9fs_dir_operations_dotl;
348 		else
349 			inode->i_fop = &v9fs_dir_operations;
350 
351 		break;
352 	default:
353 		p9_debug(P9_DEBUG_ERROR, "BAD mode 0x%hx S_IFMT 0x%x\n",
354 			 mode, mode & S_IFMT);
355 		err = -EINVAL;
356 		goto error;
357 	}
358 error:
359 	return err;
360 
361 }
362 
363 /**
364  * v9fs_get_inode - helper function to setup an inode
365  * @sb: superblock
366  * @mode: mode to setup inode with
367  *
368  */
369 
v9fs_get_inode(struct super_block * sb,umode_t mode,dev_t rdev)370 struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t rdev)
371 {
372 	int err;
373 	struct inode *inode;
374 	struct v9fs_session_info *v9ses = sb->s_fs_info;
375 
376 	p9_debug(P9_DEBUG_VFS, "super block: %p mode: %ho\n", sb, mode);
377 
378 	inode = new_inode(sb);
379 	if (!inode) {
380 		pr_warn("%s (%d): Problem allocating inode\n",
381 			__func__, task_pid_nr(current));
382 		return ERR_PTR(-ENOMEM);
383 	}
384 	err = v9fs_init_inode(v9ses, inode, mode, rdev);
385 	if (err) {
386 		iput(inode);
387 		return ERR_PTR(err);
388 	}
389 	return inode;
390 }
391 
392 /*
393 static struct v9fs_fid*
394 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
395 {
396 	int err;
397 	int nfid;
398 	struct v9fs_fid *ret;
399 	struct v9fs_fcall *fcall;
400 
401 	nfid = v9fs_get_idpool(&v9ses->fidpool);
402 	if (nfid < 0) {
403 		eprintk(KERN_WARNING, "no free fids available\n");
404 		return ERR_PTR(-ENOSPC);
405 	}
406 
407 	err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
408 		&fcall);
409 
410 	if (err < 0) {
411 		if (fcall && fcall->id == RWALK)
412 			goto clunk_fid;
413 
414 		PRINT_FCALL_ERROR("walk error", fcall);
415 		v9fs_put_idpool(nfid, &v9ses->fidpool);
416 		goto error;
417 	}
418 
419 	kfree(fcall);
420 	fcall = NULL;
421 	ret = v9fs_fid_create(v9ses, nfid);
422 	if (!ret) {
423 		err = -ENOMEM;
424 		goto clunk_fid;
425 	}
426 
427 	err = v9fs_fid_insert(ret, dentry);
428 	if (err < 0) {
429 		v9fs_fid_destroy(ret);
430 		goto clunk_fid;
431 	}
432 
433 	return ret;
434 
435 clunk_fid:
436 	v9fs_t_clunk(v9ses, nfid);
437 
438 error:
439 	kfree(fcall);
440 	return ERR_PTR(err);
441 }
442 */
443 
444 
445 /**
446  * v9fs_clear_inode - release an inode
447  * @inode: inode to release
448  *
449  */
v9fs_evict_inode(struct inode * inode)450 void v9fs_evict_inode(struct inode *inode)
451 {
452 	struct v9fs_inode *v9inode = V9FS_I(inode);
453 
454 	truncate_inode_pages_final(&inode->i_data);
455 	clear_inode(inode);
456 	filemap_fdatawrite(&inode->i_data);
457 
458 	v9fs_cache_inode_put_cookie(inode);
459 	/* clunk the fid stashed in writeback_fid */
460 	if (v9inode->writeback_fid) {
461 		p9_client_clunk(v9inode->writeback_fid);
462 		v9inode->writeback_fid = NULL;
463 	}
464 }
465 
v9fs_test_inode(struct inode * inode,void * data)466 static int v9fs_test_inode(struct inode *inode, void *data)
467 {
468 	int umode;
469 	dev_t rdev;
470 	struct v9fs_inode *v9inode = V9FS_I(inode);
471 	struct p9_wstat *st = (struct p9_wstat *)data;
472 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
473 
474 	umode = p9mode2unixmode(v9ses, st, &rdev);
475 	/* don't match inode of different type */
476 	if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
477 		return 0;
478 
479 	/* compare qid details */
480 	if (memcmp(&v9inode->qid.version,
481 		   &st->qid.version, sizeof(v9inode->qid.version)))
482 		return 0;
483 
484 	if (v9inode->qid.type != st->qid.type)
485 		return 0;
486 
487 	if (v9inode->qid.path != st->qid.path)
488 		return 0;
489 	return 1;
490 }
491 
v9fs_test_new_inode(struct inode * inode,void * data)492 static int v9fs_test_new_inode(struct inode *inode, void *data)
493 {
494 	return 0;
495 }
496 
v9fs_set_inode(struct inode * inode,void * data)497 static int v9fs_set_inode(struct inode *inode,  void *data)
498 {
499 	struct v9fs_inode *v9inode = V9FS_I(inode);
500 	struct p9_wstat *st = (struct p9_wstat *)data;
501 
502 	memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
503 	return 0;
504 }
505 
v9fs_qid_iget(struct super_block * sb,struct p9_qid * qid,struct p9_wstat * st,int new)506 static struct inode *v9fs_qid_iget(struct super_block *sb,
507 				   struct p9_qid *qid,
508 				   struct p9_wstat *st,
509 				   int new)
510 {
511 	dev_t rdev;
512 	int retval;
513 	umode_t umode;
514 	unsigned long i_ino;
515 	struct inode *inode;
516 	struct v9fs_session_info *v9ses = sb->s_fs_info;
517 	int (*test)(struct inode *, void *);
518 
519 	if (new)
520 		test = v9fs_test_new_inode;
521 	else
522 		test = v9fs_test_inode;
523 
524 	i_ino = v9fs_qid2ino(qid);
525 	inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
526 	if (!inode)
527 		return ERR_PTR(-ENOMEM);
528 	if (!(inode->i_state & I_NEW))
529 		return inode;
530 	/*
531 	 * initialize the inode with the stat info
532 	 * FIXME!! we may need support for stale inodes
533 	 * later.
534 	 */
535 	inode->i_ino = i_ino;
536 	umode = p9mode2unixmode(v9ses, st, &rdev);
537 	retval = v9fs_init_inode(v9ses, inode, umode, rdev);
538 	if (retval)
539 		goto error;
540 
541 	v9fs_stat2inode(st, inode, sb, 0);
542 	v9fs_cache_inode_get_cookie(inode);
543 	unlock_new_inode(inode);
544 	return inode;
545 error:
546 	iget_failed(inode);
547 	return ERR_PTR(retval);
548 
549 }
550 
551 struct inode *
v9fs_inode_from_fid(struct v9fs_session_info * v9ses,struct p9_fid * fid,struct super_block * sb,int new)552 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
553 		    struct super_block *sb, int new)
554 {
555 	struct p9_wstat *st;
556 	struct inode *inode = NULL;
557 
558 	st = p9_client_stat(fid);
559 	if (IS_ERR(st))
560 		return ERR_CAST(st);
561 
562 	inode = v9fs_qid_iget(sb, &st->qid, st, new);
563 	p9stat_free(st);
564 	kfree(st);
565 	return inode;
566 }
567 
568 /**
569  * v9fs_at_to_dotl_flags- convert Linux specific AT flags to
570  * plan 9 AT flag.
571  * @flags: flags to convert
572  */
v9fs_at_to_dotl_flags(int flags)573 static int v9fs_at_to_dotl_flags(int flags)
574 {
575 	int rflags = 0;
576 	if (flags & AT_REMOVEDIR)
577 		rflags |= P9_DOTL_AT_REMOVEDIR;
578 	return rflags;
579 }
580 
581 /**
582  * v9fs_dec_count - helper functon to drop i_nlink.
583  *
584  * If a directory had nlink <= 2 (including . and ..), then we should not drop
585  * the link count, which indicates the underlying exported fs doesn't maintain
586  * nlink accurately. e.g.
587  * - overlayfs sets nlink to 1 for merged dir
588  * - ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has more
589  *   than EXT4_LINK_MAX (65000) links.
590  *
591  * @inode: inode whose nlink is being dropped
592  */
v9fs_dec_count(struct inode * inode)593 static void v9fs_dec_count(struct inode *inode)
594 {
595 	if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
596 		drop_nlink(inode);
597 }
598 
599 /**
600  * v9fs_remove - helper function to remove files and directories
601  * @dir: directory inode that is being deleted
602  * @dentry:  dentry that is being deleted
603  * @flags: removing a directory
604  *
605  */
606 
v9fs_remove(struct inode * dir,struct dentry * dentry,int flags)607 static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
608 {
609 	struct inode *inode;
610 	int retval = -EOPNOTSUPP;
611 	struct p9_fid *v9fid, *dfid;
612 	struct v9fs_session_info *v9ses;
613 
614 	p9_debug(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
615 		 dir, dentry, flags);
616 
617 	v9ses = v9fs_inode2v9ses(dir);
618 	inode = d_inode(dentry);
619 	dfid = v9fs_parent_fid(dentry);
620 	if (IS_ERR(dfid)) {
621 		retval = PTR_ERR(dfid);
622 		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
623 		return retval;
624 	}
625 	if (v9fs_proto_dotl(v9ses))
626 		retval = p9_client_unlinkat(dfid, dentry->d_name.name,
627 					    v9fs_at_to_dotl_flags(flags));
628 	if (retval == -EOPNOTSUPP) {
629 		/* Try the one based on path */
630 		v9fid = v9fs_fid_clone(dentry);
631 		if (IS_ERR(v9fid))
632 			return PTR_ERR(v9fid);
633 		retval = p9_client_remove(v9fid);
634 	}
635 	if (!retval) {
636 		/*
637 		 * directories on unlink should have zero
638 		 * link count
639 		 */
640 		if (flags & AT_REMOVEDIR) {
641 			clear_nlink(inode);
642 			v9fs_dec_count(dir);
643 		} else
644 			v9fs_dec_count(inode);
645 
646 		v9fs_invalidate_inode_attr(inode);
647 		v9fs_invalidate_inode_attr(dir);
648 	}
649 	return retval;
650 }
651 
652 /**
653  * v9fs_create - Create a file
654  * @v9ses: session information
655  * @dir: directory that dentry is being created in
656  * @dentry:  dentry that is being created
657  * @extension: 9p2000.u extension string to support devices, etc.
658  * @perm: create permissions
659  * @mode: open mode
660  *
661  */
662 static struct p9_fid *
v9fs_create(struct v9fs_session_info * v9ses,struct inode * dir,struct dentry * dentry,char * extension,u32 perm,u8 mode)663 v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
664 		struct dentry *dentry, char *extension, u32 perm, u8 mode)
665 {
666 	int err;
667 	const unsigned char *name;
668 	struct p9_fid *dfid, *ofid, *fid;
669 	struct inode *inode;
670 
671 	p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
672 
673 	err = 0;
674 	ofid = NULL;
675 	fid = NULL;
676 	name = dentry->d_name.name;
677 	dfid = v9fs_parent_fid(dentry);
678 	if (IS_ERR(dfid)) {
679 		err = PTR_ERR(dfid);
680 		p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
681 		return ERR_PTR(err);
682 	}
683 
684 	/* clone a fid to use for creation */
685 	ofid = clone_fid(dfid);
686 	if (IS_ERR(ofid)) {
687 		err = PTR_ERR(ofid);
688 		p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
689 		return ERR_PTR(err);
690 	}
691 
692 	err = p9_client_fcreate(ofid, name, perm, mode, extension);
693 	if (err < 0) {
694 		p9_debug(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
695 		goto error;
696 	}
697 
698 	if (!(perm & P9_DMLINK)) {
699 		/* now walk from the parent so we can get unopened fid */
700 		fid = p9_client_walk(dfid, 1, &name, 1);
701 		if (IS_ERR(fid)) {
702 			err = PTR_ERR(fid);
703 			p9_debug(P9_DEBUG_VFS,
704 				   "p9_client_walk failed %d\n", err);
705 			fid = NULL;
706 			goto error;
707 		}
708 		/*
709 		 * instantiate inode and assign the unopened fid to the dentry
710 		 */
711 		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
712 		if (IS_ERR(inode)) {
713 			err = PTR_ERR(inode);
714 			p9_debug(P9_DEBUG_VFS,
715 				   "inode creation failed %d\n", err);
716 			goto error;
717 		}
718 		v9fs_fid_add(dentry, fid);
719 		d_instantiate(dentry, inode);
720 	}
721 	return ofid;
722 error:
723 	if (ofid)
724 		p9_client_clunk(ofid);
725 
726 	if (fid)
727 		p9_client_clunk(fid);
728 
729 	return ERR_PTR(err);
730 }
731 
732 /**
733  * v9fs_vfs_create - VFS hook to create a regular file
734  *
735  * open(.., O_CREAT) is handled in v9fs_vfs_atomic_open().  This is only called
736  * for mknod(2).
737  *
738  * @dir: directory inode that is being created
739  * @dentry:  dentry that is being deleted
740  * @mode: create permissions
741  *
742  */
743 
744 static int
v9fs_vfs_create(struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)745 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
746 		bool excl)
747 {
748 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
749 	u32 perm = unixmode2p9mode(v9ses, mode);
750 	struct p9_fid *fid;
751 
752 	/* P9_OEXCL? */
753 	fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_ORDWR);
754 	if (IS_ERR(fid))
755 		return PTR_ERR(fid);
756 
757 	v9fs_invalidate_inode_attr(dir);
758 	p9_client_clunk(fid);
759 
760 	return 0;
761 }
762 
763 /**
764  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
765  * @dir:  inode that is being unlinked
766  * @dentry: dentry that is being unlinked
767  * @mode: mode for new directory
768  *
769  */
770 
v9fs_vfs_mkdir(struct inode * dir,struct dentry * dentry,umode_t mode)771 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
772 {
773 	int err;
774 	u32 perm;
775 	struct p9_fid *fid;
776 	struct v9fs_session_info *v9ses;
777 
778 	p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
779 	err = 0;
780 	v9ses = v9fs_inode2v9ses(dir);
781 	perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
782 	fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
783 	if (IS_ERR(fid)) {
784 		err = PTR_ERR(fid);
785 		fid = NULL;
786 	} else {
787 		inc_nlink(dir);
788 		v9fs_invalidate_inode_attr(dir);
789 	}
790 
791 	if (fid)
792 		p9_client_clunk(fid);
793 
794 	return err;
795 }
796 
797 /**
798  * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
799  * @dir:  inode that is being walked from
800  * @dentry: dentry that is being walked to?
801  * @flags: lookup flags (unused)
802  *
803  */
804 
v9fs_vfs_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)805 struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
806 				      unsigned int flags)
807 {
808 	struct dentry *res;
809 	struct v9fs_session_info *v9ses;
810 	struct p9_fid *dfid, *fid;
811 	struct inode *inode;
812 	const unsigned char *name;
813 
814 	p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%pd) %p flags: %x\n",
815 		 dir, dentry, dentry, flags);
816 
817 	if (dentry->d_name.len > NAME_MAX)
818 		return ERR_PTR(-ENAMETOOLONG);
819 
820 	v9ses = v9fs_inode2v9ses(dir);
821 	/* We can walk d_parent because we hold the dir->i_mutex */
822 	dfid = v9fs_parent_fid(dentry);
823 	if (IS_ERR(dfid))
824 		return ERR_CAST(dfid);
825 
826 	/*
827 	 * Make sure we don't use a wrong inode due to parallel
828 	 * unlink. For cached mode create calls request for new
829 	 * inode. But with cache disabled, lookup should do this.
830 	 */
831 	name = dentry->d_name.name;
832 	fid = p9_client_walk(dfid, 1, &name, 1);
833 	if (fid == ERR_PTR(-ENOENT))
834 		inode = NULL;
835 	else if (IS_ERR(fid))
836 		inode = ERR_CAST(fid);
837 	else if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
838 		inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
839 	else
840 		inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
841 	/*
842 	 * If we had a rename on the server and a parallel lookup
843 	 * for the new name, then make sure we instantiate with
844 	 * the new name. ie look up for a/b, while on server somebody
845 	 * moved b under k and client parallely did a lookup for
846 	 * k/b.
847 	 */
848 	res = d_splice_alias(inode, dentry);
849 	if (!IS_ERR(fid)) {
850 		if (!res)
851 			v9fs_fid_add(dentry, fid);
852 		else if (!IS_ERR(res))
853 			v9fs_fid_add(res, fid);
854 		else
855 			p9_client_clunk(fid);
856 	}
857 	return res;
858 }
859 
860 static int
v9fs_vfs_atomic_open(struct inode * dir,struct dentry * dentry,struct file * file,unsigned flags,umode_t mode)861 v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
862 		     struct file *file, unsigned flags, umode_t mode)
863 {
864 	int err;
865 	u32 perm;
866 	struct v9fs_inode *v9inode;
867 	struct v9fs_session_info *v9ses;
868 	struct p9_fid *fid, *inode_fid;
869 	struct dentry *res = NULL;
870 
871 	if (d_in_lookup(dentry)) {
872 		res = v9fs_vfs_lookup(dir, dentry, 0);
873 		if (IS_ERR(res))
874 			return PTR_ERR(res);
875 
876 		if (res)
877 			dentry = res;
878 	}
879 
880 	/* Only creates */
881 	if (!(flags & O_CREAT) || d_really_is_positive(dentry))
882 		return finish_no_open(file, res);
883 
884 	err = 0;
885 
886 	v9ses = v9fs_inode2v9ses(dir);
887 	perm = unixmode2p9mode(v9ses, mode);
888 	fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
889 				v9fs_uflags2omode(flags,
890 						v9fs_proto_dotu(v9ses)));
891 	if (IS_ERR(fid)) {
892 		err = PTR_ERR(fid);
893 		fid = NULL;
894 		goto error;
895 	}
896 
897 	v9fs_invalidate_inode_attr(dir);
898 	v9inode = V9FS_I(d_inode(dentry));
899 	mutex_lock(&v9inode->v_mutex);
900 	if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
901 	    !v9inode->writeback_fid &&
902 	    ((flags & O_ACCMODE) != O_RDONLY)) {
903 		/*
904 		 * clone a fid and add it to writeback_fid
905 		 * we do it during open time instead of
906 		 * page dirty time via write_begin/page_mkwrite
907 		 * because we want write after unlink usecase
908 		 * to work.
909 		 */
910 		inode_fid = v9fs_writeback_fid(dentry);
911 		if (IS_ERR(inode_fid)) {
912 			err = PTR_ERR(inode_fid);
913 			mutex_unlock(&v9inode->v_mutex);
914 			goto error;
915 		}
916 		v9inode->writeback_fid = (void *) inode_fid;
917 	}
918 	mutex_unlock(&v9inode->v_mutex);
919 	err = finish_open(file, dentry, generic_file_open);
920 	if (err)
921 		goto error;
922 
923 	file->private_data = fid;
924 	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
925 		v9fs_cache_inode_set_cookie(d_inode(dentry), file);
926 
927 	file->f_mode |= FMODE_CREATED;
928 out:
929 	dput(res);
930 	return err;
931 
932 error:
933 	if (fid)
934 		p9_client_clunk(fid);
935 	goto out;
936 }
937 
938 /**
939  * v9fs_vfs_unlink - VFS unlink hook to delete an inode
940  * @i:  inode that is being unlinked
941  * @d: dentry that is being unlinked
942  *
943  */
944 
v9fs_vfs_unlink(struct inode * i,struct dentry * d)945 int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
946 {
947 	return v9fs_remove(i, d, 0);
948 }
949 
950 /**
951  * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
952  * @i:  inode that is being unlinked
953  * @d: dentry that is being unlinked
954  *
955  */
956 
v9fs_vfs_rmdir(struct inode * i,struct dentry * d)957 int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
958 {
959 	return v9fs_remove(i, d, AT_REMOVEDIR);
960 }
961 
962 /**
963  * v9fs_vfs_rename - VFS hook to rename an inode
964  * @old_dir:  old dir inode
965  * @old_dentry: old dentry
966  * @new_dir: new dir inode
967  * @new_dentry: new dentry
968  *
969  */
970 
971 int
v9fs_vfs_rename(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)972 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
973 		struct inode *new_dir, struct dentry *new_dentry,
974 		unsigned int flags)
975 {
976 	int retval;
977 	struct inode *old_inode;
978 	struct inode *new_inode;
979 	struct v9fs_session_info *v9ses;
980 	struct p9_fid *oldfid;
981 	struct p9_fid *olddirfid;
982 	struct p9_fid *newdirfid;
983 	struct p9_wstat wstat;
984 
985 	if (flags)
986 		return -EINVAL;
987 
988 	p9_debug(P9_DEBUG_VFS, "\n");
989 	retval = 0;
990 	old_inode = d_inode(old_dentry);
991 	new_inode = d_inode(new_dentry);
992 	v9ses = v9fs_inode2v9ses(old_inode);
993 	oldfid = v9fs_fid_lookup(old_dentry);
994 	if (IS_ERR(oldfid))
995 		return PTR_ERR(oldfid);
996 
997 	olddirfid = clone_fid(v9fs_parent_fid(old_dentry));
998 	if (IS_ERR(olddirfid)) {
999 		retval = PTR_ERR(olddirfid);
1000 		goto done;
1001 	}
1002 
1003 	newdirfid = clone_fid(v9fs_parent_fid(new_dentry));
1004 	if (IS_ERR(newdirfid)) {
1005 		retval = PTR_ERR(newdirfid);
1006 		goto clunk_olddir;
1007 	}
1008 
1009 	down_write(&v9ses->rename_sem);
1010 	if (v9fs_proto_dotl(v9ses)) {
1011 		retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
1012 					    newdirfid, new_dentry->d_name.name);
1013 		if (retval == -EOPNOTSUPP)
1014 			retval = p9_client_rename(oldfid, newdirfid,
1015 						  new_dentry->d_name.name);
1016 		if (retval != -EOPNOTSUPP)
1017 			goto clunk_newdir;
1018 	}
1019 	if (old_dentry->d_parent != new_dentry->d_parent) {
1020 		/*
1021 		 * 9P .u can only handle file rename in the same directory
1022 		 */
1023 
1024 		p9_debug(P9_DEBUG_ERROR, "old dir and new dir are different\n");
1025 		retval = -EXDEV;
1026 		goto clunk_newdir;
1027 	}
1028 	v9fs_blank_wstat(&wstat);
1029 	wstat.muid = v9ses->uname;
1030 	wstat.name = new_dentry->d_name.name;
1031 	retval = p9_client_wstat(oldfid, &wstat);
1032 
1033 clunk_newdir:
1034 	if (!retval) {
1035 		if (new_inode) {
1036 			if (S_ISDIR(new_inode->i_mode))
1037 				clear_nlink(new_inode);
1038 			else
1039 				v9fs_dec_count(new_inode);
1040 		}
1041 		if (S_ISDIR(old_inode->i_mode)) {
1042 			if (!new_inode)
1043 				inc_nlink(new_dir);
1044 			v9fs_dec_count(old_dir);
1045 		}
1046 		v9fs_invalidate_inode_attr(old_inode);
1047 		v9fs_invalidate_inode_attr(old_dir);
1048 		v9fs_invalidate_inode_attr(new_dir);
1049 
1050 		/* successful rename */
1051 		d_move(old_dentry, new_dentry);
1052 	}
1053 	up_write(&v9ses->rename_sem);
1054 	p9_client_clunk(newdirfid);
1055 
1056 clunk_olddir:
1057 	p9_client_clunk(olddirfid);
1058 
1059 done:
1060 	return retval;
1061 }
1062 
1063 /**
1064  * v9fs_vfs_getattr - retrieve file metadata
1065  * @path: Object to query
1066  * @stat: metadata structure to populate
1067  * @request_mask: Mask of STATX_xxx flags indicating the caller's interests
1068  * @flags: AT_STATX_xxx setting
1069  *
1070  */
1071 
1072 static int
v9fs_vfs_getattr(const struct path * path,struct kstat * stat,u32 request_mask,unsigned int flags)1073 v9fs_vfs_getattr(const struct path *path, struct kstat *stat,
1074 		 u32 request_mask, unsigned int flags)
1075 {
1076 	struct dentry *dentry = path->dentry;
1077 	struct v9fs_session_info *v9ses;
1078 	struct p9_fid *fid;
1079 	struct p9_wstat *st;
1080 
1081 	p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1082 	v9ses = v9fs_dentry2v9ses(dentry);
1083 	if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1084 		generic_fillattr(d_inode(dentry), stat);
1085 		return 0;
1086 	}
1087 	fid = v9fs_fid_lookup(dentry);
1088 	if (IS_ERR(fid))
1089 		return PTR_ERR(fid);
1090 
1091 	st = p9_client_stat(fid);
1092 	if (IS_ERR(st))
1093 		return PTR_ERR(st);
1094 
1095 	v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
1096 	generic_fillattr(d_inode(dentry), stat);
1097 
1098 	p9stat_free(st);
1099 	kfree(st);
1100 	return 0;
1101 }
1102 
1103 /**
1104  * v9fs_vfs_setattr - set file metadata
1105  * @dentry: file whose metadata to set
1106  * @iattr: metadata assignment structure
1107  *
1108  */
1109 
v9fs_vfs_setattr(struct dentry * dentry,struct iattr * iattr)1110 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
1111 {
1112 	int retval;
1113 	struct v9fs_session_info *v9ses;
1114 	struct p9_fid *fid;
1115 	struct p9_wstat wstat;
1116 
1117 	p9_debug(P9_DEBUG_VFS, "\n");
1118 	retval = setattr_prepare(dentry, iattr);
1119 	if (retval)
1120 		return retval;
1121 
1122 	retval = -EPERM;
1123 	v9ses = v9fs_dentry2v9ses(dentry);
1124 	fid = v9fs_fid_lookup(dentry);
1125 	if(IS_ERR(fid))
1126 		return PTR_ERR(fid);
1127 
1128 	v9fs_blank_wstat(&wstat);
1129 	if (iattr->ia_valid & ATTR_MODE)
1130 		wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
1131 
1132 	if (iattr->ia_valid & ATTR_MTIME)
1133 		wstat.mtime = iattr->ia_mtime.tv_sec;
1134 
1135 	if (iattr->ia_valid & ATTR_ATIME)
1136 		wstat.atime = iattr->ia_atime.tv_sec;
1137 
1138 	if (iattr->ia_valid & ATTR_SIZE)
1139 		wstat.length = iattr->ia_size;
1140 
1141 	if (v9fs_proto_dotu(v9ses)) {
1142 		if (iattr->ia_valid & ATTR_UID)
1143 			wstat.n_uid = iattr->ia_uid;
1144 
1145 		if (iattr->ia_valid & ATTR_GID)
1146 			wstat.n_gid = iattr->ia_gid;
1147 	}
1148 
1149 	/* Write all dirty data */
1150 	if (d_is_reg(dentry))
1151 		filemap_write_and_wait(d_inode(dentry)->i_mapping);
1152 
1153 	retval = p9_client_wstat(fid, &wstat);
1154 	if (retval < 0)
1155 		return retval;
1156 
1157 	if ((iattr->ia_valid & ATTR_SIZE) &&
1158 	    iattr->ia_size != i_size_read(d_inode(dentry)))
1159 		truncate_setsize(d_inode(dentry), iattr->ia_size);
1160 
1161 	v9fs_invalidate_inode_attr(d_inode(dentry));
1162 
1163 	setattr_copy(d_inode(dentry), iattr);
1164 	mark_inode_dirty(d_inode(dentry));
1165 	return 0;
1166 }
1167 
1168 /**
1169  * v9fs_stat2inode - populate an inode structure with mistat info
1170  * @stat: Plan 9 metadata (mistat) structure
1171  * @inode: inode to populate
1172  * @sb: superblock of filesystem
1173  * @flags: control flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
1174  *
1175  */
1176 
1177 void
v9fs_stat2inode(struct p9_wstat * stat,struct inode * inode,struct super_block * sb,unsigned int flags)1178 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
1179 		 struct super_block *sb, unsigned int flags)
1180 {
1181 	umode_t mode;
1182 	char ext[32];
1183 	char tag_name[14];
1184 	unsigned int i_nlink;
1185 	struct v9fs_session_info *v9ses = sb->s_fs_info;
1186 	struct v9fs_inode *v9inode = V9FS_I(inode);
1187 
1188 	set_nlink(inode, 1);
1189 
1190 	inode->i_atime.tv_sec = stat->atime;
1191 	inode->i_mtime.tv_sec = stat->mtime;
1192 	inode->i_ctime.tv_sec = stat->mtime;
1193 
1194 	inode->i_uid = v9ses->dfltuid;
1195 	inode->i_gid = v9ses->dfltgid;
1196 
1197 	if (v9fs_proto_dotu(v9ses)) {
1198 		inode->i_uid = stat->n_uid;
1199 		inode->i_gid = stat->n_gid;
1200 	}
1201 	if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1202 		if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1203 			/*
1204 			 * Hadlink support got added later to
1205 			 * to the .u extension. So there can be
1206 			 * server out there that doesn't support
1207 			 * this even with .u extension. So check
1208 			 * for non NULL stat->extension
1209 			 */
1210 			strlcpy(ext, stat->extension, sizeof(ext));
1211 			/* HARDLINKCOUNT %u */
1212 			sscanf(ext, "%13s %u", tag_name, &i_nlink);
1213 			if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
1214 				set_nlink(inode, i_nlink);
1215 		}
1216 	}
1217 	mode = p9mode2perm(v9ses, stat);
1218 	mode |= inode->i_mode & ~S_IALLUGO;
1219 	inode->i_mode = mode;
1220 
1221 	if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
1222 		v9fs_i_size_write(inode, stat->length);
1223 	/* not real number of blocks, but 512 byte ones ... */
1224 	inode->i_blocks = (stat->length + 512 - 1) >> 9;
1225 	v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
1226 }
1227 
1228 /**
1229  * v9fs_qid2ino - convert qid into inode number
1230  * @qid: qid to hash
1231  *
1232  * BUG: potential for inode number collisions?
1233  */
1234 
v9fs_qid2ino(struct p9_qid * qid)1235 ino_t v9fs_qid2ino(struct p9_qid *qid)
1236 {
1237 	u64 path = qid->path + 2;
1238 	ino_t i = 0;
1239 
1240 	if (sizeof(ino_t) == sizeof(path))
1241 		memcpy(&i, &path, sizeof(ino_t));
1242 	else
1243 		i = (ino_t) (path ^ (path >> 32));
1244 
1245 	return i;
1246 }
1247 
1248 /**
1249  * v9fs_vfs_get_link - follow a symlink path
1250  * @dentry: dentry for symlink
1251  * @inode: inode for symlink
1252  * @done: delayed call for when we are done with the return value
1253  */
1254 
v9fs_vfs_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)1255 static const char *v9fs_vfs_get_link(struct dentry *dentry,
1256 				     struct inode *inode,
1257 				     struct delayed_call *done)
1258 {
1259 	struct v9fs_session_info *v9ses;
1260 	struct p9_fid *fid;
1261 	struct p9_wstat *st;
1262 	char *res;
1263 
1264 	if (!dentry)
1265 		return ERR_PTR(-ECHILD);
1266 
1267 	v9ses = v9fs_dentry2v9ses(dentry);
1268 	fid = v9fs_fid_lookup(dentry);
1269 	p9_debug(P9_DEBUG_VFS, "%pd\n", dentry);
1270 
1271 	if (IS_ERR(fid))
1272 		return ERR_CAST(fid);
1273 
1274 	if (!v9fs_proto_dotu(v9ses))
1275 		return ERR_PTR(-EBADF);
1276 
1277 	st = p9_client_stat(fid);
1278 	if (IS_ERR(st))
1279 		return ERR_CAST(st);
1280 
1281 	if (!(st->mode & P9_DMSYMLINK)) {
1282 		p9stat_free(st);
1283 		kfree(st);
1284 		return ERR_PTR(-EINVAL);
1285 	}
1286 	res = st->extension;
1287 	st->extension = NULL;
1288 	if (strlen(res) >= PATH_MAX)
1289 		res[PATH_MAX - 1] = '\0';
1290 
1291 	p9stat_free(st);
1292 	kfree(st);
1293 	set_delayed_call(done, kfree_link, res);
1294 	return res;
1295 }
1296 
1297 /**
1298  * v9fs_vfs_mkspecial - create a special file
1299  * @dir: inode to create special file in
1300  * @dentry: dentry to create
1301  * @perm: mode to create special file
1302  * @extension: 9p2000.u format extension string representing special file
1303  *
1304  */
1305 
v9fs_vfs_mkspecial(struct inode * dir,struct dentry * dentry,u32 perm,const char * extension)1306 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1307 	u32 perm, const char *extension)
1308 {
1309 	struct p9_fid *fid;
1310 	struct v9fs_session_info *v9ses;
1311 
1312 	v9ses = v9fs_inode2v9ses(dir);
1313 	if (!v9fs_proto_dotu(v9ses)) {
1314 		p9_debug(P9_DEBUG_ERROR, "not extended\n");
1315 		return -EPERM;
1316 	}
1317 
1318 	fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1319 								P9_OREAD);
1320 	if (IS_ERR(fid))
1321 		return PTR_ERR(fid);
1322 
1323 	v9fs_invalidate_inode_attr(dir);
1324 	p9_client_clunk(fid);
1325 	return 0;
1326 }
1327 
1328 /**
1329  * v9fs_vfs_symlink - helper function to create symlinks
1330  * @dir: directory inode containing symlink
1331  * @dentry: dentry for symlink
1332  * @symname: symlink data
1333  *
1334  * See Also: 9P2000.u RFC for more information
1335  *
1336  */
1337 
1338 static int
v9fs_vfs_symlink(struct inode * dir,struct dentry * dentry,const char * symname)1339 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1340 {
1341 	p9_debug(P9_DEBUG_VFS, " %lu,%pd,%s\n",
1342 		 dir->i_ino, dentry, symname);
1343 
1344 	return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
1345 }
1346 
1347 #define U32_MAX_DIGITS 10
1348 
1349 /**
1350  * v9fs_vfs_link - create a hardlink
1351  * @old_dentry: dentry for file to link to
1352  * @dir: inode destination for new link
1353  * @dentry: dentry for link
1354  *
1355  */
1356 
1357 static int
v9fs_vfs_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)1358 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1359 	      struct dentry *dentry)
1360 {
1361 	int retval;
1362 	char name[1 + U32_MAX_DIGITS + 2]; /* sign + number + \n + \0 */
1363 	struct p9_fid *oldfid;
1364 
1365 	p9_debug(P9_DEBUG_VFS, " %lu,%pd,%pd\n",
1366 		 dir->i_ino, dentry, old_dentry);
1367 
1368 	oldfid = v9fs_fid_clone(old_dentry);
1369 	if (IS_ERR(oldfid))
1370 		return PTR_ERR(oldfid);
1371 
1372 	sprintf(name, "%d\n", oldfid->fid);
1373 	retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1374 	if (!retval) {
1375 		v9fs_refresh_inode(oldfid, d_inode(old_dentry));
1376 		v9fs_invalidate_inode_attr(dir);
1377 	}
1378 	p9_client_clunk(oldfid);
1379 	return retval;
1380 }
1381 
1382 /**
1383  * v9fs_vfs_mknod - create a special file
1384  * @dir: inode destination for new link
1385  * @dentry: dentry for file
1386  * @mode: mode for creation
1387  * @rdev: device associated with special file
1388  *
1389  */
1390 
1391 static int
v9fs_vfs_mknod(struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev)1392 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
1393 {
1394 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
1395 	int retval;
1396 	char name[2 + U32_MAX_DIGITS + 1 + U32_MAX_DIGITS + 1];
1397 	u32 perm;
1398 
1399 	p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %hx MAJOR: %u MINOR: %u\n",
1400 		 dir->i_ino, dentry, mode,
1401 		 MAJOR(rdev), MINOR(rdev));
1402 
1403 	/* build extension */
1404 	if (S_ISBLK(mode))
1405 		sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1406 	else if (S_ISCHR(mode))
1407 		sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1408 	else
1409 		*name = 0;
1410 
1411 	perm = unixmode2p9mode(v9ses, mode);
1412 	retval = v9fs_vfs_mkspecial(dir, dentry, perm, name);
1413 
1414 	return retval;
1415 }
1416 
v9fs_refresh_inode(struct p9_fid * fid,struct inode * inode)1417 int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
1418 {
1419 	int umode;
1420 	dev_t rdev;
1421 	struct p9_wstat *st;
1422 	struct v9fs_session_info *v9ses;
1423 	unsigned int flags;
1424 
1425 	v9ses = v9fs_inode2v9ses(inode);
1426 	st = p9_client_stat(fid);
1427 	if (IS_ERR(st))
1428 		return PTR_ERR(st);
1429 	/*
1430 	 * Don't update inode if the file type is different
1431 	 */
1432 	umode = p9mode2unixmode(v9ses, st, &rdev);
1433 	if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
1434 		goto out;
1435 
1436 	/*
1437 	 * We don't want to refresh inode->i_size,
1438 	 * because we may have cached data
1439 	 */
1440 	flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
1441 		V9FS_STAT2INODE_KEEP_ISIZE : 0;
1442 	v9fs_stat2inode(st, inode, inode->i_sb, flags);
1443 out:
1444 	p9stat_free(st);
1445 	kfree(st);
1446 	return 0;
1447 }
1448 
1449 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1450 	.create = v9fs_vfs_create,
1451 	.lookup = v9fs_vfs_lookup,
1452 	.atomic_open = v9fs_vfs_atomic_open,
1453 	.symlink = v9fs_vfs_symlink,
1454 	.link = v9fs_vfs_link,
1455 	.unlink = v9fs_vfs_unlink,
1456 	.mkdir = v9fs_vfs_mkdir,
1457 	.rmdir = v9fs_vfs_rmdir,
1458 	.mknod = v9fs_vfs_mknod,
1459 	.rename = v9fs_vfs_rename,
1460 	.getattr = v9fs_vfs_getattr,
1461 	.setattr = v9fs_vfs_setattr,
1462 };
1463 
1464 static const struct inode_operations v9fs_dir_inode_operations = {
1465 	.create = v9fs_vfs_create,
1466 	.lookup = v9fs_vfs_lookup,
1467 	.atomic_open = v9fs_vfs_atomic_open,
1468 	.unlink = v9fs_vfs_unlink,
1469 	.mkdir = v9fs_vfs_mkdir,
1470 	.rmdir = v9fs_vfs_rmdir,
1471 	.mknod = v9fs_vfs_mknod,
1472 	.rename = v9fs_vfs_rename,
1473 	.getattr = v9fs_vfs_getattr,
1474 	.setattr = v9fs_vfs_setattr,
1475 };
1476 
1477 static const struct inode_operations v9fs_file_inode_operations = {
1478 	.getattr = v9fs_vfs_getattr,
1479 	.setattr = v9fs_vfs_setattr,
1480 };
1481 
1482 static const struct inode_operations v9fs_symlink_inode_operations = {
1483 	.get_link = v9fs_vfs_get_link,
1484 	.getattr = v9fs_vfs_getattr,
1485 	.setattr = v9fs_vfs_setattr,
1486 };
1487 
1488