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
)
129 * v9fs_blank_wstat - helper function to setup a 9P stat structure
130 * @v9ses: 9P session info (for determining extended mode)
131 * @wstat: structure to initialize
136 v9fs_blank_wstat(struct v9fs_wstat
*wstat
)
140 wstat
->qid
.type
= ~0;
141 wstat
->qid
.version
= ~0;
142 *((long long *)&wstat
->qid
.path
) = ~0;
154 wstat
->extension
= NULL
;
158 * v9fs_get_inode - helper function to setup an inode
160 * @mode: mode to setup inode with
164 struct inode
*v9fs_get_inode(struct super_block
*sb
, int mode
)
166 struct inode
*inode
= NULL
;
167 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
169 dprintk(DEBUG_VFS
, "super block: %p mode: %o\n", sb
, mode
);
171 inode
= new_inode(sb
);
173 inode
->i_mode
= mode
;
174 inode
->i_uid
= current
->fsuid
;
175 inode
->i_gid
= current
->fsgid
;
176 inode
->i_blksize
= sb
->s_blocksize
;
179 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
180 inode
->i_mapping
->a_ops
= &v9fs_addr_operations
;
182 switch (mode
& S_IFMT
) {
187 if(!v9ses
->extended
) {
188 dprintk(DEBUG_ERROR
, "special files without extended mode\n");
189 return ERR_PTR(-EINVAL
);
191 init_special_inode(inode
, inode
->i_mode
,
195 inode
->i_op
= &v9fs_file_inode_operations
;
196 inode
->i_fop
= &v9fs_file_operations
;
199 if(!v9ses
->extended
) {
200 dprintk(DEBUG_ERROR
, "extended modes used w/o 9P2000.u\n");
201 return ERR_PTR(-EINVAL
);
203 inode
->i_op
= &v9fs_symlink_inode_operations
;
208 inode
->i_op
= &v9fs_dir_inode_operations_ext
;
210 inode
->i_op
= &v9fs_dir_inode_operations
;
211 inode
->i_fop
= &v9fs_dir_operations
;
214 dprintk(DEBUG_ERROR
, "BAD mode 0x%x S_IFMT 0x%x\n",
215 mode
, mode
& S_IFMT
);
216 return ERR_PTR(-EINVAL
);
219 eprintk(KERN_WARNING
, "Problem allocating inode\n");
220 return ERR_PTR(-ENOMEM
);
226 * v9fs_create - helper function to create files and directories
227 * @dir: directory inode file is being created in
228 * @file_dentry: dentry file is being created in
229 * @perm: permissions file is being created with
230 * @open_mode: resulting open mode for file
235 v9fs_create(struct inode
*dir
,
236 struct dentry
*file_dentry
,
237 unsigned int perm
, unsigned int open_mode
)
239 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dir
);
240 struct super_block
*sb
= dir
->i_sb
;
241 struct v9fs_fid
*dirfid
=
242 v9fs_fid_lookup(file_dentry
->d_parent
);
243 struct v9fs_fid
*fid
= NULL
;
244 struct inode
*file_inode
= NULL
;
245 struct v9fs_fcall
*fcall
= NULL
;
250 unsigned int iounit
= 0;
254 perm
= unixmode2p9mode(v9ses
, perm
);
256 dprintk(DEBUG_VFS
, "dir: %p dentry: %p perm: %o mode: %o\n", dir
,
257 file_dentry
, perm
, open_mode
);
262 dirfidnum
= dirfid
->fid
;
264 dprintk(DEBUG_ERROR
, "No fid for the directory #%lu\n",
269 if (file_dentry
->d_inode
) {
271 "Odd. There is an inode for dir %lu, name :%s:\n",
272 dir
->i_ino
, file_dentry
->d_name
.name
);
276 newfid
= v9fs_get_idpool(&v9ses
->fidpool
);
278 eprintk(KERN_WARNING
, "no free fids available\n");
282 result
= v9fs_t_walk(v9ses
, dirfidnum
, newfid
, NULL
, &fcall
);
284 PRINT_FCALL_ERROR("clone error", fcall
);
285 v9fs_put_idpool(newfid
, &v9ses
->fidpool
);
293 result
= v9fs_t_create(v9ses
, newfid
, (char *)file_dentry
->d_name
.name
,
294 perm
, open_mode
, &fcall
);
296 PRINT_FCALL_ERROR("create fails", fcall
);
300 iounit
= fcall
->params
.rcreate
.iounit
;
301 qid
= fcall
->params
.rcreate
.qid
;
305 if (!(perm
&V9FS_DMDIR
)) {
306 fid
= v9fs_fid_create(file_dentry
, v9ses
, newfid
, 1);
307 dprintk(DEBUG_VFS
, "fid %p %d\n", fid
, fid
->fidcreate
);
314 fid
->iounit
= iounit
;
316 err
= v9fs_t_clunk(v9ses
, newfid
);
319 dprintk(DEBUG_ERROR
, "clunk for mkdir failed: %d\n", err
);
322 /* walk to the newly created file and put the fid in the dentry */
323 wfidno
= v9fs_get_idpool(&v9ses
->fidpool
);
325 eprintk(KERN_WARNING
, "no free fids available\n");
329 result
= v9fs_t_walk(v9ses
, dirfidnum
, wfidno
,
330 (char *) file_dentry
->d_name
.name
, &fcall
);
332 PRINT_FCALL_ERROR("clone error", fcall
);
333 v9fs_put_idpool(wfidno
, &v9ses
->fidpool
);
340 if (!v9fs_fid_create(file_dentry
, v9ses
, wfidno
, 0)) {
341 v9fs_put_idpool(wfidno
, &v9ses
->fidpool
);
346 if ((perm
& V9FS_DMSYMLINK
) || (perm
& V9FS_DMLINK
) ||
347 (perm
& V9FS_DMNAMEDPIPE
) || (perm
& V9FS_DMSOCKET
) ||
348 (perm
& V9FS_DMDEVICE
))
351 result
= v9fs_t_stat(v9ses
, wfidno
, &fcall
);
353 PRINT_FCALL_ERROR("stat error", fcall
);
358 file_inode
= v9fs_get_inode(sb
,
359 p9mode2unixmode(v9ses
, fcall
->params
.rstat
.stat
.mode
));
361 if ((!file_inode
) || IS_ERR(file_inode
)) {
362 dprintk(DEBUG_ERROR
, "create inode failed\n");
367 v9fs_stat2inode(&fcall
->params
.rstat
.stat
, file_inode
, sb
);
370 file_dentry
->d_op
= &v9fs_dentry_operations
;
371 d_instantiate(file_dentry
, file_inode
);
380 err
= v9fs_t_clunk(v9ses
, newfid
);
382 dprintk(DEBUG_ERROR
, "clunk failed: %d\n", err
);
385 err
= v9fs_t_clunk(v9ses
, wfidno
);
387 dprintk(DEBUG_ERROR
, "clunk failed: %d\n", err
);
393 * v9fs_remove - helper function to remove files and directories
394 * @dir: directory inode that is being deleted
395 * @file: dentry that is being deleted
396 * @rmdir: removing a directory
400 static int v9fs_remove(struct inode
*dir
, struct dentry
*file
, int rmdir
)
402 struct v9fs_fcall
*fcall
= NULL
;
403 struct super_block
*sb
= NULL
;
404 struct v9fs_session_info
*v9ses
= NULL
;
405 struct v9fs_fid
*v9fid
= NULL
;
406 struct inode
*file_inode
= NULL
;
410 dprintk(DEBUG_VFS
, "inode: %p dentry: %p rmdir: %d\n", dir
, file
,
413 file_inode
= file
->d_inode
;
414 sb
= file_inode
->i_sb
;
415 v9ses
= v9fs_inode2v9ses(file_inode
);
416 v9fid
= v9fs_fid_lookup(file
);
426 dprintk(DEBUG_ERROR
, "inode #%lu, no fid!\n",
431 result
= v9fs_t_remove(v9ses
, fid
, &fcall
);
433 PRINT_FCALL_ERROR("remove fails", fcall
);
435 v9fs_put_idpool(fid
, &v9ses
->fidpool
);
436 v9fs_fid_destroy(v9fid
);
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 * @perm: create permissions
448 * @nd: path information
453 v9fs_vfs_create(struct inode
*inode
, struct dentry
*dentry
, int perm
,
454 struct nameidata
*nd
)
456 return v9fs_create(inode
, dentry
, perm
, O_RDWR
);
460 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
461 * @inode: inode that is being unlinked
462 * @dentry: dentry that is being unlinked
463 * @mode: mode for new directory
467 static int v9fs_vfs_mkdir(struct inode
*inode
, struct dentry
*dentry
, int mode
)
469 return v9fs_create(inode
, dentry
, mode
| S_IFDIR
, O_RDONLY
);
473 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
474 * @dir: inode that is being walked from
475 * @dentry: dentry that is being walked to?
476 * @nameidata: path data
480 static struct dentry
*v9fs_vfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
481 struct nameidata
*nameidata
)
483 struct super_block
*sb
;
484 struct v9fs_session_info
*v9ses
;
485 struct v9fs_fid
*dirfid
;
486 struct v9fs_fid
*fid
;
488 struct v9fs_fcall
*fcall
= NULL
;
493 dprintk(DEBUG_VFS
, "dir: %p dentry: (%s) %p nameidata: %p\n",
494 dir
, dentry
->d_iname
, dentry
, nameidata
);
497 v9ses
= v9fs_inode2v9ses(dir
);
498 dirfid
= v9fs_fid_lookup(dentry
->d_parent
);
501 dprintk(DEBUG_ERROR
, "no dirfid\n");
502 return ERR_PTR(-EINVAL
);
505 dirfidnum
= dirfid
->fid
;
508 dprintk(DEBUG_ERROR
, "no dirfid for inode %p, #%lu\n",
510 return ERR_PTR(-EBADF
);
513 newfid
= v9fs_get_idpool(&v9ses
->fidpool
);
515 eprintk(KERN_WARNING
, "newfid fails!\n");
516 return ERR_PTR(-ENOSPC
);
520 v9fs_t_walk(v9ses
, dirfidnum
, newfid
, (char *)dentry
->d_name
.name
,
523 v9fs_put_idpool(newfid
, &v9ses
->fidpool
);
524 if (result
== -ENOENT
) {
527 "Return negative dentry %p count %d\n",
528 dentry
, atomic_read(&dentry
->d_count
));
531 dprintk(DEBUG_ERROR
, "walk error:%d\n", result
);
535 result
= v9fs_t_stat(v9ses
, newfid
, &fcall
);
537 dprintk(DEBUG_ERROR
, "stat error\n");
541 inode
= v9fs_get_inode(sb
, p9mode2unixmode(v9ses
,
542 fcall
->params
.rstat
.stat
.mode
));
544 if (IS_ERR(inode
) && (PTR_ERR(inode
) == -ENOSPC
)) {
545 eprintk(KERN_WARNING
, "inode alloc failes, returns %ld\n",
552 inode
->i_ino
= v9fs_qid2ino(&fcall
->params
.rstat
.stat
.qid
);
554 fid
= v9fs_fid_create(dentry
, v9ses
, newfid
, 0);
556 dprintk(DEBUG_ERROR
, "couldn't insert\n");
561 fid
->qid
= fcall
->params
.rstat
.stat
.qid
;
563 dentry
->d_op
= &v9fs_dentry_operations
;
564 v9fs_stat2inode(&fcall
->params
.rstat
.stat
, inode
, inode
->i_sb
);
566 d_add(dentry
, inode
);
573 return ERR_PTR(result
);
577 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
578 * @i: inode that is being unlinked
579 * @d: dentry that is being unlinked
583 static int v9fs_vfs_unlink(struct inode
*i
, struct dentry
*d
)
585 return v9fs_remove(i
, d
, 0);
589 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
590 * @i: inode that is being unlinked
591 * @d: dentry that is being unlinked
595 static int v9fs_vfs_rmdir(struct inode
*i
, struct dentry
*d
)
597 return v9fs_remove(i
, d
, 1);
601 * v9fs_vfs_rename - VFS hook to rename an inode
602 * @old_dir: old dir inode
603 * @old_dentry: old dentry
604 * @new_dir: new dir inode
605 * @new_dentry: new dentry
610 v9fs_vfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
611 struct inode
*new_dir
, struct dentry
*new_dentry
)
613 struct inode
*old_inode
= old_dentry
->d_inode
;
614 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(old_inode
);
615 struct v9fs_fid
*oldfid
= v9fs_fid_lookup(old_dentry
);
616 struct v9fs_fid
*olddirfid
=
617 v9fs_fid_lookup(old_dentry
->d_parent
);
618 struct v9fs_fid
*newdirfid
=
619 v9fs_fid_lookup(new_dentry
->d_parent
);
620 struct v9fs_wstat wstat
;
621 struct v9fs_fcall
*fcall
= NULL
;
623 int olddirfidnum
= -1;
624 int newdirfidnum
= -1;
627 dprintk(DEBUG_VFS
, "\n");
629 if ((!oldfid
) || (!olddirfid
) || (!newdirfid
)) {
630 dprintk(DEBUG_ERROR
, "problem with arguments\n");
634 /* 9P can only handle file rename in the same directory */
635 if (memcmp(&olddirfid
->qid
, &newdirfid
->qid
, sizeof(newdirfid
->qid
))) {
636 dprintk(DEBUG_ERROR
, "old dir and new dir are different\n");
642 olddirfidnum
= olddirfid
->fid
;
643 newdirfidnum
= newdirfid
->fid
;
646 dprintk(DEBUG_ERROR
, "no fid for old file #%lu\n",
652 v9fs_blank_wstat(&wstat
);
653 wstat
.muid
= v9ses
->name
;
654 wstat
.name
= (char *) new_dentry
->d_name
.name
;
656 retval
= v9fs_t_wstat(v9ses
, fid
, &wstat
, &fcall
);
660 PRINT_FCALL_ERROR("wstat error", fcall
);
667 * v9fs_vfs_getattr - retrieve file metadata
668 * @mnt - mount information
669 * @dentry - file to get attributes on
670 * @stat - metadata structure to populate
675 v9fs_vfs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
678 struct v9fs_fcall
*fcall
= NULL
;
679 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
680 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
683 dprintk(DEBUG_VFS
, "dentry: %p\n", dentry
);
686 "couldn't find fid associated with dentry\n");
690 err
= v9fs_t_stat(v9ses
, fid
->fid
, &fcall
);
693 dprintk(DEBUG_ERROR
, "stat error\n");
695 v9fs_stat2inode(&fcall
->params
.rstat
.stat
, dentry
->d_inode
,
696 dentry
->d_inode
->i_sb
);
697 generic_fillattr(dentry
->d_inode
, stat
);
705 * v9fs_vfs_setattr - set file metadata
706 * @dentry: file whose metadata to set
707 * @iattr: metadata assignment structure
711 static int v9fs_vfs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
713 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
714 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
715 struct v9fs_fcall
*fcall
= NULL
;
716 struct v9fs_wstat wstat
;
719 dprintk(DEBUG_VFS
, "\n");
723 "Couldn't find fid associated with dentry\n");
727 v9fs_blank_wstat(&wstat
);
728 if (iattr
->ia_valid
& ATTR_MODE
)
729 wstat
.mode
= unixmode2p9mode(v9ses
, iattr
->ia_mode
);
731 if (iattr
->ia_valid
& ATTR_MTIME
)
732 wstat
.mtime
= iattr
->ia_mtime
.tv_sec
;
734 if (iattr
->ia_valid
& ATTR_ATIME
)
735 wstat
.atime
= iattr
->ia_atime
.tv_sec
;
737 if (iattr
->ia_valid
& ATTR_SIZE
)
738 wstat
.length
= iattr
->ia_size
;
740 if (v9ses
->extended
) {
741 if (iattr
->ia_valid
& ATTR_UID
)
742 wstat
.n_uid
= iattr
->ia_uid
;
744 if (iattr
->ia_valid
& ATTR_GID
)
745 wstat
.n_gid
= iattr
->ia_gid
;
748 res
= v9fs_t_wstat(v9ses
, fid
->fid
, &wstat
, &fcall
);
751 PRINT_FCALL_ERROR("wstat error", fcall
);
755 res
= inode_setattr(dentry
->d_inode
, iattr
);
761 * v9fs_stat2inode - populate an inode structure with mistat info
762 * @stat: Plan 9 metadata (mistat) structure
763 * @inode: inode to populate
764 * @sb: superblock of filesystem
769 v9fs_stat2inode(struct v9fs_stat
*stat
, struct inode
*inode
,
770 struct super_block
*sb
)
774 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
778 inode
->i_atime
.tv_sec
= stat
->atime
;
779 inode
->i_mtime
.tv_sec
= stat
->mtime
;
780 inode
->i_ctime
.tv_sec
= stat
->mtime
;
782 inode
->i_uid
= v9ses
->uid
;
783 inode
->i_gid
= v9ses
->gid
;
785 if (v9ses
->extended
) {
786 inode
->i_uid
= stat
->n_uid
;
787 inode
->i_gid
= stat
->n_gid
;
790 inode
->i_mode
= p9mode2unixmode(v9ses
, stat
->mode
);
791 if ((S_ISBLK(inode
->i_mode
)) || (S_ISCHR(inode
->i_mode
))) {
796 n
= stat
->extension
.len
;
797 if (n
> sizeof(ext
)-1)
799 memmove(ext
, stat
->extension
.str
, n
);
801 sscanf(ext
, "%c %u %u", &type
, &major
, &minor
);
804 inode
->i_mode
&= ~S_IFBLK
;
805 inode
->i_mode
|= S_IFCHR
;
810 dprintk(DEBUG_ERROR
, "Unknown special type %c (%.*s)\n",
811 type
, stat
->extension
.len
, stat
->extension
.str
);
813 inode
->i_rdev
= MKDEV(major
, minor
);
817 inode
->i_size
= stat
->length
;
819 inode
->i_blksize
= sb
->s_blocksize
;
821 (inode
->i_size
+ inode
->i_blksize
- 1) >> sb
->s_blocksize_bits
;
825 * v9fs_qid2ino - convert qid into inode number
828 * BUG: potential for inode number collisions?
831 ino_t
v9fs_qid2ino(struct v9fs_qid
*qid
)
833 u64 path
= qid
->path
+ 2;
836 if (sizeof(ino_t
) == sizeof(path
))
837 memcpy(&i
, &path
, sizeof(ino_t
));
839 i
= (ino_t
) (path
^ (path
>> 32));
845 * v9fs_readlink - read a symlink's location (internal version)
846 * @dentry: dentry for symlink
847 * @buffer: buffer to load symlink location into
848 * @buflen: length of buffer
852 static int v9fs_readlink(struct dentry
*dentry
, char *buffer
, int buflen
)
856 struct v9fs_fcall
*fcall
= NULL
;
857 struct v9fs_session_info
*v9ses
= v9fs_inode2v9ses(dentry
->d_inode
);
858 struct v9fs_fid
*fid
= v9fs_fid_lookup(dentry
);
861 dprintk(DEBUG_ERROR
, "could not resolve fid from dentry\n");
866 if (!v9ses
->extended
) {
868 dprintk(DEBUG_ERROR
, "not extended\n");
872 dprintk(DEBUG_VFS
, " %s\n", dentry
->d_name
.name
);
873 retval
= v9fs_t_stat(v9ses
, fid
->fid
, &fcall
);
876 dprintk(DEBUG_ERROR
, "stat error\n");
883 if (!(fcall
->params
.rstat
.stat
.mode
& V9FS_DMSYMLINK
)) {
888 /* copy extension buffer into buffer */
889 if (fcall
->params
.rstat
.stat
.extension
.len
+1 < buflen
)
890 buflen
= fcall
->params
.rstat
.stat
.extension
.len
+ 1;
892 memcpy(buffer
, fcall
->params
.rstat
.stat
.extension
.str
, buflen
- 1);
893 buffer
[buflen
-1] = 0;
904 * v9fs_vfs_readlink - read a symlink's location
905 * @dentry: dentry for symlink
906 * @buf: buffer to load symlink location into
907 * @buflen: length of buffer
911 static int v9fs_vfs_readlink(struct dentry
*dentry
, char __user
* buffer
,
916 char *link
= __getname();
918 if (buflen
> PATH_MAX
)
921 dprintk(DEBUG_VFS
, " dentry: %s (%p)\n", dentry
->d_iname
, dentry
);
923 retval
= v9fs_readlink(dentry
, link
, buflen
);
926 if ((ret
= copy_to_user(buffer
, link
, retval
)) != 0) {
927 dprintk(DEBUG_ERROR
, "problem copying to user: %d\n",
938 * v9fs_vfs_follow_link - follow a symlink path
939 * @dentry: dentry for symlink
944 static void *v9fs_vfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
947 char *link
= __getname();
949 dprintk(DEBUG_VFS
, "%s n", dentry
->d_name
.name
);
952 link
= ERR_PTR(-ENOMEM
);
954 len
= v9fs_readlink(dentry
, link
, PATH_MAX
);
962 nd_set_link(nd
, link
);
968 * v9fs_vfs_put_link - release a symlink path
969 * @dentry: dentry for symlink
974 static void v9fs_vfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
976 char *s
= nd_get_link(nd
);
978 dprintk(DEBUG_VFS
, " %s %s\n", dentry
->d_name
.name
, s
);
983 static int v9fs_vfs_mkspecial(struct inode
*dir
, struct dentry
*dentry
,
984 int mode
, const char *extension
)
987 struct v9fs_session_info
*v9ses
;
988 struct v9fs_fcall
*fcall
;
989 struct v9fs_fid
*fid
;
990 struct v9fs_wstat wstat
;
992 v9ses
= v9fs_inode2v9ses(dir
);
996 if (!v9ses
->extended
) {
997 dprintk(DEBUG_ERROR
, "not extended\n");
1001 /* issue a create */
1002 retval
= v9fs_create(dir
, dentry
, mode
, 0);
1006 fid
= v9fs_fid_get_created(dentry
);
1008 dprintk(DEBUG_ERROR
, "couldn't resolve fid from dentry\n");
1012 /* issue a Twstat */
1013 v9fs_blank_wstat(&wstat
);
1014 wstat
.muid
= v9ses
->name
;
1015 wstat
.extension
= (char *) extension
;
1016 retval
= v9fs_t_wstat(v9ses
, fid
->fid
, &wstat
, &fcall
);
1018 PRINT_FCALL_ERROR("wstat error", fcall
);
1022 err
= v9fs_t_clunk(v9ses
, fid
->fid
);
1024 dprintk(DEBUG_ERROR
, "clunk failed: %d\n", err
);
1028 d_drop(dentry
); /* FID - will this also clunk? */
1036 * v9fs_vfs_symlink - helper function to create symlinks
1037 * @dir: directory inode containing symlink
1038 * @dentry: dentry for symlink
1039 * @symname: symlink data
1041 * See 9P2000.u RFC for more information
1046 v9fs_vfs_symlink(struct inode
*dir
, struct dentry
*dentry
, const char *symname
)
1048 dprintk(DEBUG_VFS
, " %lu,%s,%s\n", dir
->i_ino
, dentry
->d_name
.name
,
1051 return v9fs_vfs_mkspecial(dir
, dentry
, S_IFLNK
, symname
);
1055 * v9fs_vfs_link - create a hardlink
1056 * @old_dentry: dentry for file to link to
1057 * @dir: inode destination for new link
1058 * @dentry: dentry for link
1062 /* XXX - lots of code dup'd from symlink and creates,
1063 * figure out a better reuse strategy
1067 v9fs_vfs_link(struct dentry
*old_dentry
, struct inode
*dir
,
1068 struct dentry
*dentry
)
1071 struct v9fs_fid
*oldfid
;
1074 dprintk(DEBUG_VFS
, " %lu,%s,%s\n", dir
->i_ino
, dentry
->d_name
.name
,
1075 old_dentry
->d_name
.name
);
1077 oldfid
= v9fs_fid_lookup(old_dentry
);
1079 dprintk(DEBUG_ERROR
, "can't find oldfid\n");
1084 sprintf(name
, "hardlink(%d)\n", oldfid
->fid
);
1085 retval
= v9fs_vfs_mkspecial(dir
, dentry
, V9FS_DMLINK
, name
);
1092 * v9fs_vfs_mknod - create a special file
1093 * @dir: inode destination for new link
1094 * @dentry: dentry for file
1095 * @mode: mode for creation
1096 * @dev_t: device associated with special file
1101 v9fs_vfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t rdev
)
1106 dprintk(DEBUG_VFS
, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir
->i_ino
,
1107 dentry
->d_name
.name
, mode
, MAJOR(rdev
), MINOR(rdev
));
1109 if (!new_valid_dev(rdev
))
1113 /* build extension */
1115 sprintf(name
, "b %u %u", MAJOR(rdev
), MINOR(rdev
));
1116 else if (S_ISCHR(mode
))
1117 sprintf(name
, "c %u %u", MAJOR(rdev
), MINOR(rdev
));
1118 else if (S_ISFIFO(mode
))
1125 retval
= v9fs_vfs_mkspecial(dir
, dentry
, mode
, name
);
1131 static struct inode_operations v9fs_dir_inode_operations_ext
= {
1132 .create
= v9fs_vfs_create
,
1133 .lookup
= v9fs_vfs_lookup
,
1134 .symlink
= v9fs_vfs_symlink
,
1135 .link
= v9fs_vfs_link
,
1136 .unlink
= v9fs_vfs_unlink
,
1137 .mkdir
= v9fs_vfs_mkdir
,
1138 .rmdir
= v9fs_vfs_rmdir
,
1139 .mknod
= v9fs_vfs_mknod
,
1140 .rename
= v9fs_vfs_rename
,
1141 .readlink
= v9fs_vfs_readlink
,
1142 .getattr
= v9fs_vfs_getattr
,
1143 .setattr
= v9fs_vfs_setattr
,
1146 static struct inode_operations v9fs_dir_inode_operations
= {
1147 .create
= v9fs_vfs_create
,
1148 .lookup
= v9fs_vfs_lookup
,
1149 .unlink
= v9fs_vfs_unlink
,
1150 .mkdir
= v9fs_vfs_mkdir
,
1151 .rmdir
= v9fs_vfs_rmdir
,
1152 .mknod
= v9fs_vfs_mknod
,
1153 .rename
= v9fs_vfs_rename
,
1154 .getattr
= v9fs_vfs_getattr
,
1155 .setattr
= v9fs_vfs_setattr
,
1158 static struct inode_operations v9fs_file_inode_operations
= {
1159 .getattr
= v9fs_vfs_getattr
,
1160 .setattr
= v9fs_vfs_setattr
,
1163 static struct inode_operations v9fs_symlink_inode_operations
= {
1164 .readlink
= v9fs_vfs_readlink
,
1165 .follow_link
= v9fs_vfs_follow_link
,
1166 .put_link
= v9fs_vfs_put_link
,
1167 .getattr
= v9fs_vfs_getattr
,
1168 .setattr
= v9fs_vfs_setattr
,