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 as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to:
21 * Free Software Foundation
22 * 51 Franklin Street, Fifth Floor
23 * Boston, MA 02111-1301 USA
27 #include <linux/module.h>
28 #include <linux/errno.h>
30 #include <linux/file.h>
31 #include <linux/pagemap.h>
32 #include <linux/stat.h>
33 #include <linux/string.h>
34 #include <linux/smp_lock.h>
35 #include <linux/inet.h>
36 #include <linux/namei.h>
37 #include <linux/idr.h>
45 static struct inode_operations v9fs_dir_inode_operations
;
46 static struct inode_operations v9fs_dir_inode_operations_ext
;
47 static struct inode_operations v9fs_file_inode_operations
;
48 static struct inode_operations v9fs_symlink_inode_operations
;
51 * unixmode2p9mode - convert unix mode bits to plan 9
52 * @v9ses: v9fs session information
53 * @mode: mode to convert
57 static int unixmode2p9mode(struct v9fs_session_info
*v9ses
, int mode
)
63 if (v9ses
->extended
) {
65 res
|= V9FS_DMSYMLINK
;
66 if (v9ses
->nodev
== 0) {
70 res
|= V9FS_DMNAMEDPIPE
;
77 if ((mode
& S_ISUID
) == S_ISUID
)
79 if ((mode
& S_ISGID
) == S_ISGID
)
81 if ((mode
& V9FS_DMLINK
))
89 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
90 * @v9ses: v9fs session information
91 * @mode: mode to convert
95 static int p9mode2unixmode(struct v9fs_session_info
*v9ses
, int mode
)
101 if ((mode
& V9FS_DMDIR
) == V9FS_DMDIR
)
103 else if ((mode
& V9FS_DMSYMLINK
) && (v9ses
->extended
))
105 else if ((mode
& V9FS_DMSOCKET
) && (v9ses
->extended
)
106 && (v9ses
->nodev
== 0))
108 else if ((mode
& V9FS_DMNAMEDPIPE
) && (v9ses
->extended
)
109 && (v9ses
->nodev
== 0))
111 else if ((mode
& V9FS_DMDEVICE
) && (v9ses
->extended
)
112 && (v9ses
->nodev
== 0))
117 if (v9ses
->extended
) {
118 if ((mode
& V9FS_DMSETUID
) == V9FS_DMSETUID
)
121 if ((mode
& V9FS_DMSETGID
) == V9FS_DMSETGID
)
128 int v9fs_uflags2omode(int uflags
)
151 if (uflags
& O_TRUNC
)
154 if (uflags
& O_APPEND
)
161 * v9fs_blank_wstat - helper function to setup a 9P stat structure
162 * @v9ses: 9P session info (for determining extended mode)
163 * @wstat: structure to initialize
168 v9fs_blank_wstat(struct v9fs_wstat
*wstat
)
172 wstat
->qid
.type
= ~0;
173 wstat
->qid
.version
= ~0;
174 *((long long *)&wstat
->qid
.path
) = ~0;
186 wstat
->extension
= NULL
;
190 * v9fs_get_inode - helper function to setup an inode
192 * @mode: mode to setup inode with
196 struct inode
*v9fs_get_inode(struct super_block
*sb
, int mode
)
199 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
201 dprintk(DEBUG_VFS
, "super block: %p mode: %o\n", sb
, mode
);
203 inode
= new_inode(sb
);
205 inode
->i_mode
= mode
;
206 inode
->i_uid
= current
->fsuid
;
207 inode
->i_gid
= current
->fsgid
;
208 inode
->i_blksize
= sb
->s_blocksize
;
211 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
212 inode
->i_mapping
->a_ops
= &v9fs_addr_operations
;
214 switch (mode
& S_IFMT
) {
219 if(!v9ses
->extended
) {
220 dprintk(DEBUG_ERROR
, "special files without extended mode\n");
221 return ERR_PTR(-EINVAL
);
223 init_special_inode(inode
, inode
->i_mode
,
227 inode
->i_op
= &v9fs_file_inode_operations
;
228 inode
->i_fop
= &v9fs_file_operations
;
231 if(!v9ses
->extended
) {
232 dprintk(DEBUG_ERROR
, "extended modes used w/o 9P2000.u\n");
233 return ERR_PTR(-EINVAL
);
235 inode
->i_op
= &v9fs_symlink_inode_operations
;
240 inode
->i_op
= &v9fs_dir_inode_operations_ext
;
242 inode
->i_op
= &v9fs_dir_inode_operations
;
243 inode
->i_fop
= &v9fs_dir_operations
;
246 dprintk(DEBUG_ERROR
, "BAD mode 0x%x S_IFMT 0x%x\n",
247 mode
, mode
& S_IFMT
);
248 return ERR_PTR(-EINVAL
);
251 eprintk(KERN_WARNING
, "Problem allocating inode\n");
252 return ERR_PTR(-ENOMEM
);
258 v9fs_create(struct v9fs_session_info
*v9ses
, u32 pfid
, char *name
,
259 u32 perm
, u8 mode
, u32
*fidp
, struct v9fs_qid
*qid
, u32
*iounit
)
263 struct v9fs_fcall
*fcall
;
265 fid
= v9fs_get_idpool(&v9ses
->fidpool
);
267 eprintk(KERN_WARNING
, "no free fids available\n");
271 err
= v9fs_t_walk(v9ses
, pfid
, fid
, NULL
, &fcall
);
273 PRINT_FCALL_ERROR("clone error", fcall
);
278 err
= v9fs_t_create(v9ses
, fid
, name
, perm
, mode
, &fcall
);
280 PRINT_FCALL_ERROR("create fails", fcall
);
285 *iounit
= fcall
->params
.rcreate
.iounit
;
288 *qid
= fcall
->params
.rcreate
.qid
;
298 v9fs_put_idpool(fid
, &v9ses
->fidpool
);
304 static struct v9fs_fid
*
305 v9fs_clone_walk(struct v9fs_session_info
*v9ses
, u32 fid
, struct dentry
*dentry
)
309 struct v9fs_fid
*ret
;
310 struct v9fs_fcall
*fcall
;
312 nfid
= v9fs_get_idpool(&v9ses
->fidpool
);
314 eprintk(KERN_WARNING
, "no free fids available\n");
315 return ERR_PTR(-ENOSPC
);
318 err
= v9fs_t_walk(v9ses
, fid
, nfid
, (char *) dentry
->d_name
.name
,
322 PRINT_FCALL_ERROR("walk error", fcall
);
323 v9fs_put_idpool(nfid
, &v9ses
->fidpool
);
329 ret
= v9fs_fid_create(v9ses
, nfid
);
335 err
= v9fs_fid_insert(ret
, dentry
);
337 v9fs_fid_destroy(ret
);
344 v9fs_t_clunk(v9ses
, nfid
);
351 static struct inode
*
352 v9fs_inode_from_fid(struct v9fs_session_info
*v9ses
, u32 fid
,
353 struct super_block
*sb
)
357 struct v9fs_fcall
*fcall
;
360 err
= v9fs_t_stat(v9ses
, fid
, &fcall
);
362 PRINT_FCALL_ERROR("stat error", fcall
);
366 umode
= p9mode2unixmode(v9ses
, fcall
->params
.rstat
.stat
.mode
);
367 ret
= v9fs_get_inode(sb
, umode
);
374 v9fs_stat2inode(&fcall
->params
.rstat
.stat
, ret
, sb
);
387 * v9fs_remove - helper function to remove files and directories
388 * @dir: directory inode that is being deleted
389 * @file: dentry that is being deleted
390 * @rmdir: removing a directory
394 static int v9fs_remove(struct inode
*dir
, struct dentry
*file
, int rmdir
)
396 struct v9fs_fcall
*fcall
= NULL
;
397 struct super_block
*sb
= NULL
;
398 struct v9fs_session_info
*v9ses
= NULL
;
399 struct v9fs_fid
*v9fid
= NULL
;
400 struct inode
*file_inode
= NULL
;
404 dprintk(DEBUG_VFS
, "inode: %p dentry: %p rmdir: %d\n", dir
, file
,
407 file_inode
= file
->d_inode
;
408 sb
= file_inode
->i_sb
;
409 v9ses
= v9fs_inode2v9ses(file_inode
);
410 v9fid
= v9fs_fid_lookup(file
);
420 dprintk(DEBUG_ERROR
, "inode #%lu, no fid!\n",
425 result
= v9fs_t_remove(v9ses
, fid
, &fcall
);
427 PRINT_FCALL_ERROR("remove fails", fcall
);
429 v9fs_put_idpool(fid
, &v9ses
->fidpool
);
430 v9fs_fid_destroy(v9fid
);
438 v9fs_open_created(struct inode
*inode
, struct file
*file
)
444 * v9fs_vfs_create - VFS hook to create files
445 * @inode: directory inode that is being deleted
446 * @dentry: dentry that is being deleted
447 * @mode: create permissions
448 * @nd: path information
453 v9fs_vfs_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
454 struct nameidata
*nd
)
457 u32 fid
, perm
, iounit
;
459 struct v9fs_session_info
*v9ses
;
460 struct v9fs_fid
*dfid
, *vfid
, *ffid
;
467 v9ses
= v9fs_inode2v9ses(dir
);
468 dfid
= v9fs_fid_lookup(dentry
->d_parent
);
469 perm
= unixmode2p9mode(v9ses
, mode
);
471 if (nd
&& nd
->flags
& LOOKUP_OPEN
)
472 flags
= nd
->intent
.open
.flags
- 1;
476 err
= v9fs_create(v9ses
, dfid
->fid
, (char *) dentry
->d_name
.name
,
477 perm
, v9fs_uflags2omode(flags
), &fid
, &qid
, &iounit
);
482 vfid
= v9fs_clone_walk(v9ses
, dfid
->fid
, dentry
);
489 inode
= v9fs_inode_from_fid(v9ses
, vfid
->fid
, dir
->i_sb
);
491 err
= PTR_ERR(inode
);
496 dentry
->d_op
= &v9fs_dentry_operations
;
497 d_instantiate(dentry
, inode
);
499 if (nd
&& nd
->flags
& LOOKUP_OPEN
) {
500 ffid
= v9fs_fid_create(v9ses
, fid
);
504 filp
= lookup_instantiate_filp(nd
, dentry
, v9fs_open_created
);
506 v9fs_fid_destroy(ffid
);
507 return PTR_ERR(filp
);
511 ffid
->rdir_fcall
= NULL
;
513 ffid
->iounit
= iounit
;
515 filp
->private_data
= ffid
;
522 v9fs_fid_destroy(vfid
);
531 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
532 * @inode: inode that is being unlinked
533 * @dentry: dentry that is being unlinked
534 * @mode: mode for new directory
538 static int v9fs_vfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
542 struct v9fs_session_info
*v9ses
;
543 struct v9fs_fid
*dfid
, *vfid
;
548 v9ses
= v9fs_inode2v9ses(dir
);
549 dfid
= v9fs_fid_lookup(dentry
->d_parent
);
550 perm
= unixmode2p9mode(v9ses
, mode
| S_IFDIR
);
552 err
= v9fs_create(v9ses
, dfid
->fid
, (char *) dentry
->d_name
.name
,
553 perm
, V9FS_OREAD
, &fid
, NULL
, NULL
);
556 dprintk(DEBUG_ERROR
, "create error %d\n", err
);
560 err
= v9fs_t_clunk(v9ses
, fid
);
562 dprintk(DEBUG_ERROR
, "clunk error %d\n", err
);
566 vfid
= v9fs_clone_walk(v9ses
, dfid
->fid
, dentry
);
573 inode
= v9fs_inode_from_fid(v9ses
, vfid
->fid
, dir
->i_sb
);
575 err
= PTR_ERR(inode
);
580 dentry
->d_op
= &v9fs_dentry_operations
;
581 d_instantiate(dentry
, inode
);
586 v9fs_fid_destroy(vfid
);
592 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
593 * @dir: inode that is being walked from
594 * @dentry: dentry that is being walked to?
595 * @nameidata: path data
599 static struct dentry
*v9fs_vfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
600 struct nameidata
*nameidata
)
602 struct super_block
*sb
;
603 struct v9fs_session_info
*v9ses
;
604 struct v9fs_fid
*dirfid
;
605 struct v9fs_fid
*fid
;
607 struct v9fs_fcall
*fcall
= NULL
;
612 dprintk(DEBUG_VFS
, "dir: %p dentry: (%s) %p nameidata: %p\n",
613 dir
, dentry
->d_name
.name
, dentry
, nameidata
);
616 v9ses
= v9fs_inode2v9ses(dir
);
617 dentry
->d_op
= &v9fs_dentry_operations
;
618 dirfid
= v9fs_fid_lookup(dentry
->d_parent
);
621 dprintk(DEBUG_ERROR
, "no dirfid\n");
622 return ERR_PTR(-EINVAL
);
625 dirfidnum
= dirfid
->fid
;
628 dprintk(DEBUG_ERROR
, "no dirfid for inode %p, #%lu\n",
630 return ERR_PTR(-EBADF
);
633 newfid
= v9fs_get_idpool(&v9ses
->fidpool
);
635 eprintk(KERN_WARNING
, "newfid fails!\n");
636 return ERR_PTR(-ENOSPC
);
639 result
= v9fs_t_walk(v9ses
, dirfidnum
, newfid
,
640 (char *)dentry
->d_name
.name
, NULL
);
642 v9fs_put_idpool(newfid
, &v9ses
->fidpool
);
643 if (result
== -ENOENT
) {
646 "Return negative dentry %p count %d\n",
647 dentry
, atomic_read(&dentry
->d_count
));
650 dprintk(DEBUG_ERROR
, "walk error:%d\n", result
);
654 result
= v9fs_t_stat(v9ses
, newfid
, &fcall
);
656 dprintk(DEBUG_ERROR
, "stat error\n");
660 inode
= v9fs_get_inode(sb
, p9mode2unixmode(v9ses
,
661 fcall
->params
.rstat
.stat
.mode
));
663 if (IS_ERR(inode
) && (PTR_ERR(inode
) == -ENOSPC
)) {
664 eprintk(KERN_WARNING
, "inode alloc failes, returns %ld\n",
671 inode
->i_ino
= v9fs_qid2ino(&fcall
->params
.rstat
.stat
.qid
);
673 fid
= v9fs_fid_create(v9ses
, newfid
);
675 dprintk(DEBUG_ERROR
, "couldn't insert\n");
680 result
= v9fs_fid_insert(fid
, dentry
);
684 fid
->qid
= fcall
->params
.rstat
.stat
.qid
;
685 v9fs_stat2inode(&fcall
->params
.rstat
.stat
, inode
, inode
->i_sb
);
687 d_add(dentry
, inode
);
694 return ERR_PTR(result
);
698 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
699 * @i: inode that is being unlinked
700 * @d: dentry that is being unlinked
704 static int v9fs_vfs_unlink(struct inode
*i
, struct dentry
*d
)
706 return v9fs_remove(i
, d
, 0);
710 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
711 * @i: inode that is being unlinked
712 * @d: dentry that is being unlinked
716 static int v9fs_vfs_rmdir(struct inode
*i
, struct dentry
*d
)
718 return v9fs_remove(i
, d
, 1);
722 * v9fs_vfs_rename - VFS hook to rename an inode
723 * @old_dir: old dir inode
724 * @old_dentry: old dentry
725 * @new_dir: new dir inode
726 * @new_dentry: new dentry
731 v9fs_vfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
732 struct inode
*new_dir
, struct dentry
*new_dentry
)
734 struct inode
*old_inode
= old_dentry
->d_inode
;
735 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(old_inode
);
736 struct v9fs_fid
*oldfid
= v9fs_fid_lookup(old_dentry
);
737 struct v9fs_fid
*olddirfid
=
738 v9fs_fid_lookup(old_dentry
->d_parent
);
739 struct v9fs_fid
*newdirfid
=
740 v9fs_fid_lookup(new_dentry
->d_parent
);
741 struct v9fs_wstat wstat
;
742 struct v9fs_fcall
*fcall
= NULL
;
744 int olddirfidnum
= -1;
745 int newdirfidnum
= -1;
748 dprintk(DEBUG_VFS
, "\n");
750 if ((!oldfid
) || (!olddirfid
) || (!newdirfid
)) {
751 dprintk(DEBUG_ERROR
, "problem with arguments\n");
755 /* 9P can only handle file rename in the same directory */
756 if (memcmp(&olddirfid
->qid
, &newdirfid
->qid
, sizeof(newdirfid
->qid
))) {
757 dprintk(DEBUG_ERROR
, "old dir and new dir are different\n");
763 olddirfidnum
= olddirfid
->fid
;
764 newdirfidnum
= newdirfid
->fid
;
767 dprintk(DEBUG_ERROR
, "no fid for old file #%lu\n",
773 v9fs_blank_wstat(&wstat
);
774 wstat
.muid
= v9ses
->name
;
775 wstat
.name
= (char *) new_dentry
->d_name
.name
;
777 retval
= v9fs_t_wstat(v9ses
, fid
, &wstat
, &fcall
);
781 PRINT_FCALL_ERROR("wstat error", fcall
);
788 * v9fs_vfs_getattr - retrieve file metadata
789 * @mnt - mount information
790 * @dentry - file to get attributes on
791 * @stat - metadata structure to populate
796 v9fs_vfs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
799 struct v9fs_fcall
*fcall
= NULL
;
800 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
801 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
804 dprintk(DEBUG_VFS
, "dentry: %p\n", dentry
);
807 "couldn't find fid associated with dentry\n");
811 err
= v9fs_t_stat(v9ses
, fid
->fid
, &fcall
);
814 dprintk(DEBUG_ERROR
, "stat error\n");
816 v9fs_stat2inode(&fcall
->params
.rstat
.stat
, dentry
->d_inode
,
817 dentry
->d_inode
->i_sb
);
818 generic_fillattr(dentry
->d_inode
, stat
);
826 * v9fs_vfs_setattr - set file metadata
827 * @dentry: file whose metadata to set
828 * @iattr: metadata assignment structure
832 static int v9fs_vfs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
834 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
835 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
836 struct v9fs_fcall
*fcall
= NULL
;
837 struct v9fs_wstat wstat
;
840 dprintk(DEBUG_VFS
, "\n");
844 "Couldn't find fid associated with dentry\n");
848 v9fs_blank_wstat(&wstat
);
849 if (iattr
->ia_valid
& ATTR_MODE
)
850 wstat
.mode
= unixmode2p9mode(v9ses
, iattr
->ia_mode
);
852 if (iattr
->ia_valid
& ATTR_MTIME
)
853 wstat
.mtime
= iattr
->ia_mtime
.tv_sec
;
855 if (iattr
->ia_valid
& ATTR_ATIME
)
856 wstat
.atime
= iattr
->ia_atime
.tv_sec
;
858 if (iattr
->ia_valid
& ATTR_SIZE
)
859 wstat
.length
= iattr
->ia_size
;
861 if (v9ses
->extended
) {
862 if (iattr
->ia_valid
& ATTR_UID
)
863 wstat
.n_uid
= iattr
->ia_uid
;
865 if (iattr
->ia_valid
& ATTR_GID
)
866 wstat
.n_gid
= iattr
->ia_gid
;
869 res
= v9fs_t_wstat(v9ses
, fid
->fid
, &wstat
, &fcall
);
872 PRINT_FCALL_ERROR("wstat error", fcall
);
876 res
= inode_setattr(dentry
->d_inode
, iattr
);
882 * v9fs_stat2inode - populate an inode structure with mistat info
883 * @stat: Plan 9 metadata (mistat) structure
884 * @inode: inode to populate
885 * @sb: superblock of filesystem
890 v9fs_stat2inode(struct v9fs_stat
*stat
, struct inode
*inode
,
891 struct super_block
*sb
)
895 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
899 inode
->i_atime
.tv_sec
= stat
->atime
;
900 inode
->i_mtime
.tv_sec
= stat
->mtime
;
901 inode
->i_ctime
.tv_sec
= stat
->mtime
;
903 inode
->i_uid
= v9ses
->uid
;
904 inode
->i_gid
= v9ses
->gid
;
906 if (v9ses
->extended
) {
907 inode
->i_uid
= stat
->n_uid
;
908 inode
->i_gid
= stat
->n_gid
;
911 inode
->i_mode
= p9mode2unixmode(v9ses
, stat
->mode
);
912 if ((S_ISBLK(inode
->i_mode
)) || (S_ISCHR(inode
->i_mode
))) {
917 n
= stat
->extension
.len
;
918 if (n
> sizeof(ext
)-1)
920 memmove(ext
, stat
->extension
.str
, n
);
922 sscanf(ext
, "%c %u %u", &type
, &major
, &minor
);
925 inode
->i_mode
&= ~S_IFBLK
;
926 inode
->i_mode
|= S_IFCHR
;
931 dprintk(DEBUG_ERROR
, "Unknown special type %c (%.*s)\n",
932 type
, stat
->extension
.len
, stat
->extension
.str
);
934 inode
->i_rdev
= MKDEV(major
, minor
);
938 inode
->i_size
= stat
->length
;
940 inode
->i_blksize
= sb
->s_blocksize
;
942 (inode
->i_size
+ inode
->i_blksize
- 1) >> sb
->s_blocksize_bits
;
946 * v9fs_qid2ino - convert qid into inode number
949 * BUG: potential for inode number collisions?
952 ino_t
v9fs_qid2ino(struct v9fs_qid
*qid
)
954 u64 path
= qid
->path
+ 2;
957 if (sizeof(ino_t
) == sizeof(path
))
958 memcpy(&i
, &path
, sizeof(ino_t
));
960 i
= (ino_t
) (path
^ (path
>> 32));
966 * v9fs_readlink - read a symlink's location (internal version)
967 * @dentry: dentry for symlink
968 * @buffer: buffer to load symlink location into
969 * @buflen: length of buffer
973 static int v9fs_readlink(struct dentry
*dentry
, char *buffer
, int buflen
)
977 struct v9fs_fcall
*fcall
= NULL
;
978 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
979 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
982 dprintk(DEBUG_ERROR
, "could not resolve fid from dentry\n");
987 if (!v9ses
->extended
) {
989 dprintk(DEBUG_ERROR
, "not extended\n");
993 dprintk(DEBUG_VFS
, " %s\n", dentry
->d_name
.name
);
994 retval
= v9fs_t_stat(v9ses
, fid
->fid
, &fcall
);
997 dprintk(DEBUG_ERROR
, "stat error\n");
1004 if (!(fcall
->params
.rstat
.stat
.mode
& V9FS_DMSYMLINK
)) {
1009 /* copy extension buffer into buffer */
1010 if (fcall
->params
.rstat
.stat
.extension
.len
< buflen
)
1011 buflen
= fcall
->params
.rstat
.stat
.extension
.len
;
1013 memcpy(buffer
, fcall
->params
.rstat
.stat
.extension
.str
, buflen
- 1);
1014 buffer
[buflen
-1] = 0;
1025 * v9fs_vfs_readlink - read a symlink's location
1026 * @dentry: dentry for symlink
1027 * @buf: buffer to load symlink location into
1028 * @buflen: length of buffer
1032 static int v9fs_vfs_readlink(struct dentry
*dentry
, char __user
* buffer
,
1037 char *link
= __getname();
1039 if (buflen
> PATH_MAX
)
1042 dprintk(DEBUG_VFS
, " dentry: %s (%p)\n", dentry
->d_iname
, dentry
);
1044 retval
= v9fs_readlink(dentry
, link
, buflen
);
1047 if ((ret
= copy_to_user(buffer
, link
, retval
)) != 0) {
1048 dprintk(DEBUG_ERROR
, "problem copying to user: %d\n",
1059 * v9fs_vfs_follow_link - follow a symlink path
1060 * @dentry: dentry for symlink
1065 static void *v9fs_vfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
1068 char *link
= __getname();
1070 dprintk(DEBUG_VFS
, "%s n", dentry
->d_name
.name
);
1073 link
= ERR_PTR(-ENOMEM
);
1075 len
= v9fs_readlink(dentry
, link
, strlen(link
));
1079 link
= ERR_PTR(len
);
1083 nd_set_link(nd
, link
);
1089 * v9fs_vfs_put_link - release a symlink path
1090 * @dentry: dentry for symlink
1095 static void v9fs_vfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
1097 char *s
= nd_get_link(nd
);
1099 dprintk(DEBUG_VFS
, " %s %s\n", dentry
->d_name
.name
, s
);
1104 static int v9fs_vfs_mkspecial(struct inode
*dir
, struct dentry
*dentry
,
1105 int mode
, const char *extension
)
1109 struct v9fs_session_info
*v9ses
;
1110 struct v9fs_fid
*dfid
, *vfid
;
1111 struct inode
*inode
;
1112 struct v9fs_fcall
*fcall
;
1113 struct v9fs_wstat wstat
;
1118 v9ses
= v9fs_inode2v9ses(dir
);
1119 dfid
= v9fs_fid_lookup(dentry
->d_parent
);
1120 perm
= unixmode2p9mode(v9ses
, mode
);
1122 if (!v9ses
->extended
) {
1123 dprintk(DEBUG_ERROR
, "not extended\n");
1127 err
= v9fs_create(v9ses
, dfid
->fid
, (char *) dentry
->d_name
.name
,
1128 perm
, V9FS_OREAD
, &fid
, NULL
, NULL
);
1133 err
= v9fs_t_clunk(v9ses
, fid
);
1137 vfid
= v9fs_clone_walk(v9ses
, dfid
->fid
, dentry
);
1139 err
= PTR_ERR(vfid
);
1144 inode
= v9fs_inode_from_fid(v9ses
, vfid
->fid
, dir
->i_sb
);
1145 if (IS_ERR(inode
)) {
1146 err
= PTR_ERR(inode
);
1151 /* issue a Twstat */
1152 v9fs_blank_wstat(&wstat
);
1153 wstat
.muid
= v9ses
->name
;
1154 wstat
.extension
= (char *) extension
;
1155 err
= v9fs_t_wstat(v9ses
, vfid
->fid
, &wstat
, &fcall
);
1157 PRINT_FCALL_ERROR("wstat error", fcall
);
1162 dentry
->d_op
= &v9fs_dentry_operations
;
1163 d_instantiate(dentry
, inode
);
1169 v9fs_fid_destroy(vfid
);
1179 * v9fs_vfs_symlink - helper function to create symlinks
1180 * @dir: directory inode containing symlink
1181 * @dentry: dentry for symlink
1182 * @symname: symlink data
1184 * See 9P2000.u RFC for more information
1189 v9fs_vfs_symlink(struct inode
*dir
, struct dentry
*dentry
, const char *symname
)
1191 dprintk(DEBUG_VFS
, " %lu,%s,%s\n", dir
->i_ino
, dentry
->d_name
.name
,
1194 return v9fs_vfs_mkspecial(dir
, dentry
, S_IFLNK
, symname
);
1198 * v9fs_vfs_link - create a hardlink
1199 * @old_dentry: dentry for file to link to
1200 * @dir: inode destination for new link
1201 * @dentry: dentry for link
1205 /* XXX - lots of code dup'd from symlink and creates,
1206 * figure out a better reuse strategy
1210 v9fs_vfs_link(struct dentry
*old_dentry
, struct inode
*dir
,
1211 struct dentry
*dentry
)
1214 struct v9fs_fid
*oldfid
;
1217 dprintk(DEBUG_VFS
, " %lu,%s,%s\n", dir
->i_ino
, dentry
->d_name
.name
,
1218 old_dentry
->d_name
.name
);
1220 oldfid
= v9fs_fid_lookup(old_dentry
);
1222 dprintk(DEBUG_ERROR
, "can't find oldfid\n");
1227 sprintf(name
, "hardlink(%d)\n", oldfid
->fid
);
1228 retval
= v9fs_vfs_mkspecial(dir
, dentry
, V9FS_DMLINK
, name
);
1235 * v9fs_vfs_mknod - create a special file
1236 * @dir: inode destination for new link
1237 * @dentry: dentry for file
1238 * @mode: mode for creation
1239 * @dev_t: device associated with special file
1244 v9fs_vfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t rdev
)
1249 dprintk(DEBUG_VFS
, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir
->i_ino
,
1250 dentry
->d_name
.name
, mode
, MAJOR(rdev
), MINOR(rdev
));
1252 if (!new_valid_dev(rdev
))
1256 /* build extension */
1258 sprintf(name
, "b %u %u", MAJOR(rdev
), MINOR(rdev
));
1259 else if (S_ISCHR(mode
))
1260 sprintf(name
, "c %u %u", MAJOR(rdev
), MINOR(rdev
));
1261 else if (S_ISFIFO(mode
))
1268 retval
= v9fs_vfs_mkspecial(dir
, dentry
, mode
, name
);
1274 static struct inode_operations v9fs_dir_inode_operations_ext
= {
1275 .create
= v9fs_vfs_create
,
1276 .lookup
= v9fs_vfs_lookup
,
1277 .symlink
= v9fs_vfs_symlink
,
1278 .link
= v9fs_vfs_link
,
1279 .unlink
= v9fs_vfs_unlink
,
1280 .mkdir
= v9fs_vfs_mkdir
,
1281 .rmdir
= v9fs_vfs_rmdir
,
1282 .mknod
= v9fs_vfs_mknod
,
1283 .rename
= v9fs_vfs_rename
,
1284 .readlink
= v9fs_vfs_readlink
,
1285 .getattr
= v9fs_vfs_getattr
,
1286 .setattr
= v9fs_vfs_setattr
,
1289 static struct inode_operations v9fs_dir_inode_operations
= {
1290 .create
= v9fs_vfs_create
,
1291 .lookup
= v9fs_vfs_lookup
,
1292 .unlink
= v9fs_vfs_unlink
,
1293 .mkdir
= v9fs_vfs_mkdir
,
1294 .rmdir
= v9fs_vfs_rmdir
,
1295 .mknod
= v9fs_vfs_mknod
,
1296 .rename
= v9fs_vfs_rename
,
1297 .getattr
= v9fs_vfs_getattr
,
1298 .setattr
= v9fs_vfs_setattr
,
1301 static struct inode_operations v9fs_file_inode_operations
= {
1302 .getattr
= v9fs_vfs_getattr
,
1303 .setattr
= v9fs_vfs_setattr
,
1306 static struct inode_operations v9fs_symlink_inode_operations
= {
1307 .readlink
= v9fs_vfs_readlink
,
1308 .follow_link
= v9fs_vfs_follow_link
,
1309 .put_link
= v9fs_vfs_put_link
,
1310 .getattr
= v9fs_vfs_getattr
,
1311 .setattr
= v9fs_vfs_setattr
,