2 * linux/fs/9p/vfs_inode.c
4 * This file contains vfs inode ops for the 9P2000 protocol.
6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
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.
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.
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
26 #include <linux/module.h>
27 #include <linux/errno.h>
29 #include <linux/file.h>
30 #include <linux/pagemap.h>
31 #include <linux/stat.h>
32 #include <linux/string.h>
33 #include <linux/inet.h>
34 #include <linux/namei.h>
35 #include <linux/idr.h>
36 #include <linux/sched.h>
37 #include <linux/slab.h>
38 #include <linux/xattr.h>
39 #include <linux/posix_acl.h>
40 #include <net/9p/9p.h>
41 #include <net/9p/client.h>
50 static const struct inode_operations v9fs_dir_inode_operations;
51 static const struct inode_operations v9fs_dir_inode_operations_dotu;
52 static const struct inode_operations v9fs_file_inode_operations;
53 static const struct inode_operations v9fs_symlink_inode_operations;
56 * unixmode2p9mode - convert unix mode bits to plan 9
57 * @v9ses: v9fs session information
58 * @mode: mode to convert
62 static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
68 if (v9fs_proto_dotu(v9ses)) {
71 if (v9ses->nodev == 0) {
75 res |= P9_DMNAMEDPIPE;
82 if ((mode & S_ISUID) == S_ISUID)
84 if ((mode & S_ISGID) == S_ISGID)
86 if ((mode & S_ISVTX) == S_ISVTX)
88 if ((mode & P9_DMLINK))
96 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
97 * @v9ses: v9fs session information
98 * @stat: p9_wstat from which mode need to be derived
99 * @rdev: major number, minor number in case of device files.
102 static int p9mode2unixmode(struct v9fs_session_info *v9ses,
103 struct p9_wstat *stat, dev_t *rdev)
106 int mode = stat->mode;
108 res = mode & S_IALLUGO;
111 if ((mode & P9_DMDIR) == P9_DMDIR)
113 else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
115 else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
116 && (v9ses->nodev == 0))
118 else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
119 && (v9ses->nodev == 0))
121 else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
122 && (v9ses->nodev == 0)) {
123 char type = 0, ext[32];
124 int major = -1, minor = -1;
126 strncpy(ext, stat->extension, sizeof(ext));
127 sscanf(ext, "%c %u %u", &type, &major, &minor);
136 P9_DPRINTK(P9_DEBUG_ERROR,
137 "Unknown special type %c %s\n", type,
140 *rdev = MKDEV(major, minor);
144 if (v9fs_proto_dotu(v9ses)) {
145 if ((mode & P9_DMSETUID) == P9_DMSETUID)
148 if ((mode & P9_DMSETGID) == P9_DMSETGID)
151 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
158 * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
159 * @uflags: flags to convert
160 * @extended: if .u extensions are active
163 int v9fs_uflags2omode(int uflags, int extended)
183 if (uflags & O_TRUNC)
190 if (uflags & O_APPEND)
198 * v9fs_blank_wstat - helper function to setup a 9P stat structure
199 * @wstat: structure to initialize
204 v9fs_blank_wstat(struct p9_wstat *wstat)
208 wstat->qid.type = ~0;
209 wstat->qid.version = ~0;
210 *((long long *)&wstat->qid.path) = ~0;
222 wstat->extension = NULL;
226 * v9fs_alloc_inode - helper function to allocate an inode
229 struct inode *v9fs_alloc_inode(struct super_block *sb)
231 struct v9fs_inode *v9inode;
232 v9inode = (struct v9fs_inode *)kmem_cache_alloc(v9fs_inode_cache,
236 #ifdef CONFIG_9P_FSCACHE
237 v9inode->fscache = NULL;
238 spin_lock_init(&v9inode->fscache_lock);
240 v9inode->writeback_fid = NULL;
241 v9inode->cache_validity = 0;
242 mutex_init(&v9inode->v_mutex);
243 return &v9inode->vfs_inode;
247 * v9fs_destroy_inode - destroy an inode
251 static void v9fs_i_callback(struct rcu_head *head)
253 struct inode *inode = container_of(head, struct inode, i_rcu);
254 kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
257 void v9fs_destroy_inode(struct inode *inode)
259 call_rcu(&inode->i_rcu, v9fs_i_callback);
262 int v9fs_init_inode(struct v9fs_session_info *v9ses,
263 struct inode *inode, int mode, dev_t rdev)
267 inode_init_owner(inode, NULL, mode);
269 inode->i_rdev = rdev;
270 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
271 inode->i_mapping->a_ops = &v9fs_addr_operations;
273 switch (mode & S_IFMT) {
278 if (v9fs_proto_dotl(v9ses)) {
279 inode->i_op = &v9fs_file_inode_operations_dotl;
280 } else if (v9fs_proto_dotu(v9ses)) {
281 inode->i_op = &v9fs_file_inode_operations;
283 P9_DPRINTK(P9_DEBUG_ERROR,
284 "special files without extended mode\n");
288 init_special_inode(inode, inode->i_mode, inode->i_rdev);
291 if (v9fs_proto_dotl(v9ses)) {
292 inode->i_op = &v9fs_file_inode_operations_dotl;
295 &v9fs_cached_file_operations_dotl;
297 inode->i_fop = &v9fs_file_operations_dotl;
299 inode->i_op = &v9fs_file_inode_operations;
301 inode->i_fop = &v9fs_cached_file_operations;
303 inode->i_fop = &v9fs_file_operations;
308 if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
309 P9_DPRINTK(P9_DEBUG_ERROR, "extended modes used with "
310 "legacy protocol.\n");
315 if (v9fs_proto_dotl(v9ses))
316 inode->i_op = &v9fs_symlink_inode_operations_dotl;
318 inode->i_op = &v9fs_symlink_inode_operations;
323 if (v9fs_proto_dotl(v9ses))
324 inode->i_op = &v9fs_dir_inode_operations_dotl;
325 else if (v9fs_proto_dotu(v9ses))
326 inode->i_op = &v9fs_dir_inode_operations_dotu;
328 inode->i_op = &v9fs_dir_inode_operations;
330 if (v9fs_proto_dotl(v9ses))
331 inode->i_fop = &v9fs_dir_operations_dotl;
333 inode->i_fop = &v9fs_dir_operations;
337 P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
338 mode, mode & S_IFMT);
348 * v9fs_get_inode - helper function to setup an inode
350 * @mode: mode to setup inode with
354 struct inode *v9fs_get_inode(struct super_block *sb, int mode, dev_t rdev)
358 struct v9fs_session_info *v9ses = sb->s_fs_info;
360 P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
362 inode = new_inode(sb);
364 P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
365 return ERR_PTR(-ENOMEM);
367 err = v9fs_init_inode(v9ses, inode, mode, rdev);
376 static struct v9fs_fid*
377 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
381 struct v9fs_fid *ret;
382 struct v9fs_fcall *fcall;
384 nfid = v9fs_get_idpool(&v9ses->fidpool);
386 eprintk(KERN_WARNING, "no free fids available\n");
387 return ERR_PTR(-ENOSPC);
390 err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
394 if (fcall && fcall->id == RWALK)
397 PRINT_FCALL_ERROR("walk error", fcall);
398 v9fs_put_idpool(nfid, &v9ses->fidpool);
404 ret = v9fs_fid_create(v9ses, nfid);
410 err = v9fs_fid_insert(ret, dentry);
412 v9fs_fid_destroy(ret);
419 v9fs_t_clunk(v9ses, nfid);
429 * v9fs_clear_inode - release an inode
430 * @inode: inode to release
433 void v9fs_evict_inode(struct inode *inode)
435 struct v9fs_inode *v9inode = V9FS_I(inode);
437 truncate_inode_pages(inode->i_mapping, 0);
438 end_writeback(inode);
439 filemap_fdatawrite(inode->i_mapping);
441 #ifdef CONFIG_9P_FSCACHE
442 v9fs_cache_inode_put_cookie(inode);
444 /* clunk the fid stashed in writeback_fid */
445 if (v9inode->writeback_fid) {
446 p9_client_clunk(v9inode->writeback_fid);
447 v9inode->writeback_fid = NULL;
451 static int v9fs_test_inode(struct inode *inode, void *data)
455 struct v9fs_inode *v9inode = V9FS_I(inode);
456 struct p9_wstat *st = (struct p9_wstat *)data;
457 struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
459 umode = p9mode2unixmode(v9ses, st, &rdev);
460 /* don't match inode of different type */
461 if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
464 /* compare qid details */
465 if (memcmp(&v9inode->qid.version,
466 &st->qid.version, sizeof(v9inode->qid.version)))
469 if (v9inode->qid.type != st->qid.type)
474 static int v9fs_test_new_inode(struct inode *inode, void *data)
479 static int v9fs_set_inode(struct inode *inode, void *data)
481 struct v9fs_inode *v9inode = V9FS_I(inode);
482 struct p9_wstat *st = (struct p9_wstat *)data;
484 memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
488 static struct inode *v9fs_qid_iget(struct super_block *sb,
497 struct v9fs_session_info *v9ses = sb->s_fs_info;
498 int (*test)(struct inode *, void *);
501 test = v9fs_test_new_inode;
503 test = v9fs_test_inode;
505 i_ino = v9fs_qid2ino(qid);
506 inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
508 return ERR_PTR(-ENOMEM);
509 if (!(inode->i_state & I_NEW))
512 * initialize the inode with the stat info
513 * FIXME!! we may need support for stale inodes
516 inode->i_ino = i_ino;
517 umode = p9mode2unixmode(v9ses, st, &rdev);
518 retval = v9fs_init_inode(v9ses, inode, umode, rdev);
522 v9fs_stat2inode(st, inode, sb);
523 #ifdef CONFIG_9P_FSCACHE
524 v9fs_cache_inode_get_cookie(inode);
526 unlock_new_inode(inode);
529 unlock_new_inode(inode);
531 return ERR_PTR(retval);
536 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
537 struct super_block *sb, int new)
540 struct inode *inode = NULL;
542 st = p9_client_stat(fid);
546 inode = v9fs_qid_iget(sb, &st->qid, st, new);
553 * v9fs_at_to_dotl_flags- convert Linux specific AT flags to
555 * @flags: flags to convert
557 static int v9fs_at_to_dotl_flags(int flags)
560 if (flags & AT_REMOVEDIR)
561 rflags |= P9_DOTL_AT_REMOVEDIR;
566 * v9fs_remove - helper function to remove files and directories
567 * @dir: directory inode that is being deleted
568 * @dentry: dentry that is being deleted
569 * @rmdir: removing a directory
573 static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
576 int retval = -EOPNOTSUPP;
577 struct p9_fid *v9fid, *dfid;
578 struct v9fs_session_info *v9ses;
580 P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
583 v9ses = v9fs_inode2v9ses(dir);
584 inode = dentry->d_inode;
585 dfid = v9fs_fid_lookup(dentry->d_parent);
587 retval = PTR_ERR(dfid);
588 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
591 if (v9fs_proto_dotl(v9ses))
592 retval = p9_client_unlinkat(dfid, dentry->d_name.name,
593 v9fs_at_to_dotl_flags(flags));
594 if (retval == -EOPNOTSUPP) {
595 /* Try the one based on path */
596 v9fid = v9fs_fid_clone(dentry);
598 return PTR_ERR(v9fid);
599 retval = p9_client_remove(v9fid);
603 * directories on unlink should have zero
606 if (flags & AT_REMOVEDIR) {
612 v9fs_invalidate_inode_attr(inode);
613 v9fs_invalidate_inode_attr(dir);
619 * v9fs_create - Create a file
620 * @v9ses: session information
621 * @dir: directory that dentry is being created in
622 * @dentry: dentry that is being created
623 * @extension: 9p2000.u extension string to support devices, etc.
624 * @perm: create permissions
628 static struct p9_fid *
629 v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
630 struct dentry *dentry, char *extension, u32 perm, u8 mode)
634 struct p9_fid *dfid, *ofid, *fid;
637 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
642 name = (char *) dentry->d_name.name;
643 dfid = v9fs_fid_lookup(dentry->d_parent);
646 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
650 /* clone a fid to use for creation */
651 ofid = p9_client_walk(dfid, 0, NULL, 1);
654 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
658 err = p9_client_fcreate(ofid, name, perm, mode, extension);
660 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
664 /* now walk from the parent so we can get unopened fid */
665 fid = p9_client_walk(dfid, 1, &name, 1);
668 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
673 /* instantiate inode and assign the unopened fid to the dentry */
674 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
676 err = PTR_ERR(inode);
677 P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
680 err = v9fs_fid_add(dentry, fid);
683 d_instantiate(dentry, inode);
687 p9_client_clunk(ofid);
690 p9_client_clunk(fid);
696 * v9fs_vfs_create - VFS hook to create files
697 * @dir: directory inode that is being created
698 * @dentry: dentry that is being deleted
699 * @mode: create permissions
700 * @nd: path information
705 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
706 struct nameidata *nd)
712 struct v9fs_inode *v9inode;
713 struct v9fs_session_info *v9ses;
714 struct p9_fid *fid, *inode_fid;
718 v9ses = v9fs_inode2v9ses(dir);
719 perm = unixmode2p9mode(v9ses, mode);
721 flags = nd->intent.open.flags;
725 fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
726 v9fs_uflags2omode(flags,
727 v9fs_proto_dotu(v9ses)));
734 v9fs_invalidate_inode_attr(dir);
735 /* if we are opening a file, assign the open fid to the file */
737 v9inode = V9FS_I(dentry->d_inode);
738 mutex_lock(&v9inode->v_mutex);
739 if (v9ses->cache && !v9inode->writeback_fid &&
740 ((flags & O_ACCMODE) != O_RDONLY)) {
742 * clone a fid and add it to writeback_fid
743 * we do it during open time instead of
744 * page dirty time via write_begin/page_mkwrite
745 * because we want write after unlink usecase
748 inode_fid = v9fs_writeback_fid(dentry);
749 if (IS_ERR(inode_fid)) {
750 err = PTR_ERR(inode_fid);
751 mutex_unlock(&v9inode->v_mutex);
754 v9inode->writeback_fid = (void *) inode_fid;
756 mutex_unlock(&v9inode->v_mutex);
757 filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
763 filp->private_data = fid;
764 #ifdef CONFIG_9P_FSCACHE
766 v9fs_cache_inode_set_cookie(dentry->d_inode, filp);
769 p9_client_clunk(fid);
775 p9_client_clunk(fid);
781 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
782 * @dir: inode that is being unlinked
783 * @dentry: dentry that is being unlinked
784 * @mode: mode for new directory
788 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
793 struct v9fs_session_info *v9ses;
795 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
797 v9ses = v9fs_inode2v9ses(dir);
798 perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
799 fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
805 v9fs_invalidate_inode_attr(dir);
809 p9_client_clunk(fid);
815 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
816 * @dir: inode that is being walked from
817 * @dentry: dentry that is being walked to?
818 * @nameidata: path data
822 struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
823 struct nameidata *nameidata)
826 struct super_block *sb;
827 struct v9fs_session_info *v9ses;
828 struct p9_fid *dfid, *fid;
833 P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
834 dir, dentry->d_name.name, dentry, nameidata);
836 if (dentry->d_name.len > NAME_MAX)
837 return ERR_PTR(-ENAMETOOLONG);
840 v9ses = v9fs_inode2v9ses(dir);
841 /* We can walk d_parent because we hold the dir->i_mutex */
842 dfid = v9fs_fid_lookup(dentry->d_parent);
844 return ERR_CAST(dfid);
846 name = (char *) dentry->d_name.name;
847 fid = p9_client_walk(dfid, 1, &name, 1);
849 result = PTR_ERR(fid);
850 if (result == -ENOENT) {
855 return ERR_PTR(result);
858 * Make sure we don't use a wrong inode due to parallel
859 * unlink. For cached mode create calls request for new
860 * inode. But with cache disabled, lookup should do this.
863 inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
865 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
867 result = PTR_ERR(inode);
871 result = v9fs_fid_add(dentry, fid);
876 * If we had a rename on the server and a parallel lookup
877 * for the new name, then make sure we instantiate with
878 * the new name. ie look up for a/b, while on server somebody
879 * moved b under k and client parallely did a lookup for
882 res = d_materialise_unique(dentry, inode);
885 result = PTR_ERR(res);
889 p9_client_clunk(fid);
891 return ERR_PTR(result);
895 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
896 * @i: inode that is being unlinked
897 * @d: dentry that is being unlinked
901 int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
903 return v9fs_remove(i, d, 0);
907 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
908 * @i: inode that is being unlinked
909 * @d: dentry that is being unlinked
913 int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
915 return v9fs_remove(i, d, AT_REMOVEDIR);
919 * v9fs_vfs_rename - VFS hook to rename an inode
920 * @old_dir: old dir inode
921 * @old_dentry: old dentry
922 * @new_dir: new dir inode
923 * @new_dentry: new dentry
928 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
929 struct inode *new_dir, struct dentry *new_dentry)
932 struct inode *old_inode;
933 struct inode *new_inode;
934 struct v9fs_session_info *v9ses;
935 struct p9_fid *oldfid;
936 struct p9_fid *olddirfid;
937 struct p9_fid *newdirfid;
938 struct p9_wstat wstat;
940 P9_DPRINTK(P9_DEBUG_VFS, "\n");
942 old_inode = old_dentry->d_inode;
943 new_inode = new_dentry->d_inode;
944 v9ses = v9fs_inode2v9ses(old_inode);
945 oldfid = v9fs_fid_lookup(old_dentry);
947 return PTR_ERR(oldfid);
949 olddirfid = v9fs_fid_clone(old_dentry->d_parent);
950 if (IS_ERR(olddirfid)) {
951 retval = PTR_ERR(olddirfid);
955 newdirfid = v9fs_fid_clone(new_dentry->d_parent);
956 if (IS_ERR(newdirfid)) {
957 retval = PTR_ERR(newdirfid);
961 down_write(&v9ses->rename_sem);
962 if (v9fs_proto_dotl(v9ses)) {
963 retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
964 newdirfid, new_dentry->d_name.name);
965 if (retval == -EOPNOTSUPP)
966 retval = p9_client_rename(oldfid, newdirfid,
967 new_dentry->d_name.name);
968 if (retval != -EOPNOTSUPP)
971 if (old_dentry->d_parent != new_dentry->d_parent) {
973 * 9P .u can only handle file rename in the same directory
976 P9_DPRINTK(P9_DEBUG_ERROR,
977 "old dir and new dir are different\n");
981 v9fs_blank_wstat(&wstat);
982 wstat.muid = v9ses->uname;
983 wstat.name = (char *) new_dentry->d_name.name;
984 retval = p9_client_wstat(oldfid, &wstat);
989 if (S_ISDIR(new_inode->i_mode))
990 clear_nlink(new_inode);
992 drop_nlink(new_inode);
994 if (S_ISDIR(old_inode->i_mode)) {
999 v9fs_invalidate_inode_attr(old_inode);
1000 v9fs_invalidate_inode_attr(old_dir);
1001 v9fs_invalidate_inode_attr(new_dir);
1003 /* successful rename */
1004 d_move(old_dentry, new_dentry);
1006 up_write(&v9ses->rename_sem);
1007 p9_client_clunk(newdirfid);
1010 p9_client_clunk(olddirfid);
1017 * v9fs_vfs_getattr - retrieve file metadata
1018 * @mnt: mount information
1019 * @dentry: file to get attributes on
1020 * @stat: metadata structure to populate
1025 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1029 struct v9fs_session_info *v9ses;
1031 struct p9_wstat *st;
1033 P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1035 v9ses = v9fs_dentry2v9ses(dentry);
1036 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1037 generic_fillattr(dentry->d_inode, stat);
1040 fid = v9fs_fid_lookup(dentry);
1042 return PTR_ERR(fid);
1044 st = p9_client_stat(fid);
1048 v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
1049 generic_fillattr(dentry->d_inode, stat);
1057 * v9fs_vfs_setattr - set file metadata
1058 * @dentry: file whose metadata to set
1059 * @iattr: metadata assignment structure
1063 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
1066 struct v9fs_session_info *v9ses;
1068 struct p9_wstat wstat;
1070 P9_DPRINTK(P9_DEBUG_VFS, "\n");
1071 retval = inode_change_ok(dentry->d_inode, iattr);
1076 v9ses = v9fs_dentry2v9ses(dentry);
1077 fid = v9fs_fid_lookup(dentry);
1079 return PTR_ERR(fid);
1081 v9fs_blank_wstat(&wstat);
1082 if (iattr->ia_valid & ATTR_MODE)
1083 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
1085 if (iattr->ia_valid & ATTR_MTIME)
1086 wstat.mtime = iattr->ia_mtime.tv_sec;
1088 if (iattr->ia_valid & ATTR_ATIME)
1089 wstat.atime = iattr->ia_atime.tv_sec;
1091 if (iattr->ia_valid & ATTR_SIZE)
1092 wstat.length = iattr->ia_size;
1094 if (v9fs_proto_dotu(v9ses)) {
1095 if (iattr->ia_valid & ATTR_UID)
1096 wstat.n_uid = iattr->ia_uid;
1098 if (iattr->ia_valid & ATTR_GID)
1099 wstat.n_gid = iattr->ia_gid;
1102 /* Write all dirty data */
1103 if (S_ISREG(dentry->d_inode->i_mode))
1104 filemap_write_and_wait(dentry->d_inode->i_mapping);
1106 retval = p9_client_wstat(fid, &wstat);
1110 if ((iattr->ia_valid & ATTR_SIZE) &&
1111 iattr->ia_size != i_size_read(dentry->d_inode))
1112 truncate_setsize(dentry->d_inode, iattr->ia_size);
1114 v9fs_invalidate_inode_attr(dentry->d_inode);
1116 setattr_copy(dentry->d_inode, iattr);
1117 mark_inode_dirty(dentry->d_inode);
1122 * v9fs_stat2inode - populate an inode structure with mistat info
1123 * @stat: Plan 9 metadata (mistat) structure
1124 * @inode: inode to populate
1125 * @sb: superblock of filesystem
1130 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
1131 struct super_block *sb)
1136 unsigned int i_nlink;
1137 struct v9fs_session_info *v9ses = sb->s_fs_info;
1138 struct v9fs_inode *v9inode = V9FS_I(inode);
1140 set_nlink(inode, 1);
1142 inode->i_atime.tv_sec = stat->atime;
1143 inode->i_mtime.tv_sec = stat->mtime;
1144 inode->i_ctime.tv_sec = stat->mtime;
1146 inode->i_uid = v9ses->dfltuid;
1147 inode->i_gid = v9ses->dfltgid;
1149 if (v9fs_proto_dotu(v9ses)) {
1150 inode->i_uid = stat->n_uid;
1151 inode->i_gid = stat->n_gid;
1153 if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1154 if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1156 * Hadlink support got added later to
1157 * to the .u extension. So there can be
1158 * server out there that doesn't support
1159 * this even with .u extension. So check
1160 * for non NULL stat->extension
1162 strncpy(ext, stat->extension, sizeof(ext));
1163 /* HARDLINKCOUNT %u */
1164 sscanf(ext, "%13s %u", tag_name, &i_nlink);
1165 if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
1166 set_nlink(inode, i_nlink);
1169 mode = stat->mode & S_IALLUGO;
1170 mode |= inode->i_mode & ~S_IALLUGO;
1171 inode->i_mode = mode;
1172 i_size_write(inode, stat->length);
1174 /* not real number of blocks, but 512 byte ones ... */
1175 inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
1176 v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
1180 * v9fs_qid2ino - convert qid into inode number
1183 * BUG: potential for inode number collisions?
1186 ino_t v9fs_qid2ino(struct p9_qid *qid)
1188 u64 path = qid->path + 2;
1191 if (sizeof(ino_t) == sizeof(path))
1192 memcpy(&i, &path, sizeof(ino_t));
1194 i = (ino_t) (path ^ (path >> 32));
1200 * v9fs_readlink - read a symlink's location (internal version)
1201 * @dentry: dentry for symlink
1202 * @buffer: buffer to load symlink location into
1203 * @buflen: length of buffer
1207 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1211 struct v9fs_session_info *v9ses;
1213 struct p9_wstat *st;
1215 P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
1217 v9ses = v9fs_dentry2v9ses(dentry);
1218 fid = v9fs_fid_lookup(dentry);
1220 return PTR_ERR(fid);
1222 if (!v9fs_proto_dotu(v9ses))
1225 st = p9_client_stat(fid);
1229 if (!(st->mode & P9_DMSYMLINK)) {
1234 /* copy extension buffer into buffer */
1235 strncpy(buffer, st->extension, buflen);
1237 P9_DPRINTK(P9_DEBUG_VFS,
1238 "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
1240 retval = strnlen(buffer, buflen);
1248 * v9fs_vfs_follow_link - follow a symlink path
1249 * @dentry: dentry for symlink
1254 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1257 char *link = __getname();
1259 P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
1262 link = ERR_PTR(-ENOMEM);
1264 len = v9fs_readlink(dentry, link, PATH_MAX);
1268 link = ERR_PTR(len);
1270 link[min(len, PATH_MAX-1)] = 0;
1272 nd_set_link(nd, link);
1278 * v9fs_vfs_put_link - release a symlink path
1279 * @dentry: dentry for symlink
1286 v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1288 char *s = nd_get_link(nd);
1290 P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name,
1291 IS_ERR(s) ? "<error>" : s);
1297 * v9fs_vfs_mkspecial - create a special file
1298 * @dir: inode to create special file in
1299 * @dentry: dentry to create
1300 * @mode: mode to create special file
1301 * @extension: 9p2000.u format extension string representing special file
1305 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1306 int mode, const char *extension)
1310 struct v9fs_session_info *v9ses;
1312 v9ses = v9fs_inode2v9ses(dir);
1313 if (!v9fs_proto_dotu(v9ses)) {
1314 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
1318 perm = unixmode2p9mode(v9ses, mode);
1319 fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1322 return PTR_ERR(fid);
1324 v9fs_invalidate_inode_attr(dir);
1325 p9_client_clunk(fid);
1330 * v9fs_vfs_symlink - helper function to create symlinks
1331 * @dir: directory inode containing symlink
1332 * @dentry: dentry for symlink
1333 * @symname: symlink data
1335 * See Also: 9P2000.u RFC for more information
1340 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1342 P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
1343 dentry->d_name.name, symname);
1345 return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1349 * v9fs_vfs_link - create a hardlink
1350 * @old_dentry: dentry for file to link to
1351 * @dir: inode destination for new link
1352 * @dentry: dentry for link
1357 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1358 struct dentry *dentry)
1362 struct p9_fid *oldfid;
1364 P9_DPRINTK(P9_DEBUG_VFS,
1365 " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
1366 old_dentry->d_name.name);
1368 oldfid = v9fs_fid_clone(old_dentry);
1370 return PTR_ERR(oldfid);
1373 if (unlikely(!name)) {
1378 sprintf(name, "%d\n", oldfid->fid);
1379 retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1382 v9fs_refresh_inode(oldfid, old_dentry->d_inode);
1383 v9fs_invalidate_inode_attr(dir);
1386 p9_client_clunk(oldfid);
1391 * v9fs_vfs_mknod - create a special file
1392 * @dir: inode destination for new link
1393 * @dentry: dentry for file
1394 * @mode: mode for creation
1395 * @rdev: device associated with special file
1400 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1405 P9_DPRINTK(P9_DEBUG_VFS,
1406 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1407 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1409 if (!new_valid_dev(rdev))
1415 /* build extension */
1417 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1418 else if (S_ISCHR(mode))
1419 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1420 else if (S_ISFIFO(mode))
1422 else if (S_ISSOCK(mode))
1429 retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1435 int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
1440 struct p9_wstat *st;
1441 struct v9fs_session_info *v9ses;
1443 v9ses = v9fs_inode2v9ses(inode);
1444 st = p9_client_stat(fid);
1448 * Don't update inode if the file type is different
1450 umode = p9mode2unixmode(v9ses, st, &rdev);
1451 if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
1454 spin_lock(&inode->i_lock);
1456 * We don't want to refresh inode->i_size,
1457 * because we may have cached data
1459 i_size = inode->i_size;
1460 v9fs_stat2inode(st, inode, inode->i_sb);
1462 inode->i_size = i_size;
1463 spin_unlock(&inode->i_lock);
1470 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1471 .create = v9fs_vfs_create,
1472 .lookup = v9fs_vfs_lookup,
1473 .symlink = v9fs_vfs_symlink,
1474 .link = v9fs_vfs_link,
1475 .unlink = v9fs_vfs_unlink,
1476 .mkdir = v9fs_vfs_mkdir,
1477 .rmdir = v9fs_vfs_rmdir,
1478 .mknod = v9fs_vfs_mknod,
1479 .rename = v9fs_vfs_rename,
1480 .getattr = v9fs_vfs_getattr,
1481 .setattr = v9fs_vfs_setattr,
1484 static const struct inode_operations v9fs_dir_inode_operations = {
1485 .create = v9fs_vfs_create,
1486 .lookup = v9fs_vfs_lookup,
1487 .unlink = v9fs_vfs_unlink,
1488 .mkdir = v9fs_vfs_mkdir,
1489 .rmdir = v9fs_vfs_rmdir,
1490 .mknod = v9fs_vfs_mknod,
1491 .rename = v9fs_vfs_rename,
1492 .getattr = v9fs_vfs_getattr,
1493 .setattr = v9fs_vfs_setattr,
1496 static const struct inode_operations v9fs_file_inode_operations = {
1497 .getattr = v9fs_vfs_getattr,
1498 .setattr = v9fs_vfs_setattr,
1501 static const struct inode_operations v9fs_symlink_inode_operations = {
1502 .readlink = generic_readlink,
1503 .follow_link = v9fs_vfs_follow_link,
1504 .put_link = v9fs_vfs_put_link,
1505 .getattr = v9fs_vfs_getattr,
1506 .setattr = v9fs_vfs_setattr,