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>
46 static struct inode_operations v9fs_dir_inode_operations
;
47 static struct inode_operations v9fs_dir_inode_operations_ext
;
48 static struct inode_operations v9fs_file_inode_operations
;
49 static struct inode_operations v9fs_symlink_inode_operations
;
52 * unixmode2p9mode - convert unix mode bits to plan 9
53 * @v9ses: v9fs session information
54 * @mode: mode to convert
58 static int unixmode2p9mode(struct v9fs_session_info
*v9ses
, int mode
)
64 if (v9ses
->extended
) {
66 res
|= V9FS_DMSYMLINK
;
67 if (v9ses
->nodev
== 0) {
71 res
|= V9FS_DMNAMEDPIPE
;
78 if ((mode
& S_ISUID
) == S_ISUID
)
80 if ((mode
& S_ISGID
) == S_ISGID
)
82 if ((mode
& V9FS_DMLINK
))
90 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
91 * @v9ses: v9fs session information
92 * @mode: mode to convert
96 static int p9mode2unixmode(struct v9fs_session_info
*v9ses
, int mode
)
102 if ((mode
& V9FS_DMDIR
) == V9FS_DMDIR
)
104 else if ((mode
& V9FS_DMSYMLINK
) && (v9ses
->extended
))
106 else if ((mode
& V9FS_DMSOCKET
) && (v9ses
->extended
)
107 && (v9ses
->nodev
== 0))
109 else if ((mode
& V9FS_DMNAMEDPIPE
) && (v9ses
->extended
)
110 && (v9ses
->nodev
== 0))
112 else if ((mode
& V9FS_DMDEVICE
) && (v9ses
->extended
)
113 && (v9ses
->nodev
== 0))
118 if (v9ses
->extended
) {
119 if ((mode
& V9FS_DMSETUID
) == V9FS_DMSETUID
)
122 if ((mode
& V9FS_DMSETGID
) == V9FS_DMSETGID
)
130 * v9fs_blank_mistat - helper function to setup a 9P stat structure
131 * @v9ses: 9P session info (for determining extended mode)
132 * @mistat: structure to initialize
137 v9fs_blank_mistat(struct v9fs_session_info
*v9ses
, struct v9fs_stat
*mistat
)
141 mistat
->qid
.type
= ~0;
142 mistat
->qid
.version
= ~0;
143 *((long long *)&mistat
->qid
.path
) = ~0;
148 mistat
->name
= mistat
->data
;
149 mistat
->uid
= mistat
->data
;
150 mistat
->gid
= mistat
->data
;
151 mistat
->muid
= mistat
->data
;
152 if (v9ses
->extended
) {
156 mistat
->extension
= mistat
->data
;
162 * v9fs_mistat2unix - convert mistat to unix stat
163 * @mistat: Plan 9 metadata (mistat) structure
164 * @buf: unix metadata (stat) structure to populate
170 v9fs_mistat2unix(struct v9fs_stat
*mistat
, struct stat
*buf
,
171 struct super_block
*sb
)
173 struct v9fs_session_info
*v9ses
= sb
? sb
->s_fs_info
: NULL
;
177 buf
->st_atime
= mistat
->atime
;
178 buf
->st_mtime
= mistat
->mtime
;
179 buf
->st_ctime
= mistat
->mtime
;
181 buf
->st_uid
= (unsigned short)-1;
182 buf
->st_gid
= (unsigned short)-1;
184 if (v9ses
&& v9ses
->extended
) {
185 /* TODO: string to uid mapping via user-space daemon */
186 if (mistat
->n_uid
!= -1)
187 sscanf(mistat
->uid
, "%x", (unsigned int *)&buf
->st_uid
);
189 if (mistat
->n_gid
!= -1)
190 sscanf(mistat
->gid
, "%x", (unsigned int *)&buf
->st_gid
);
193 if (buf
->st_uid
== (unsigned short)-1)
194 buf
->st_uid
= v9ses
->uid
;
195 if (buf
->st_gid
== (unsigned short)-1)
196 buf
->st_gid
= v9ses
->gid
;
198 buf
->st_mode
= p9mode2unixmode(v9ses
, mistat
->mode
);
199 if ((S_ISBLK(buf
->st_mode
)) || (S_ISCHR(buf
->st_mode
))) {
203 sscanf(mistat
->extension
, "%c %u %u", &type
, &major
, &minor
);
206 buf
->st_mode
&= ~S_IFBLK
;
207 buf
->st_mode
|= S_IFCHR
;
212 dprintk(DEBUG_ERROR
, "Unknown special type %c (%s)\n",
213 type
, mistat
->extension
);
215 buf
->st_rdev
= MKDEV(major
, minor
);
219 buf
->st_size
= mistat
->length
;
221 buf
->st_blksize
= sb
->s_blocksize
;
223 (buf
->st_size
+ buf
->st_blksize
- 1) >> sb
->s_blocksize_bits
;
227 * v9fs_get_inode - helper function to setup an inode
229 * @mode: mode to setup inode with
233 struct inode
*v9fs_get_inode(struct super_block
*sb
, int mode
)
235 struct inode
*inode
= NULL
;
236 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
238 dprintk(DEBUG_VFS
, "super block: %p mode: %o\n", sb
, mode
);
240 inode
= new_inode(sb
);
242 inode
->i_mode
= mode
;
243 inode
->i_uid
= current
->fsuid
;
244 inode
->i_gid
= current
->fsgid
;
245 inode
->i_blksize
= sb
->s_blocksize
;
248 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
250 switch (mode
& S_IFMT
) {
255 if(!v9ses
->extended
) {
256 dprintk(DEBUG_ERROR
, "special files without extended mode\n");
257 return ERR_PTR(-EINVAL
);
259 init_special_inode(inode
, inode
->i_mode
,
263 inode
->i_op
= &v9fs_file_inode_operations
;
264 inode
->i_fop
= &v9fs_file_operations
;
267 if(!v9ses
->extended
) {
268 dprintk(DEBUG_ERROR
, "extended modes used w/o 9P2000.u\n");
269 return ERR_PTR(-EINVAL
);
271 inode
->i_op
= &v9fs_symlink_inode_operations
;
276 inode
->i_op
= &v9fs_dir_inode_operations_ext
;
278 inode
->i_op
= &v9fs_dir_inode_operations
;
279 inode
->i_fop
= &v9fs_dir_operations
;
282 dprintk(DEBUG_ERROR
, "BAD mode 0x%x S_IFMT 0x%x\n",
283 mode
, mode
& S_IFMT
);
284 return ERR_PTR(-EINVAL
);
287 eprintk(KERN_WARNING
, "Problem allocating inode\n");
288 return ERR_PTR(-ENOMEM
);
294 * v9fs_create - helper function to create files and directories
295 * @dir: directory inode file is being created in
296 * @file_dentry: dentry file is being created in
297 * @perm: permissions file is being created with
298 * @open_mode: resulting open mode for file
303 v9fs_create(struct inode
*dir
,
304 struct dentry
*file_dentry
,
305 unsigned int perm
, unsigned int open_mode
)
307 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dir
);
308 struct super_block
*sb
= dir
->i_sb
;
309 struct v9fs_fid
*dirfid
=
310 v9fs_fid_lookup(file_dentry
->d_parent
);
311 struct v9fs_fid
*fid
= NULL
;
312 struct inode
*file_inode
= NULL
;
313 struct v9fs_fcall
*fcall
= NULL
;
319 unsigned int iounit
= 0;
323 perm
= unixmode2p9mode(v9ses
, perm
);
325 dprintk(DEBUG_VFS
, "dir: %p dentry: %p perm: %o mode: %o\n", dir
,
326 file_dentry
, perm
, open_mode
);
331 dirfidnum
= dirfid
->fid
;
333 dprintk(DEBUG_ERROR
, "No fid for the directory #%lu\n",
338 if (file_dentry
->d_inode
) {
340 "Odd. There is an inode for dir %lu, name :%s:\n",
341 dir
->i_ino
, file_dentry
->d_name
.name
);
345 newfid
= v9fs_get_idpool(&v9ses
->fidpool
);
347 eprintk(KERN_WARNING
, "no free fids available\n");
351 result
= v9fs_t_walk(v9ses
, dirfidnum
, newfid
, NULL
, &fcall
);
353 dprintk(DEBUG_ERROR
, "clone error: %s\n", FCALL_ERROR(fcall
));
354 v9fs_put_idpool(newfid
, &v9ses
->fidpool
);
362 result
= v9fs_t_create(v9ses
, newfid
, (char *)file_dentry
->d_name
.name
,
363 perm
, open_mode
, &fcall
);
365 dprintk(DEBUG_ERROR
, "create fails: %s(%d)\n",
366 FCALL_ERROR(fcall
), result
);
371 iounit
= fcall
->params
.rcreate
.iounit
;
372 qid
= fcall
->params
.rcreate
.qid
;
376 if (!(perm
&V9FS_DMDIR
)) {
377 fid
= v9fs_fid_create(file_dentry
, v9ses
, newfid
, 1);
378 dprintk(DEBUG_VFS
, "fid %p %d\n", fid
, fid
->fidcreate
);
385 fid
->iounit
= iounit
;
387 err
= v9fs_t_clunk(v9ses
, newfid
);
390 dprintk(DEBUG_ERROR
, "clunk for mkdir failed: %d\n", err
);
393 /* walk to the newly created file and put the fid in the dentry */
394 wfidno
= v9fs_get_idpool(&v9ses
->fidpool
);
396 eprintk(KERN_WARNING
, "no free fids available\n");
400 result
= v9fs_t_walk(v9ses
, dirfidnum
, wfidno
,
401 (char *) file_dentry
->d_name
.name
, &fcall
);
403 dprintk(DEBUG_ERROR
, "clone error: %s\n", FCALL_ERROR(fcall
));
404 v9fs_put_idpool(wfidno
, &v9ses
->fidpool
);
411 if (!v9fs_fid_create(file_dentry
, v9ses
, wfidno
, 0)) {
412 v9fs_put_idpool(wfidno
, &v9ses
->fidpool
);
417 if ((perm
& V9FS_DMSYMLINK
) || (perm
& V9FS_DMLINK
) ||
418 (perm
& V9FS_DMNAMEDPIPE
) || (perm
& V9FS_DMSOCKET
) ||
419 (perm
& V9FS_DMDEVICE
))
422 result
= v9fs_t_stat(v9ses
, wfidno
, &fcall
);
424 dprintk(DEBUG_ERROR
, "stat error: %s(%d)\n", FCALL_ERROR(fcall
),
429 v9fs_mistat2unix(fcall
->params
.rstat
.stat
, &newstat
, sb
);
431 file_inode
= v9fs_get_inode(sb
, newstat
.st_mode
);
432 if ((!file_inode
) || IS_ERR(file_inode
)) {
433 dprintk(DEBUG_ERROR
, "create inode failed\n");
438 v9fs_mistat2inode(fcall
->params
.rstat
.stat
, file_inode
, sb
);
441 file_dentry
->d_op
= &v9fs_dentry_operations
;
442 d_instantiate(file_dentry
, file_inode
);
451 err
= v9fs_t_clunk(v9ses
, newfid
);
453 dprintk(DEBUG_ERROR
, "clunk failed: %d\n", err
);
456 err
= v9fs_t_clunk(v9ses
, wfidno
);
458 dprintk(DEBUG_ERROR
, "clunk failed: %d\n", err
);
464 * v9fs_remove - helper function to remove files and directories
465 * @dir: directory inode that is being deleted
466 * @file: dentry that is being deleted
467 * @rmdir: removing a directory
471 static int v9fs_remove(struct inode
*dir
, struct dentry
*file
, int rmdir
)
473 struct v9fs_fcall
*fcall
= NULL
;
474 struct super_block
*sb
= NULL
;
475 struct v9fs_session_info
*v9ses
= NULL
;
476 struct v9fs_fid
*v9fid
= NULL
;
477 struct inode
*file_inode
= NULL
;
481 dprintk(DEBUG_VFS
, "inode: %p dentry: %p rmdir: %d\n", dir
, file
,
484 file_inode
= file
->d_inode
;
485 sb
= file_inode
->i_sb
;
486 v9ses
= v9fs_inode2v9ses(file_inode
);
487 v9fid
= v9fs_fid_lookup(file
);
497 dprintk(DEBUG_ERROR
, "inode #%lu, no fid!\n",
502 result
= v9fs_t_remove(v9ses
, fid
, &fcall
);
504 dprintk(DEBUG_ERROR
, "remove of file fails: %s(%d)\n",
505 FCALL_ERROR(fcall
), result
);
507 v9fs_put_idpool(fid
, &v9ses
->fidpool
);
508 v9fs_fid_destroy(v9fid
);
516 * v9fs_vfs_create - VFS hook to create files
517 * @inode: directory inode that is being deleted
518 * @dentry: dentry that is being deleted
519 * @perm: create permissions
520 * @nd: path information
525 v9fs_vfs_create(struct inode
*inode
, struct dentry
*dentry
, int perm
,
526 struct nameidata
*nd
)
528 return v9fs_create(inode
, dentry
, perm
, O_RDWR
);
532 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
533 * @inode: inode that is being unlinked
534 * @dentry: dentry that is being unlinked
535 * @mode: mode for new directory
539 static int v9fs_vfs_mkdir(struct inode
*inode
, struct dentry
*dentry
, int mode
)
541 return v9fs_create(inode
, dentry
, mode
| S_IFDIR
, O_RDONLY
);
545 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
546 * @dir: inode that is being walked from
547 * @dentry: dentry that is being walked to?
548 * @nameidata: path data
552 static struct dentry
*v9fs_vfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
553 struct nameidata
*nameidata
)
555 struct super_block
*sb
;
556 struct v9fs_session_info
*v9ses
;
557 struct v9fs_fid
*dirfid
;
558 struct v9fs_fid
*fid
;
560 struct v9fs_fcall
*fcall
= NULL
;
566 dprintk(DEBUG_VFS
, "dir: %p dentry: (%s) %p nameidata: %p\n",
567 dir
, dentry
->d_iname
, dentry
, nameidata
);
570 v9ses
= v9fs_inode2v9ses(dir
);
571 dirfid
= v9fs_fid_lookup(dentry
->d_parent
);
574 dprintk(DEBUG_ERROR
, "no dirfid\n");
575 return ERR_PTR(-EINVAL
);
578 dirfidnum
= dirfid
->fid
;
581 dprintk(DEBUG_ERROR
, "no dirfid for inode %p, #%lu\n",
583 return ERR_PTR(-EBADF
);
586 newfid
= v9fs_get_idpool(&v9ses
->fidpool
);
588 eprintk(KERN_WARNING
, "newfid fails!\n");
589 return ERR_PTR(-ENOSPC
);
593 v9fs_t_walk(v9ses
, dirfidnum
, newfid
, (char *)dentry
->d_name
.name
,
596 v9fs_put_idpool(newfid
, &v9ses
->fidpool
);
597 if (result
== -ENOENT
) {
600 "Return negative dentry %p count %d\n",
601 dentry
, atomic_read(&dentry
->d_count
));
604 dprintk(DEBUG_ERROR
, "walk error:%d\n", result
);
608 result
= v9fs_t_stat(v9ses
, newfid
, &fcall
);
610 dprintk(DEBUG_ERROR
, "stat error\n");
614 v9fs_mistat2unix(fcall
->params
.rstat
.stat
, &newstat
, sb
);
615 inode
= v9fs_get_inode(sb
, newstat
.st_mode
);
617 if (IS_ERR(inode
) && (PTR_ERR(inode
) == -ENOSPC
)) {
618 eprintk(KERN_WARNING
, "inode alloc failes, returns %ld\n",
625 inode
->i_ino
= v9fs_qid2ino(&fcall
->params
.rstat
.stat
->qid
);
627 fid
= v9fs_fid_create(dentry
, v9ses
, newfid
, 0);
629 dprintk(DEBUG_ERROR
, "couldn't insert\n");
634 fid
->qid
= fcall
->params
.rstat
.stat
->qid
;
636 dentry
->d_op
= &v9fs_dentry_operations
;
637 v9fs_mistat2inode(fcall
->params
.rstat
.stat
, inode
, inode
->i_sb
);
639 d_add(dentry
, inode
);
646 return ERR_PTR(result
);
650 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
651 * @i: inode that is being unlinked
652 * @d: dentry that is being unlinked
656 static int v9fs_vfs_unlink(struct inode
*i
, struct dentry
*d
)
658 return v9fs_remove(i
, d
, 0);
662 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
663 * @i: inode that is being unlinked
664 * @d: dentry that is being unlinked
668 static int v9fs_vfs_rmdir(struct inode
*i
, struct dentry
*d
)
670 return v9fs_remove(i
, d
, 1);
674 * v9fs_vfs_rename - VFS hook to rename an inode
675 * @old_dir: old dir inode
676 * @old_dentry: old dentry
677 * @new_dir: new dir inode
678 * @new_dentry: new dentry
683 v9fs_vfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
684 struct inode
*new_dir
, struct dentry
*new_dentry
)
686 struct inode
*old_inode
= old_dentry
->d_inode
;
687 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(old_inode
);
688 struct v9fs_fid
*oldfid
= v9fs_fid_lookup(old_dentry
);
689 struct v9fs_fid
*olddirfid
=
690 v9fs_fid_lookup(old_dentry
->d_parent
);
691 struct v9fs_fid
*newdirfid
=
692 v9fs_fid_lookup(new_dentry
->d_parent
);
693 struct v9fs_stat
*mistat
= kmalloc(v9ses
->maxdata
, GFP_KERNEL
);
694 struct v9fs_fcall
*fcall
= NULL
;
696 int olddirfidnum
= -1;
697 int newdirfidnum
= -1;
700 dprintk(DEBUG_VFS
, "\n");
705 if ((!oldfid
) || (!olddirfid
) || (!newdirfid
)) {
706 dprintk(DEBUG_ERROR
, "problem with arguments\n");
710 /* 9P can only handle file rename in the same directory */
711 if (memcmp(&olddirfid
->qid
, &newdirfid
->qid
, sizeof(newdirfid
->qid
))) {
712 dprintk(DEBUG_ERROR
, "old dir and new dir are different\n");
718 olddirfidnum
= olddirfid
->fid
;
719 newdirfidnum
= newdirfid
->fid
;
722 dprintk(DEBUG_ERROR
, "no fid for old file #%lu\n",
728 v9fs_blank_mistat(v9ses
, mistat
);
730 strcpy(mistat
->data
+ 1, v9ses
->name
);
731 mistat
->name
= mistat
->data
+ 1 + strlen(v9ses
->name
);
733 if (new_dentry
->d_name
.len
>
734 (v9ses
->maxdata
- strlen(v9ses
->name
) - sizeof(struct v9fs_stat
))) {
735 dprintk(DEBUG_ERROR
, "new name too long\n");
739 strcpy(mistat
->name
, new_dentry
->d_name
.name
);
740 retval
= v9fs_t_wstat(v9ses
, fid
, mistat
, &fcall
);
746 dprintk(DEBUG_ERROR
, "v9fs_t_wstat error: %s\n",
754 * v9fs_vfs_getattr - retreive file metadata
755 * @mnt - mount information
756 * @dentry - file to get attributes on
757 * @stat - metadata structure to populate
762 v9fs_vfs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
765 struct v9fs_fcall
*fcall
= NULL
;
766 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
767 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
770 dprintk(DEBUG_VFS
, "dentry: %p\n", dentry
);
773 "couldn't find fid associated with dentry\n");
777 err
= v9fs_t_stat(v9ses
, fid
->fid
, &fcall
);
780 dprintk(DEBUG_ERROR
, "stat error\n");
782 v9fs_mistat2inode(fcall
->params
.rstat
.stat
, dentry
->d_inode
,
783 dentry
->d_inode
->i_sb
);
784 generic_fillattr(dentry
->d_inode
, stat
);
792 * v9fs_vfs_setattr - set file metadata
793 * @dentry: file whose metadata to set
794 * @iattr: metadata assignment structure
798 static int v9fs_vfs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
800 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
801 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
802 struct v9fs_fcall
*fcall
= NULL
;
803 struct v9fs_stat
*mistat
= kmalloc(v9ses
->maxdata
, GFP_KERNEL
);
806 dprintk(DEBUG_VFS
, "\n");
813 "Couldn't find fid associated with dentry\n");
817 v9fs_blank_mistat(v9ses
, mistat
);
818 if (iattr
->ia_valid
& ATTR_MODE
)
819 mistat
->mode
= unixmode2p9mode(v9ses
, iattr
->ia_mode
);
821 if (iattr
->ia_valid
& ATTR_MTIME
)
822 mistat
->mtime
= iattr
->ia_mtime
.tv_sec
;
824 if (iattr
->ia_valid
& ATTR_ATIME
)
825 mistat
->atime
= iattr
->ia_atime
.tv_sec
;
827 if (iattr
->ia_valid
& ATTR_SIZE
)
828 mistat
->length
= iattr
->ia_size
;
830 if (v9ses
->extended
) {
831 char *ptr
= mistat
->data
+1;
833 if (iattr
->ia_valid
& ATTR_UID
) {
835 ptr
+= 1+sprintf(ptr
, "%08x", iattr
->ia_uid
);
836 mistat
->n_uid
= iattr
->ia_uid
;
839 if (iattr
->ia_valid
& ATTR_GID
) {
841 ptr
+= 1+sprintf(ptr
, "%08x", iattr
->ia_gid
);
842 mistat
->n_gid
= iattr
->ia_gid
;
846 res
= v9fs_t_wstat(v9ses
, fid
->fid
, mistat
, &fcall
);
849 dprintk(DEBUG_ERROR
, "wstat error: %s\n", FCALL_ERROR(fcall
));
855 res
= inode_setattr(dentry
->d_inode
, iattr
);
861 * v9fs_mistat2inode - populate an inode structure with mistat info
862 * @mistat: Plan 9 metadata (mistat) structure
863 * @inode: inode to populate
864 * @sb: superblock of filesystem
869 v9fs_mistat2inode(struct v9fs_stat
*mistat
, struct inode
*inode
,
870 struct super_block
*sb
)
872 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
876 inode
->i_atime
.tv_sec
= mistat
->atime
;
877 inode
->i_mtime
.tv_sec
= mistat
->mtime
;
878 inode
->i_ctime
.tv_sec
= mistat
->mtime
;
883 if (v9ses
->extended
) {
884 /* TODO: string to uid mapping via user-space daemon */
885 inode
->i_uid
= mistat
->n_uid
;
886 inode
->i_gid
= mistat
->n_gid
;
888 if (mistat
->n_uid
== -1)
889 sscanf(mistat
->uid
, "%x", &inode
->i_uid
);
891 if (mistat
->n_gid
== -1)
892 sscanf(mistat
->gid
, "%x", &inode
->i_gid
);
895 if (inode
->i_uid
== -1)
896 inode
->i_uid
= v9ses
->uid
;
897 if (inode
->i_gid
== -1)
898 inode
->i_gid
= v9ses
->gid
;
900 inode
->i_mode
= p9mode2unixmode(v9ses
, mistat
->mode
);
901 if ((S_ISBLK(inode
->i_mode
)) || (S_ISCHR(inode
->i_mode
))) {
905 sscanf(mistat
->extension
, "%c %u %u", &type
, &major
, &minor
);
908 inode
->i_mode
&= ~S_IFBLK
;
909 inode
->i_mode
|= S_IFCHR
;
914 dprintk(DEBUG_ERROR
, "Unknown special type %c (%s)\n",
915 type
, mistat
->extension
);
917 inode
->i_rdev
= MKDEV(major
, minor
);
921 inode
->i_size
= mistat
->length
;
923 inode
->i_blksize
= sb
->s_blocksize
;
925 (inode
->i_size
+ inode
->i_blksize
- 1) >> sb
->s_blocksize_bits
;
929 * v9fs_qid2ino - convert qid into inode number
932 * BUG: potential for inode number collisions?
935 ino_t
v9fs_qid2ino(struct v9fs_qid
*qid
)
937 u64 path
= qid
->path
+ 2;
940 if (sizeof(ino_t
) == sizeof(path
))
941 memcpy(&i
, &path
, sizeof(ino_t
));
943 i
= (ino_t
) (path
^ (path
>> 32));
949 * v9fs_vfs_symlink - helper function to create symlinks
950 * @dir: directory inode containing symlink
951 * @dentry: dentry for symlink
952 * @symname: symlink data
954 * See 9P2000.u RFC for more information
959 v9fs_vfs_symlink(struct inode
*dir
, struct dentry
*dentry
, const char *symname
)
962 struct v9fs_fid
*newfid
;
963 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dir
);
964 struct v9fs_fcall
*fcall
= NULL
;
965 struct v9fs_stat
*mistat
= kmalloc(v9ses
->maxdata
, GFP_KERNEL
);
968 dprintk(DEBUG_VFS
, " %lu,%s,%s\n", dir
->i_ino
, dentry
->d_name
.name
,
974 if (!v9ses
->extended
) {
975 dprintk(DEBUG_ERROR
, "not extended\n");
980 retval
= v9fs_create(dir
, dentry
, S_IFLNK
, 0);
984 newfid
= v9fs_fid_lookup(dentry
);
987 v9fs_blank_mistat(v9ses
, mistat
);
988 strcpy(mistat
->data
+ 1, symname
);
989 mistat
->extension
= mistat
->data
+ 1;
990 retval
= v9fs_t_wstat(v9ses
, newfid
->fid
, mistat
, &fcall
);
992 dprintk(DEBUG_ERROR
, "v9fs_t_wstat error: %s\n",
999 err
= v9fs_t_clunk(v9ses
, newfid
->fid
);
1001 dprintk(DEBUG_ERROR
, "clunk for symlink failed: %d\n", err
);
1005 d_drop(dentry
); /* FID - will this also clunk? */
1015 * v9fs_readlink - read a symlink's location (internal version)
1016 * @dentry: dentry for symlink
1017 * @buffer: buffer to load symlink location into
1018 * @buflen: length of buffer
1022 static int v9fs_readlink(struct dentry
*dentry
, char *buffer
, int buflen
)
1024 int retval
= -EPERM
;
1026 struct v9fs_fcall
*fcall
= NULL
;
1027 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
1028 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
1031 dprintk(DEBUG_ERROR
, "could not resolve fid from dentry\n");
1036 if (!v9ses
->extended
) {
1038 dprintk(DEBUG_ERROR
, "not extended\n");
1042 dprintk(DEBUG_VFS
, " %s\n", dentry
->d_name
.name
);
1043 retval
= v9fs_t_stat(v9ses
, fid
->fid
, &fcall
);
1046 dprintk(DEBUG_ERROR
, "stat error\n");
1053 if (!(fcall
->params
.rstat
.stat
->mode
& V9FS_DMSYMLINK
)) {
1058 /* copy extension buffer into buffer */
1059 if (strlen(fcall
->params
.rstat
.stat
->extension
) < buflen
)
1060 buflen
= strlen(fcall
->params
.rstat
.stat
->extension
);
1062 memcpy(buffer
, fcall
->params
.rstat
.stat
->extension
, buflen
+ 1);
1073 * v9fs_vfs_readlink - read a symlink's location
1074 * @dentry: dentry for symlink
1075 * @buf: buffer to load symlink location into
1076 * @buflen: length of buffer
1080 static int v9fs_vfs_readlink(struct dentry
*dentry
, char __user
* buffer
,
1085 char *link
= __getname();
1087 if (buflen
> PATH_MAX
)
1090 dprintk(DEBUG_VFS
, " dentry: %s (%p)\n", dentry
->d_iname
, dentry
);
1092 retval
= v9fs_readlink(dentry
, link
, buflen
);
1095 if ((ret
= copy_to_user(buffer
, link
, retval
)) != 0) {
1096 dprintk(DEBUG_ERROR
, "problem copying to user: %d\n",
1107 * v9fs_vfs_follow_link - follow a symlink path
1108 * @dentry: dentry for symlink
1113 static void *v9fs_vfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
1116 char *link
= __getname();
1118 dprintk(DEBUG_VFS
, "%s n", dentry
->d_name
.name
);
1121 link
= ERR_PTR(-ENOMEM
);
1123 len
= v9fs_readlink(dentry
, link
, strlen(link
));
1127 link
= ERR_PTR(len
);
1131 nd_set_link(nd
, link
);
1137 * v9fs_vfs_put_link - release a symlink path
1138 * @dentry: dentry for symlink
1143 static void v9fs_vfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
1145 char *s
= nd_get_link(nd
);
1147 dprintk(DEBUG_VFS
, " %s %s\n", dentry
->d_name
.name
, s
);
1153 * v9fs_vfs_link - create a hardlink
1154 * @old_dentry: dentry for file to link to
1155 * @dir: inode destination for new link
1156 * @dentry: dentry for link
1160 /* XXX - lots of code dup'd from symlink and creates,
1161 * figure out a better reuse strategy
1165 v9fs_vfs_link(struct dentry
*old_dentry
, struct inode
*dir
,
1166 struct dentry
*dentry
)
1168 int retval
= -EPERM
;
1169 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dir
);
1170 struct v9fs_fcall
*fcall
= NULL
;
1171 struct v9fs_stat
*mistat
= kmalloc(v9ses
->maxdata
, GFP_KERNEL
);
1172 struct v9fs_fid
*oldfid
= v9fs_fid_lookup(old_dentry
);
1173 struct v9fs_fid
*newfid
= NULL
;
1174 char *symname
= __getname();
1177 dprintk(DEBUG_VFS
, " %lu,%s,%s\n", dir
->i_ino
, dentry
->d_name
.name
,
1178 old_dentry
->d_name
.name
);
1180 if (!v9ses
->extended
) {
1181 dprintk(DEBUG_ERROR
, "not extended\n");
1185 /* get fid of old_dentry */
1186 sprintf(symname
, "hardlink(%d)\n", oldfid
->fid
);
1188 /* issue a create */
1189 retval
= v9fs_create(dir
, dentry
, V9FS_DMLINK
, 0);
1193 newfid
= v9fs_fid_lookup(dentry
);
1195 dprintk(DEBUG_ERROR
, "couldn't resolve fid from dentry\n");
1199 /* issue a twstat */
1200 v9fs_blank_mistat(v9ses
, mistat
);
1201 strcpy(mistat
->data
+ 1, symname
);
1202 mistat
->extension
= mistat
->data
+ 1;
1203 retval
= v9fs_t_wstat(v9ses
, newfid
->fid
, mistat
, &fcall
);
1205 dprintk(DEBUG_ERROR
, "v9fs_t_wstat error: %s\n",
1206 FCALL_ERROR(fcall
));
1212 err
= v9fs_t_clunk(v9ses
, newfid
->fid
);
1215 dprintk(DEBUG_ERROR
, "clunk for symlink failed: %d\n", err
);
1219 d_drop(dentry
); /* FID - will this also clunk? */
1232 * v9fs_vfs_mknod - create a special file
1233 * @dir: inode destination for new link
1234 * @dentry: dentry for file
1235 * @mode: mode for creation
1236 * @dev_t: device associated with special file
1241 v9fs_vfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t rdev
)
1243 int retval
= -EPERM
;
1244 struct v9fs_fid
*newfid
;
1245 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dir
);
1246 struct v9fs_fcall
*fcall
= NULL
;
1247 struct v9fs_stat
*mistat
= kmalloc(v9ses
->maxdata
, GFP_KERNEL
);
1248 char *symname
= __getname();
1251 dprintk(DEBUG_VFS
, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir
->i_ino
,
1252 dentry
->d_name
.name
, mode
, MAJOR(rdev
), MINOR(rdev
));
1257 if (!new_valid_dev(rdev
)) {
1262 if (!v9ses
->extended
) {
1263 dprintk(DEBUG_ERROR
, "not extended\n");
1267 /* issue a create */
1268 retval
= v9fs_create(dir
, dentry
, mode
, 0);
1273 newfid
= v9fs_fid_lookup(dentry
);
1275 dprintk(DEBUG_ERROR
, "coudn't resove fid from dentry\n");
1280 /* build extension */
1282 sprintf(symname
, "b %u %u", MAJOR(rdev
), MINOR(rdev
));
1283 else if (S_ISCHR(mode
))
1284 sprintf(symname
, "c %u %u", MAJOR(rdev
), MINOR(rdev
));
1285 else if (S_ISFIFO(mode
))
1292 if (!S_ISFIFO(mode
)) {
1293 /* issue a twstat */
1294 v9fs_blank_mistat(v9ses
, mistat
);
1295 strcpy(mistat
->data
+ 1, symname
);
1296 mistat
->extension
= mistat
->data
+ 1;
1297 retval
= v9fs_t_wstat(v9ses
, newfid
->fid
, mistat
, &fcall
);
1299 dprintk(DEBUG_ERROR
, "v9fs_t_wstat error: %s\n",
1300 FCALL_ERROR(fcall
));
1305 /* need to update dcache so we show up */
1308 err
= v9fs_t_clunk(v9ses
, newfid
->fid
);
1310 dprintk(DEBUG_ERROR
, "clunk for symlink failed: %d\n", err
);
1314 d_drop(dentry
); /* FID - will this also clunk? */
1324 static struct inode_operations v9fs_dir_inode_operations_ext
= {
1325 .create
= v9fs_vfs_create
,
1326 .lookup
= v9fs_vfs_lookup
,
1327 .symlink
= v9fs_vfs_symlink
,
1328 .link
= v9fs_vfs_link
,
1329 .unlink
= v9fs_vfs_unlink
,
1330 .mkdir
= v9fs_vfs_mkdir
,
1331 .rmdir
= v9fs_vfs_rmdir
,
1332 .mknod
= v9fs_vfs_mknod
,
1333 .rename
= v9fs_vfs_rename
,
1334 .readlink
= v9fs_vfs_readlink
,
1335 .getattr
= v9fs_vfs_getattr
,
1336 .setattr
= v9fs_vfs_setattr
,
1339 static struct inode_operations v9fs_dir_inode_operations
= {
1340 .create
= v9fs_vfs_create
,
1341 .lookup
= v9fs_vfs_lookup
,
1342 .unlink
= v9fs_vfs_unlink
,
1343 .mkdir
= v9fs_vfs_mkdir
,
1344 .rmdir
= v9fs_vfs_rmdir
,
1345 .mknod
= v9fs_vfs_mknod
,
1346 .rename
= v9fs_vfs_rename
,
1347 .getattr
= v9fs_vfs_getattr
,
1348 .setattr
= v9fs_vfs_setattr
,
1351 static struct inode_operations v9fs_file_inode_operations
= {
1352 .getattr
= v9fs_vfs_getattr
,
1353 .setattr
= v9fs_vfs_setattr
,
1356 static struct inode_operations v9fs_symlink_inode_operations
= {
1357 .readlink
= v9fs_vfs_readlink
,
1358 .follow_link
= v9fs_vfs_follow_link
,
1359 .put_link
= v9fs_vfs_put_link
,
1360 .getattr
= v9fs_vfs_getattr
,
1361 .setattr
= v9fs_vfs_setattr
,