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
, umode_t 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
,