1 // SPDX-License-Identifier: GPL-2.0-only
3 * This file contains vfs inode ops for the 9P2000 protocol.
5 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
6 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/module.h>
12 #include <linux/errno.h>
14 #include <linux/file.h>
15 #include <linux/pagemap.h>
16 #include <linux/stat.h>
17 #include <linux/string.h>
18 #include <linux/inet.h>
19 #include <linux/namei.h>
20 #include <linux/idr.h>
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 #include <linux/xattr.h>
24 #include <linux/posix_acl.h>
25 #include <net/9p/9p.h>
26 #include <net/9p/client.h>
35 static const struct inode_operations v9fs_dir_inode_operations;
36 static const struct inode_operations v9fs_dir_inode_operations_dotu;
37 static const struct inode_operations v9fs_file_inode_operations;
38 static const struct inode_operations v9fs_symlink_inode_operations;
41 * unixmode2p9mode - convert unix mode bits to plan 9
42 * @v9ses: v9fs session information
43 * @mode: mode to convert
47 static u32 unixmode2p9mode(struct v9fs_session_info *v9ses, umode_t mode)
54 if (v9fs_proto_dotu(v9ses)) {
55 if (v9ses->nodev == 0) {
59 res |= P9_DMNAMEDPIPE;
66 if ((mode & S_ISUID) == S_ISUID)
68 if ((mode & S_ISGID) == S_ISGID)
70 if ((mode & S_ISVTX) == S_ISVTX)
77 * p9mode2perm- convert plan9 mode bits to unix permission bits
78 * @v9ses: v9fs session information
79 * @stat: p9_wstat from which mode need to be derived
82 static int p9mode2perm(struct v9fs_session_info *v9ses,
83 struct p9_wstat *stat)
86 int mode = stat->mode;
88 res = mode & S_IALLUGO;
89 if (v9fs_proto_dotu(v9ses)) {
90 if ((mode & P9_DMSETUID) == P9_DMSETUID)
93 if ((mode & P9_DMSETGID) == P9_DMSETGID)
96 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
103 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
104 * @v9ses: v9fs session information
105 * @stat: p9_wstat from which mode need to be derived
106 * @rdev: major number, minor number in case of device files.
109 static umode_t p9mode2unixmode(struct v9fs_session_info *v9ses,
110 struct p9_wstat *stat, dev_t *rdev)
113 u32 mode = stat->mode;
116 res = p9mode2perm(v9ses, stat);
118 if ((mode & P9_DMDIR) == P9_DMDIR)
120 else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
122 else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
123 && (v9ses->nodev == 0))
125 else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
126 && (v9ses->nodev == 0))
128 else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
129 && (v9ses->nodev == 0)) {
131 int major = -1, minor = -1;
133 r = sscanf(stat->extension, "%c %i %i", &type, &major, &minor);
135 p9_debug(P9_DEBUG_ERROR,
136 "invalid device string, umode will be bogus: %s\n",
148 p9_debug(P9_DEBUG_ERROR, "Unknown special type %c %s\n",
149 type, stat->extension);
151 *rdev = MKDEV(major, minor);
159 * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
160 * @uflags: flags to convert
161 * @extended: if .u extensions are active
164 int v9fs_uflags2omode(int uflags, int extended)
188 if (uflags & O_APPEND)
196 * v9fs_blank_wstat - helper function to setup a 9P stat structure
197 * @wstat: structure to initialize
202 v9fs_blank_wstat(struct p9_wstat *wstat)
206 wstat->qid.type = ~0;
207 wstat->qid.version = ~0;
208 *((long long *)&wstat->qid.path) = ~0;
217 wstat->n_uid = INVALID_UID;
218 wstat->n_gid = INVALID_GID;
219 wstat->n_muid = INVALID_UID;
220 wstat->extension = NULL;
224 * v9fs_alloc_inode - helper function to allocate an inode
225 * @sb: The superblock to allocate the inode from
227 struct inode *v9fs_alloc_inode(struct super_block *sb)
229 struct v9fs_inode *v9inode;
231 v9inode = alloc_inode_sb(sb, v9fs_inode_cache, GFP_KERNEL);
234 v9inode->writeback_fid = NULL;
235 v9inode->cache_validity = 0;
236 mutex_init(&v9inode->v_mutex);
237 return &v9inode->vfs_inode;
241 * v9fs_free_inode - destroy an inode
242 * @inode: The inode to be freed
245 void v9fs_free_inode(struct inode *inode)
247 kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
251 * Set parameters for the netfs library
253 static void v9fs_set_netfs_context(struct inode *inode)
255 netfs_i_context_init(inode, &v9fs_req_ops);
258 int v9fs_init_inode(struct v9fs_session_info *v9ses,
259 struct inode *inode, umode_t mode, dev_t rdev)
263 inode_init_owner(&init_user_ns, inode, NULL, mode);
265 inode->i_rdev = rdev;
266 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
267 inode->i_mapping->a_ops = &v9fs_addr_operations;
268 inode->i_private = NULL;
270 switch (mode & S_IFMT) {
275 if (v9fs_proto_dotl(v9ses)) {
276 inode->i_op = &v9fs_file_inode_operations_dotl;
277 } else if (v9fs_proto_dotu(v9ses)) {
278 inode->i_op = &v9fs_file_inode_operations;
280 p9_debug(P9_DEBUG_ERROR,
281 "special files without extended mode\n");
285 init_special_inode(inode, inode->i_mode, inode->i_rdev);
288 if (v9fs_proto_dotl(v9ses)) {
289 inode->i_op = &v9fs_file_inode_operations_dotl;
290 if (v9ses->cache == CACHE_LOOSE ||
291 v9ses->cache == CACHE_FSCACHE)
293 &v9fs_cached_file_operations_dotl;
294 else if (v9ses->cache == CACHE_MMAP)
295 inode->i_fop = &v9fs_mmap_file_operations_dotl;
297 inode->i_fop = &v9fs_file_operations_dotl;
299 inode->i_op = &v9fs_file_inode_operations;
300 if (v9ses->cache == CACHE_LOOSE ||
301 v9ses->cache == CACHE_FSCACHE)
303 &v9fs_cached_file_operations;
304 else if (v9ses->cache == CACHE_MMAP)
305 inode->i_fop = &v9fs_mmap_file_operations;
307 inode->i_fop = &v9fs_file_operations;
312 if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
313 p9_debug(P9_DEBUG_ERROR,
314 "extended modes used with legacy protocol\n");
319 if (v9fs_proto_dotl(v9ses))
320 inode->i_op = &v9fs_symlink_inode_operations_dotl;
322 inode->i_op = &v9fs_symlink_inode_operations;
327 if (v9fs_proto_dotl(v9ses))
328 inode->i_op = &v9fs_dir_inode_operations_dotl;
329 else if (v9fs_proto_dotu(v9ses))
330 inode->i_op = &v9fs_dir_inode_operations_dotu;
332 inode->i_op = &v9fs_dir_inode_operations;
334 if (v9fs_proto_dotl(v9ses))
335 inode->i_fop = &v9fs_dir_operations_dotl;
337 inode->i_fop = &v9fs_dir_operations;
341 p9_debug(P9_DEBUG_ERROR, "BAD mode 0x%hx S_IFMT 0x%x\n",
342 mode, mode & S_IFMT);
347 v9fs_set_netfs_context(inode);
354 * v9fs_get_inode - helper function to setup an inode
356 * @mode: mode to setup inode with
357 * @rdev: The device numbers to set
360 struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t rdev)
364 struct v9fs_session_info *v9ses = sb->s_fs_info;
366 p9_debug(P9_DEBUG_VFS, "super block: %p mode: %ho\n", sb, mode);
368 inode = new_inode(sb);
370 pr_warn("%s (%d): Problem allocating inode\n",
371 __func__, task_pid_nr(current));
372 return ERR_PTR(-ENOMEM);
374 err = v9fs_init_inode(v9ses, inode, mode, rdev);
383 * v9fs_evict_inode - Remove an inode from the inode cache
384 * @inode: inode to release
387 void v9fs_evict_inode(struct inode *inode)
389 struct v9fs_inode *v9inode = V9FS_I(inode);
392 truncate_inode_pages_final(&inode->i_data);
393 version = cpu_to_le32(v9inode->qid.version);
394 fscache_clear_inode_writeback(v9fs_inode_cookie(v9inode), inode,
397 filemap_fdatawrite(&inode->i_data);
399 fscache_relinquish_cookie(v9fs_inode_cookie(v9inode), false);
400 /* clunk the fid stashed in writeback_fid */
401 if (v9inode->writeback_fid) {
402 p9_client_clunk(v9inode->writeback_fid);
403 v9inode->writeback_fid = NULL;
407 static int v9fs_test_inode(struct inode *inode, void *data)
411 struct v9fs_inode *v9inode = V9FS_I(inode);
412 struct p9_wstat *st = (struct p9_wstat *)data;
413 struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
415 umode = p9mode2unixmode(v9ses, st, &rdev);
416 /* don't match inode of different type */
417 if (inode_wrong_type(inode, umode))
420 /* compare qid details */
421 if (memcmp(&v9inode->qid.version,
422 &st->qid.version, sizeof(v9inode->qid.version)))
425 if (v9inode->qid.type != st->qid.type)
428 if (v9inode->qid.path != st->qid.path)
433 static int v9fs_test_new_inode(struct inode *inode, void *data)
438 static int v9fs_set_inode(struct inode *inode, void *data)
440 struct v9fs_inode *v9inode = V9FS_I(inode);
441 struct p9_wstat *st = (struct p9_wstat *)data;
443 memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
447 static struct inode *v9fs_qid_iget(struct super_block *sb,
457 struct v9fs_session_info *v9ses = sb->s_fs_info;
458 int (*test)(struct inode *inode, void *data);
461 test = v9fs_test_new_inode;
463 test = v9fs_test_inode;
465 i_ino = v9fs_qid2ino(qid);
466 inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
468 return ERR_PTR(-ENOMEM);
469 if (!(inode->i_state & I_NEW))
472 * initialize the inode with the stat info
473 * FIXME!! we may need support for stale inodes
476 inode->i_ino = i_ino;
477 umode = p9mode2unixmode(v9ses, st, &rdev);
478 retval = v9fs_init_inode(v9ses, inode, umode, rdev);
482 v9fs_stat2inode(st, inode, sb, 0);
483 v9fs_cache_inode_get_cookie(inode);
484 unlock_new_inode(inode);
488 return ERR_PTR(retval);
493 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
494 struct super_block *sb, int new)
497 struct inode *inode = NULL;
499 st = p9_client_stat(fid);
503 inode = v9fs_qid_iget(sb, &st->qid, st, new);
510 * v9fs_at_to_dotl_flags- convert Linux specific AT flags to
512 * @flags: flags to convert
514 static int v9fs_at_to_dotl_flags(int flags)
518 if (flags & AT_REMOVEDIR)
519 rflags |= P9_DOTL_AT_REMOVEDIR;
525 * v9fs_dec_count - helper functon to drop i_nlink.
527 * If a directory had nlink <= 2 (including . and ..), then we should not drop
528 * the link count, which indicates the underlying exported fs doesn't maintain
529 * nlink accurately. e.g.
530 * - overlayfs sets nlink to 1 for merged dir
531 * - ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has more
532 * than EXT4_LINK_MAX (65000) links.
534 * @inode: inode whose nlink is being dropped
536 static void v9fs_dec_count(struct inode *inode)
538 if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
543 * v9fs_remove - helper function to remove files and directories
544 * @dir: directory inode that is being deleted
545 * @dentry: dentry that is being deleted
546 * @flags: removing a directory
550 static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
553 int retval = -EOPNOTSUPP;
554 struct p9_fid *v9fid, *dfid;
555 struct v9fs_session_info *v9ses;
557 p9_debug(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
560 v9ses = v9fs_inode2v9ses(dir);
561 inode = d_inode(dentry);
562 dfid = v9fs_parent_fid(dentry);
564 retval = PTR_ERR(dfid);
565 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
568 if (v9fs_proto_dotl(v9ses))
569 retval = p9_client_unlinkat(dfid, dentry->d_name.name,
570 v9fs_at_to_dotl_flags(flags));
571 p9_client_clunk(dfid);
572 if (retval == -EOPNOTSUPP) {
573 /* Try the one based on path */
574 v9fid = v9fs_fid_clone(dentry);
576 return PTR_ERR(v9fid);
577 retval = p9_client_remove(v9fid);
581 * directories on unlink should have zero
584 if (flags & AT_REMOVEDIR) {
588 v9fs_dec_count(inode);
590 v9fs_invalidate_inode_attr(inode);
591 v9fs_invalidate_inode_attr(dir);
593 /* invalidate all fids associated with dentry */
594 /* NOTE: This will not include open fids */
595 dentry->d_op->d_release(dentry);
601 * v9fs_create - Create a file
602 * @v9ses: session information
603 * @dir: directory that dentry is being created in
604 * @dentry: dentry that is being created
605 * @extension: 9p2000.u extension string to support devices, etc.
606 * @perm: create permissions
610 static struct p9_fid *
611 v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
612 struct dentry *dentry, char *extension, u32 perm, u8 mode)
615 const unsigned char *name;
616 struct p9_fid *dfid, *ofid = NULL, *fid = NULL;
619 p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
622 name = dentry->d_name.name;
623 dfid = v9fs_parent_fid(dentry);
626 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
630 /* clone a fid to use for creation */
631 ofid = clone_fid(dfid);
634 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
635 p9_client_clunk(dfid);
639 err = p9_client_fcreate(ofid, name, perm, mode, extension);
641 p9_debug(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
642 p9_client_clunk(dfid);
646 if (!(perm & P9_DMLINK)) {
647 /* now walk from the parent so we can get unopened fid */
648 fid = p9_client_walk(dfid, 1, &name, 1);
651 p9_debug(P9_DEBUG_VFS,
652 "p9_client_walk failed %d\n", err);
654 p9_client_clunk(dfid);
658 * instantiate inode and assign the unopened fid to the dentry
660 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
662 err = PTR_ERR(inode);
663 p9_debug(P9_DEBUG_VFS,
664 "inode creation failed %d\n", err);
665 p9_client_clunk(dfid);
668 v9fs_fid_add(dentry, fid);
669 d_instantiate(dentry, inode);
671 p9_client_clunk(dfid);
675 p9_client_clunk(ofid);
678 p9_client_clunk(fid);
684 * v9fs_vfs_create - VFS hook to create a regular file
685 * @mnt_userns: The user namespace of the mount
686 * @dir: The parent directory
687 * @dentry: The name of file to be created
688 * @mode: The UNIX file mode to set
689 * @excl: True if the file must not yet exist
691 * open(.., O_CREAT) is handled in v9fs_vfs_atomic_open(). This is only called
697 v9fs_vfs_create(struct user_namespace *mnt_userns, struct inode *dir,
698 struct dentry *dentry, umode_t mode, bool excl)
700 struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
701 u32 perm = unixmode2p9mode(v9ses, mode);
705 fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_ORDWR);
709 v9fs_invalidate_inode_attr(dir);
710 p9_client_clunk(fid);
716 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
717 * @mnt_userns: The user namespace of the mount
718 * @dir: inode that is being unlinked
719 * @dentry: dentry that is being unlinked
720 * @mode: mode for new directory
724 static int v9fs_vfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
725 struct dentry *dentry, umode_t mode)
730 struct v9fs_session_info *v9ses;
732 p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
734 v9ses = v9fs_inode2v9ses(dir);
735 perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
736 fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
742 v9fs_invalidate_inode_attr(dir);
746 p9_client_clunk(fid);
752 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
753 * @dir: inode that is being walked from
754 * @dentry: dentry that is being walked to?
755 * @flags: lookup flags (unused)
759 struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
763 struct v9fs_session_info *v9ses;
764 struct p9_fid *dfid, *fid;
766 const unsigned char *name;
768 p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%pd) %p flags: %x\n",
769 dir, dentry, dentry, flags);
771 if (dentry->d_name.len > NAME_MAX)
772 return ERR_PTR(-ENAMETOOLONG);
774 v9ses = v9fs_inode2v9ses(dir);
775 /* We can walk d_parent because we hold the dir->i_mutex */
776 dfid = v9fs_parent_fid(dentry);
778 return ERR_CAST(dfid);
781 * Make sure we don't use a wrong inode due to parallel
782 * unlink. For cached mode create calls request for new
783 * inode. But with cache disabled, lookup should do this.
785 name = dentry->d_name.name;
786 fid = p9_client_walk(dfid, 1, &name, 1);
787 p9_client_clunk(dfid);
788 if (fid == ERR_PTR(-ENOENT))
790 else if (IS_ERR(fid))
791 inode = ERR_CAST(fid);
792 else if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
793 inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
795 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
797 * If we had a rename on the server and a parallel lookup
798 * for the new name, then make sure we instantiate with
799 * the new name. ie look up for a/b, while on server somebody
800 * moved b under k and client parallely did a lookup for
803 res = d_splice_alias(inode, dentry);
806 v9fs_fid_add(dentry, fid);
807 else if (!IS_ERR(res))
808 v9fs_fid_add(res, fid);
810 p9_client_clunk(fid);
816 v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
817 struct file *file, unsigned int flags, umode_t mode)
821 struct v9fs_inode *v9inode;
822 struct v9fs_session_info *v9ses;
823 struct p9_fid *fid, *inode_fid;
824 struct dentry *res = NULL;
827 if (d_in_lookup(dentry)) {
828 res = v9fs_vfs_lookup(dir, dentry, 0);
837 if (!(flags & O_CREAT) || d_really_is_positive(dentry))
838 return finish_no_open(file, res);
842 v9ses = v9fs_inode2v9ses(dir);
843 perm = unixmode2p9mode(v9ses, mode);
844 fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
845 v9fs_uflags2omode(flags,
846 v9fs_proto_dotu(v9ses)));
853 v9fs_invalidate_inode_attr(dir);
854 inode = d_inode(dentry);
855 v9inode = V9FS_I(inode);
856 mutex_lock(&v9inode->v_mutex);
857 if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
858 !v9inode->writeback_fid &&
859 ((flags & O_ACCMODE) != O_RDONLY)) {
861 * clone a fid and add it to writeback_fid
862 * we do it during open time instead of
863 * page dirty time via write_begin/page_mkwrite
864 * because we want write after unlink usecase
867 inode_fid = v9fs_writeback_fid(dentry);
868 if (IS_ERR(inode_fid)) {
869 err = PTR_ERR(inode_fid);
870 mutex_unlock(&v9inode->v_mutex);
873 v9inode->writeback_fid = (void *) inode_fid;
875 mutex_unlock(&v9inode->v_mutex);
876 err = finish_open(file, dentry, generic_file_open);
880 file->private_data = fid;
881 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
882 fscache_use_cookie(v9fs_inode_cookie(v9inode),
883 file->f_mode & FMODE_WRITE);
884 v9fs_open_fid_add(inode, fid);
886 file->f_mode |= FMODE_CREATED;
893 p9_client_clunk(fid);
898 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
899 * @i: inode that is being unlinked
900 * @d: dentry that is being unlinked
904 int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
906 return v9fs_remove(i, d, 0);
910 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
911 * @i: inode that is being unlinked
912 * @d: dentry that is being unlinked
916 int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
918 return v9fs_remove(i, d, AT_REMOVEDIR);
922 * v9fs_vfs_rename - VFS hook to rename an inode
923 * @mnt_userns: The user namespace of the mount
924 * @old_dir: old dir inode
925 * @old_dentry: old dentry
926 * @new_dir: new dir inode
927 * @new_dentry: new dentry
928 * @flags: RENAME_* flags
933 v9fs_vfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
934 struct dentry *old_dentry, struct inode *new_dir,
935 struct dentry *new_dentry, unsigned int flags)
938 struct inode *old_inode;
939 struct inode *new_inode;
940 struct v9fs_session_info *v9ses;
941 struct p9_fid *oldfid, *dfid;
942 struct p9_fid *olddirfid;
943 struct p9_fid *newdirfid;
944 struct p9_wstat wstat;
949 p9_debug(P9_DEBUG_VFS, "\n");
951 old_inode = d_inode(old_dentry);
952 new_inode = d_inode(new_dentry);
953 v9ses = v9fs_inode2v9ses(old_inode);
954 oldfid = v9fs_fid_lookup(old_dentry);
956 return PTR_ERR(oldfid);
958 dfid = v9fs_parent_fid(old_dentry);
959 olddirfid = clone_fid(dfid);
960 if (dfid && !IS_ERR(dfid))
961 p9_client_clunk(dfid);
963 if (IS_ERR(olddirfid)) {
964 retval = PTR_ERR(olddirfid);
968 dfid = v9fs_parent_fid(new_dentry);
969 newdirfid = clone_fid(dfid);
970 p9_client_clunk(dfid);
972 if (IS_ERR(newdirfid)) {
973 retval = PTR_ERR(newdirfid);
977 down_write(&v9ses->rename_sem);
978 if (v9fs_proto_dotl(v9ses)) {
979 retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
980 newdirfid, new_dentry->d_name.name);
981 if (retval == -EOPNOTSUPP)
982 retval = p9_client_rename(oldfid, newdirfid,
983 new_dentry->d_name.name);
984 if (retval != -EOPNOTSUPP)
987 if (old_dentry->d_parent != new_dentry->d_parent) {
989 * 9P .u can only handle file rename in the same directory
992 p9_debug(P9_DEBUG_ERROR, "old dir and new dir are different\n");
996 v9fs_blank_wstat(&wstat);
997 wstat.muid = v9ses->uname;
998 wstat.name = new_dentry->d_name.name;
999 retval = p9_client_wstat(oldfid, &wstat);
1004 if (S_ISDIR(new_inode->i_mode))
1005 clear_nlink(new_inode);
1007 v9fs_dec_count(new_inode);
1009 if (S_ISDIR(old_inode->i_mode)) {
1012 v9fs_dec_count(old_dir);
1014 v9fs_invalidate_inode_attr(old_inode);
1015 v9fs_invalidate_inode_attr(old_dir);
1016 v9fs_invalidate_inode_attr(new_dir);
1018 /* successful rename */
1019 d_move(old_dentry, new_dentry);
1021 up_write(&v9ses->rename_sem);
1022 p9_client_clunk(newdirfid);
1025 p9_client_clunk(olddirfid);
1028 p9_client_clunk(oldfid);
1033 * v9fs_vfs_getattr - retrieve file metadata
1034 * @mnt_userns: The user namespace of the mount
1035 * @path: Object to query
1036 * @stat: metadata structure to populate
1037 * @request_mask: Mask of STATX_xxx flags indicating the caller's interests
1038 * @flags: AT_STATX_xxx setting
1043 v9fs_vfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
1044 struct kstat *stat, u32 request_mask, unsigned int flags)
1046 struct dentry *dentry = path->dentry;
1047 struct v9fs_session_info *v9ses;
1049 struct p9_wstat *st;
1051 p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1052 v9ses = v9fs_dentry2v9ses(dentry);
1053 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1054 generic_fillattr(&init_user_ns, d_inode(dentry), stat);
1057 fid = v9fs_fid_lookup(dentry);
1059 return PTR_ERR(fid);
1061 st = p9_client_stat(fid);
1062 p9_client_clunk(fid);
1066 v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
1067 generic_fillattr(&init_user_ns, d_inode(dentry), stat);
1075 * v9fs_vfs_setattr - set file metadata
1076 * @mnt_userns: The user namespace of the mount
1077 * @dentry: file whose metadata to set
1078 * @iattr: metadata assignment structure
1082 static int v9fs_vfs_setattr(struct user_namespace *mnt_userns,
1083 struct dentry *dentry, struct iattr *iattr)
1085 int retval, use_dentry = 0;
1086 struct inode *inode = d_inode(dentry);
1087 struct v9fs_inode *v9inode = V9FS_I(inode);
1088 struct v9fs_session_info *v9ses;
1089 struct p9_fid *fid = NULL;
1090 struct p9_wstat wstat;
1092 p9_debug(P9_DEBUG_VFS, "\n");
1093 retval = setattr_prepare(&init_user_ns, dentry, iattr);
1098 v9ses = v9fs_dentry2v9ses(dentry);
1099 if (iattr->ia_valid & ATTR_FILE) {
1100 fid = iattr->ia_file->private_data;
1104 fid = v9fs_fid_lookup(dentry);
1108 return PTR_ERR(fid);
1110 v9fs_blank_wstat(&wstat);
1111 if (iattr->ia_valid & ATTR_MODE)
1112 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
1114 if (iattr->ia_valid & ATTR_MTIME)
1115 wstat.mtime = iattr->ia_mtime.tv_sec;
1117 if (iattr->ia_valid & ATTR_ATIME)
1118 wstat.atime = iattr->ia_atime.tv_sec;
1120 if (iattr->ia_valid & ATTR_SIZE)
1121 wstat.length = iattr->ia_size;
1123 if (v9fs_proto_dotu(v9ses)) {
1124 if (iattr->ia_valid & ATTR_UID)
1125 wstat.n_uid = iattr->ia_uid;
1127 if (iattr->ia_valid & ATTR_GID)
1128 wstat.n_gid = iattr->ia_gid;
1131 /* Write all dirty data */
1132 if (d_is_reg(dentry))
1133 filemap_write_and_wait(inode->i_mapping);
1135 retval = p9_client_wstat(fid, &wstat);
1138 p9_client_clunk(fid);
1143 if ((iattr->ia_valid & ATTR_SIZE) &&
1144 iattr->ia_size != i_size_read(inode)) {
1145 truncate_setsize(inode, iattr->ia_size);
1146 fscache_resize_cookie(v9fs_inode_cookie(v9inode), iattr->ia_size);
1149 v9fs_invalidate_inode_attr(inode);
1151 setattr_copy(&init_user_ns, inode, iattr);
1152 mark_inode_dirty(inode);
1157 * v9fs_stat2inode - populate an inode structure with mistat info
1158 * @stat: Plan 9 metadata (mistat) structure
1159 * @inode: inode to populate
1160 * @sb: superblock of filesystem
1161 * @flags: control flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
1166 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
1167 struct super_block *sb, unsigned int flags)
1170 struct v9fs_session_info *v9ses = sb->s_fs_info;
1171 struct v9fs_inode *v9inode = V9FS_I(inode);
1173 set_nlink(inode, 1);
1175 inode->i_atime.tv_sec = stat->atime;
1176 inode->i_mtime.tv_sec = stat->mtime;
1177 inode->i_ctime.tv_sec = stat->mtime;
1179 inode->i_uid = v9ses->dfltuid;
1180 inode->i_gid = v9ses->dfltgid;
1182 if (v9fs_proto_dotu(v9ses)) {
1183 inode->i_uid = stat->n_uid;
1184 inode->i_gid = stat->n_gid;
1186 if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1187 if (v9fs_proto_dotu(v9ses)) {
1188 unsigned int i_nlink;
1190 * Hadlink support got added later to the .u extension.
1191 * So there can be a server out there that doesn't
1192 * support this even with .u extension. That would
1193 * just leave us with stat->extension being an empty
1196 /* HARDLINKCOUNT %u */
1197 if (sscanf(stat->extension,
1198 " HARDLINKCOUNT %u", &i_nlink) == 1)
1199 set_nlink(inode, i_nlink);
1202 mode = p9mode2perm(v9ses, stat);
1203 mode |= inode->i_mode & ~S_IALLUGO;
1204 inode->i_mode = mode;
1206 if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
1207 v9fs_i_size_write(inode, stat->length);
1208 /* not real number of blocks, but 512 byte ones ... */
1209 inode->i_blocks = (stat->length + 512 - 1) >> 9;
1210 v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
1214 * v9fs_qid2ino - convert qid into inode number
1217 * BUG: potential for inode number collisions?
1220 ino_t v9fs_qid2ino(struct p9_qid *qid)
1222 u64 path = qid->path + 2;
1225 if (sizeof(ino_t) == sizeof(path))
1226 memcpy(&i, &path, sizeof(ino_t));
1228 i = (ino_t) (path ^ (path >> 32));
1234 * v9fs_vfs_get_link - follow a symlink path
1235 * @dentry: dentry for symlink
1236 * @inode: inode for symlink
1237 * @done: delayed call for when we are done with the return value
1240 static const char *v9fs_vfs_get_link(struct dentry *dentry,
1241 struct inode *inode,
1242 struct delayed_call *done)
1244 struct v9fs_session_info *v9ses;
1246 struct p9_wstat *st;
1250 return ERR_PTR(-ECHILD);
1252 v9ses = v9fs_dentry2v9ses(dentry);
1253 fid = v9fs_fid_lookup(dentry);
1254 p9_debug(P9_DEBUG_VFS, "%pd\n", dentry);
1257 return ERR_CAST(fid);
1259 if (!v9fs_proto_dotu(v9ses))
1260 return ERR_PTR(-EBADF);
1262 st = p9_client_stat(fid);
1263 p9_client_clunk(fid);
1265 return ERR_CAST(st);
1267 if (!(st->mode & P9_DMSYMLINK)) {
1270 return ERR_PTR(-EINVAL);
1272 res = st->extension;
1273 st->extension = NULL;
1274 if (strlen(res) >= PATH_MAX)
1275 res[PATH_MAX - 1] = '\0';
1279 set_delayed_call(done, kfree_link, res);
1284 * v9fs_vfs_mkspecial - create a special file
1285 * @dir: inode to create special file in
1286 * @dentry: dentry to create
1287 * @perm: mode to create special file
1288 * @extension: 9p2000.u format extension string representing special file
1292 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1293 u32 perm, const char *extension)
1296 struct v9fs_session_info *v9ses;
1298 v9ses = v9fs_inode2v9ses(dir);
1299 if (!v9fs_proto_dotu(v9ses)) {
1300 p9_debug(P9_DEBUG_ERROR, "not extended\n");
1304 fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1307 return PTR_ERR(fid);
1309 v9fs_invalidate_inode_attr(dir);
1310 p9_client_clunk(fid);
1315 * v9fs_vfs_symlink - helper function to create symlinks
1316 * @mnt_userns: The user namespace of the mount
1317 * @dir: directory inode containing symlink
1318 * @dentry: dentry for symlink
1319 * @symname: symlink data
1321 * See Also: 9P2000.u RFC for more information
1326 v9fs_vfs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
1327 struct dentry *dentry, const char *symname)
1329 p9_debug(P9_DEBUG_VFS, " %lu,%pd,%s\n",
1330 dir->i_ino, dentry, symname);
1332 return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
1335 #define U32_MAX_DIGITS 10
1338 * v9fs_vfs_link - create a hardlink
1339 * @old_dentry: dentry for file to link to
1340 * @dir: inode destination for new link
1341 * @dentry: dentry for link
1346 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1347 struct dentry *dentry)
1350 char name[1 + U32_MAX_DIGITS + 2]; /* sign + number + \n + \0 */
1351 struct p9_fid *oldfid;
1353 p9_debug(P9_DEBUG_VFS, " %lu,%pd,%pd\n",
1354 dir->i_ino, dentry, old_dentry);
1356 oldfid = v9fs_fid_clone(old_dentry);
1358 return PTR_ERR(oldfid);
1360 sprintf(name, "%d\n", oldfid->fid);
1361 retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1363 v9fs_refresh_inode(oldfid, d_inode(old_dentry));
1364 v9fs_invalidate_inode_attr(dir);
1366 p9_client_clunk(oldfid);
1371 * v9fs_vfs_mknod - create a special file
1372 * @mnt_userns: The user namespace of the mount
1373 * @dir: inode destination for new link
1374 * @dentry: dentry for file
1375 * @mode: mode for creation
1376 * @rdev: device associated with special file
1381 v9fs_vfs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
1382 struct dentry *dentry, umode_t mode, dev_t rdev)
1384 struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
1386 char name[2 + U32_MAX_DIGITS + 1 + U32_MAX_DIGITS + 1];
1389 p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %x MAJOR: %u MINOR: %u\n",
1390 dir->i_ino, dentry, mode,
1391 MAJOR(rdev), MINOR(rdev));
1393 /* build extension */
1395 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1396 else if (S_ISCHR(mode))
1397 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1401 perm = unixmode2p9mode(v9ses, mode);
1402 retval = v9fs_vfs_mkspecial(dir, dentry, perm, name);
1407 int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
1411 struct p9_wstat *st;
1412 struct v9fs_session_info *v9ses;
1415 v9ses = v9fs_inode2v9ses(inode);
1416 st = p9_client_stat(fid);
1420 * Don't update inode if the file type is different
1422 umode = p9mode2unixmode(v9ses, st, &rdev);
1423 if (inode_wrong_type(inode, umode))
1427 * We don't want to refresh inode->i_size,
1428 * because we may have cached data
1430 flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
1431 V9FS_STAT2INODE_KEEP_ISIZE : 0;
1432 v9fs_stat2inode(st, inode, inode->i_sb, flags);
1439 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1440 .create = v9fs_vfs_create,
1441 .lookup = v9fs_vfs_lookup,
1442 .atomic_open = v9fs_vfs_atomic_open,
1443 .symlink = v9fs_vfs_symlink,
1444 .link = v9fs_vfs_link,
1445 .unlink = v9fs_vfs_unlink,
1446 .mkdir = v9fs_vfs_mkdir,
1447 .rmdir = v9fs_vfs_rmdir,
1448 .mknod = v9fs_vfs_mknod,
1449 .rename = v9fs_vfs_rename,
1450 .getattr = v9fs_vfs_getattr,
1451 .setattr = v9fs_vfs_setattr,
1454 static const struct inode_operations v9fs_dir_inode_operations = {
1455 .create = v9fs_vfs_create,
1456 .lookup = v9fs_vfs_lookup,
1457 .atomic_open = v9fs_vfs_atomic_open,
1458 .unlink = v9fs_vfs_unlink,
1459 .mkdir = v9fs_vfs_mkdir,
1460 .rmdir = v9fs_vfs_rmdir,
1461 .mknod = v9fs_vfs_mknod,
1462 .rename = v9fs_vfs_rename,
1463 .getattr = v9fs_vfs_getattr,
1464 .setattr = v9fs_vfs_setattr,
1467 static const struct inode_operations v9fs_file_inode_operations = {
1468 .getattr = v9fs_vfs_getattr,
1469 .setattr = v9fs_vfs_setattr,
1472 static const struct inode_operations v9fs_symlink_inode_operations = {
1473 .get_link = v9fs_vfs_get_link,
1474 .getattr = v9fs_vfs_getattr,
1475 .setattr = v9fs_vfs_setattr,