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);
389 dprintk(DEBUG_ERROR, "clunk for mkdir failed: %d\n", err);
392 /* walk to the newly created file and put the fid in the dentry */
393 wfidno = v9fs_get_idpool(&v9ses->fidpool);
395 eprintk(KERN_WARNING, "no free fids available\n");
399 result = v9fs_t_walk(v9ses, dirfidnum, wfidno,
400 (char *) file_dentry->d_name.name, &fcall);
402 dprintk(DEBUG_ERROR, "clone error: %s\n", FCALL_ERROR(fcall));
403 v9fs_put_idpool(wfidno, &v9ses->fidpool);
410 if (!v9fs_fid_create(file_dentry, v9ses, wfidno, 0)) {
411 v9fs_t_clunk(v9ses, newfid);
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, newfid, &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,