fs/9p/vfs_inode.c

   1 /*
   2  *  linux/fs/9p/vfs_inode.c
   3  *
   4  * This file contains vfs inode ops for the 9P2000 protocol.
   5  *
   6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   7  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License version 2
  11  *  as published by the Free Software Foundation.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to:
  20  *  Free Software Foundation
  21  *  51 Franklin Street, Fifth Floor
  22  *  Boston, MA  02111-1301  USA
  23  *
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/errno.h>
  28 #include <linux/fs.h>
  29 #include <linux/file.h>
  30 #include <linux/pagemap.h>
  31 #include <linux/stat.h>
  32 #include <linux/string.h>
  33 #include <linux/inet.h>
  34 #include <linux/namei.h>
  35 #include <linux/idr.h>
  36
  37 #include "debug.h"
  38 #include "v9fs.h"
  39 #include "9p.h"
  40 #include "v9fs_vfs.h"
  41 #include "fid.h"
  42
  43 static const struct inode_operations v9fs_dir_inode_operations;
  44 static const struct inode_operations v9fs_dir_inode_operations_ext;
  45 static const struct inode_operations v9fs_file_inode_operations;
  46 static const struct inode_operations v9fs_symlink_inode_operations;
  47
  48 /**
  49  * unixmode2p9mode - convert unix mode bits to plan 9
  50  * @v9ses: v9fs session information
  51  * @mode: mode to convert
  52  *
  53  */
  54
  55 static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
  56 {
  57         int res;
  58         res = mode & 0777;
  59         if (S_ISDIR(mode))
  60                 res |= V9FS_DMDIR;
  61         if (v9ses->extended) {
  62                 if (S_ISLNK(mode))
  63                         res |= V9FS_DMSYMLINK;
  64                 if (v9ses->nodev == 0) {
  65                         if (S_ISSOCK(mode))
  66                                 res |= V9FS_DMSOCKET;
  67                         if (S_ISFIFO(mode))
  68                                 res |= V9FS_DMNAMEDPIPE;
  69                         if (S_ISBLK(mode))
  70                                 res |= V9FS_DMDEVICE;
  71                         if (S_ISCHR(mode))
  72                                 res |= V9FS_DMDEVICE;
  73                 }
  74
  75                 if ((mode & S_ISUID) == S_ISUID)
  76                         res |= V9FS_DMSETUID;
  77                 if ((mode & S_ISGID) == S_ISGID)
  78                         res |= V9FS_DMSETGID;
  79                 if ((mode & V9FS_DMLINK))
  80                         res |= V9FS_DMLINK;
  81         }
  82
  83         return res;
  84 }
  85
  86 /**
  87  * p9mode2unixmode- convert plan9 mode bits to unix mode bits
  88  * @v9ses: v9fs session information
  89  * @mode: mode to convert
  90  *
  91  */
  92
  93 static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
  94 {
  95         int res;
  96
  97         res = mode & 0777;
  98
  99         if ((mode & V9FS_DMDIR) == V9FS_DMDIR)
 100                 res |= S_IFDIR;
 101         else if ((mode & V9FS_DMSYMLINK) && (v9ses->extended))
 102                 res |= S_IFLNK;
 103         else if ((mode & V9FS_DMSOCKET) && (v9ses->extended)
 104                  && (v9ses->nodev == 0))
 105                 res |= S_IFSOCK;
 106         else if ((mode & V9FS_DMNAMEDPIPE) && (v9ses->extended)
 107                  && (v9ses->nodev == 0))
 108                 res |= S_IFIFO;
 109         else if ((mode & V9FS_DMDEVICE) && (v9ses->extended)
 110                  && (v9ses->nodev == 0))
 111                 res |= S_IFBLK;
 112         else
 113                 res |= S_IFREG;
 114
 115         if (v9ses->extended) {
 116                 if ((mode & V9FS_DMSETUID) == V9FS_DMSETUID)
 117                         res |= S_ISUID;
 118
 119                 if ((mode & V9FS_DMSETGID) == V9FS_DMSETGID)
 120                         res |= S_ISGID;
 121         }
 122
 123         return res;
 124 }
 125
 126 int v9fs_uflags2omode(int uflags)
 127 {
 128         int ret;
 129
 130         ret = 0;
 131         switch (uflags&3) {
 132         default:
 133         case O_RDONLY:
 134                 ret = V9FS_OREAD;
 135                 break;
 136
 137         case O_WRONLY:
 138                 ret = V9FS_OWRITE;
 139                 break;
 140
 141         case O_RDWR:
 142                 ret = V9FS_ORDWR;
 143                 break;
 144         }
 145
 146         if (uflags & O_EXCL)
 147                 ret |= V9FS_OEXCL;
 148
 149         if (uflags & O_TRUNC)
 150                 ret |= V9FS_OTRUNC;
 151
 152         if (uflags & O_APPEND)
 153                 ret |= V9FS_OAPPEND;
 154
 155         return ret;
 156 }
 157
 158 /**
 159  * v9fs_blank_wstat - helper function to setup a 9P stat structure
 160  * @v9ses: 9P session info (for determining extended mode)
 161  * @wstat: structure to initialize
 162  *
 163  */
 164
 165 static void
 166 v9fs_blank_wstat(struct v9fs_wstat *wstat)
 167 {
 168         wstat->type = ~0;
 169         wstat->dev = ~0;
 170         wstat->qid.type = ~0;
 171         wstat->qid.version = ~0;
 172         *((long long *)&wstat->qid.path) = ~0;
 173         wstat->mode = ~0;
 174         wstat->atime = ~0;
 175         wstat->mtime = ~0;
 176         wstat->length = ~0;
 177         wstat->name = NULL;
 178         wstat->uid = NULL;
 179         wstat->gid = NULL;
 180         wstat->muid = NULL;
 181         wstat->n_uid = ~0;
 182         wstat->n_gid = ~0;
 183         wstat->n_muid = ~0;
 184         wstat->extension = NULL;
 185 }
 186
 187 /**
 188  * v9fs_get_inode - helper function to setup an inode
 189  * @sb: superblock
 190  * @mode: mode to setup inode with
 191  *
 192  */
 193
 194 struct inode *v9fs_get_inode(struct super_block *sb, int mode)
 195 {
 196         struct inode *inode;
 197         struct v9fs_session_info *v9ses = sb->s_fs_info;
 198
 199         dprintk(DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
 200
 201         inode = new_inode(sb);
 202         if (inode) {
 203                 inode->i_mode = mode;
 204                 inode->i_uid = current->fsuid;
 205                 inode->i_gid = current->fsgid;
 206                 inode->i_blocks = 0;
 207                 inode->i_rdev = 0;
 208                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 209                 inode->i_mapping->a_ops = &v9fs_addr_operations;
 210
 211                 switch (mode & S_IFMT) {
 212                 case S_IFIFO:
 213                 case S_IFBLK:
 214                 case S_IFCHR:
 215                 case S_IFSOCK:
 216                         if(!v9ses->extended) {
 217                                 dprintk(DEBUG_ERROR, "special files without extended mode\n");
 218                                 return ERR_PTR(-EINVAL);
 219                         }
 220                         init_special_inode(inode, inode->i_mode,
 221                                            inode->i_rdev);
 222                         break;
 223                 case S_IFREG:
 224                         inode->i_op = &v9fs_file_inode_operations;
 225                         inode->i_fop = &v9fs_file_operations;
 226                         break;
 227                 case S_IFLNK:
 228                         if(!v9ses->extended) {
 229                                 dprintk(DEBUG_ERROR, "extended modes used w/o 9P2000.u\n");
 230                                 return ERR_PTR(-EINVAL);
 231                         }
 232                         inode->i_op = &v9fs_symlink_inode_operations;
 233                         break;
 234                 case S_IFDIR:
 235                         inc_nlink(inode);
 236                         if(v9ses->extended)
 237                                 inode->i_op = &v9fs_dir_inode_operations_ext;
 238                         else
 239                                 inode->i_op = &v9fs_dir_inode_operations;
 240                         inode->i_fop = &v9fs_dir_operations;
 241                         break;
 242                 default:
 243                         dprintk(DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
 244                                 mode, mode & S_IFMT);
 245                         return ERR_PTR(-EINVAL);
 246                 }
 247         } else {
 248                 eprintk(KERN_WARNING, "Problem allocating inode\n");
 249                 return ERR_PTR(-ENOMEM);
 250         }
 251         return inode;
 252 }
 253
 254 static int
 255 v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name, u32 perm,
 256         u8 mode, char *extension, u32 *fidp, struct v9fs_qid *qid, u32 *iounit)
 257 {
 258         int fid;
 259         int err;
 260         struct v9fs_fcall *fcall;
 261
 262         fid = v9fs_get_idpool(&v9ses->fidpool);
 263         if (fid < 0) {
 264                 eprintk(KERN_WARNING, "no free fids available\n");
 265                 return -ENOSPC;
 266         }
 267
 268         err = v9fs_t_walk(v9ses, pfid, fid, NULL, &fcall);
 269         if (err < 0) {
 270                 PRINT_FCALL_ERROR("clone error", fcall);
 271                 if (fcall && fcall->id == RWALK)
 272                         goto clunk_fid;
 273                 else
 274                         goto put_fid;
 275         }
 276         kfree(fcall);
 277
 278         err = v9fs_t_create(v9ses, fid, name, perm, mode, extension, &fcall);
 279         if (err < 0) {
 280                 PRINT_FCALL_ERROR("create fails", fcall);
 281                 goto clunk_fid;
 282         }
 283
 284         if (iounit)
 285                 *iounit = fcall->params.rcreate.iounit;
 286
 287         if (qid)
 288                 *qid = fcall->params.rcreate.qid;
 289
 290         if (fidp)
 291                 *fidp = fid;
 292
 293         kfree(fcall);
 294         return 0;
 295
 296 clunk_fid:
 297         v9fs_t_clunk(v9ses, fid);
 298         fid = V9FS_NOFID;
 299
 300 put_fid:
 301         if (fid != V9FS_NOFID)
 302                 v9fs_put_idpool(fid, &v9ses->fidpool);
 303
 304         kfree(fcall);
 305         return err;
 306 }
 307
 308 static struct v9fs_fid*
 309 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
 310 {
 311         int err;
 312         int nfid;
 313         struct v9fs_fid *ret;
 314         struct v9fs_fcall *fcall;
 315
 316         nfid = v9fs_get_idpool(&v9ses->fidpool);
 317         if (nfid < 0) {
 318                 eprintk(KERN_WARNING, "no free fids available\n");
 319                 return ERR_PTR(-ENOSPC);
 320         }
 321
 322         err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
 323                 &fcall);
 324
 325         if (err < 0) {
 326                 if (fcall && fcall->id == RWALK)
 327                         goto clunk_fid;
 328
 329                 PRINT_FCALL_ERROR("walk error", fcall);
 330                 v9fs_put_idpool(nfid, &v9ses->fidpool);
 331                 goto error;
 332         }
 333
 334         kfree(fcall);
 335         fcall = NULL;
 336         ret = v9fs_fid_create(v9ses, nfid);
 337         if (!ret) {
 338                 err = -ENOMEM;
 339                 goto clunk_fid;
 340         }
 341
 342         err = v9fs_fid_insert(ret, dentry);
 343         if (err < 0) {
 344                 v9fs_fid_destroy(ret);
 345                 goto clunk_fid;
 346         }
 347
 348         return ret;
 349
 350 clunk_fid:
 351         v9fs_t_clunk(v9ses, nfid);
 352
 353 error:
 354         kfree(fcall);
 355         return ERR_PTR(err);
 356 }
 357
 358 static struct inode *
 359 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, u32 fid,
 360         struct super_block *sb)
 361 {
 362         int err, umode;
 363         struct inode *ret;
 364         struct v9fs_fcall *fcall;
 365
 366         ret = NULL;
 367         err = v9fs_t_stat(v9ses, fid, &fcall);
 368         if (err) {
 369                 PRINT_FCALL_ERROR("stat error", fcall);
 370                 goto error;
 371         }
 372
 373         umode = p9mode2unixmode(v9ses, fcall->params.rstat.stat.mode);
 374         ret = v9fs_get_inode(sb, umode);
 375         if (IS_ERR(ret)) {
 376                 err = PTR_ERR(ret);
 377                 ret = NULL;
 378                 goto error;
 379         }
 380
 381         v9fs_stat2inode(&fcall->params.rstat.stat, ret, sb);
 382         kfree(fcall);
 383         return ret;
 384
 385 error:
 386         kfree(fcall);
 387         if (ret)
 388                 iput(ret);
 389
 390         return ERR_PTR(err);
 391 }
 392
 393 /**
 394  * v9fs_remove - helper function to remove files and directories
 395  * @dir: directory inode that is being deleted
 396  * @file:  dentry that is being deleted
 397  * @rmdir: removing a directory
 398  *
 399  */
 400
 401 static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
 402 {
 403         struct v9fs_fcall *fcall = NULL;
 404         struct super_block *sb = NULL;
 405         struct v9fs_session_info *v9ses = NULL;
 406         struct v9fs_fid *v9fid = NULL;
 407         struct inode *file_inode = NULL;
 408         int fid = -1;
 409         int result = 0;
 410
 411         dprintk(DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
 412                 rmdir);
 413
 414         file_inode = file->d_inode;
 415         sb = file_inode->i_sb;
 416         v9ses = v9fs_inode2v9ses(file_inode);
 417         v9fid = v9fs_fid_clone(file);
 418         if(IS_ERR(v9fid))
 419                 return PTR_ERR(v9fid);
 420
 421         fid = v9fid->fid;
 422         if (fid < 0) {
 423                 dprintk(DEBUG_ERROR, "inode #%lu, no fid!\n",
 424                         file_inode->i_ino);
 425                 return -EBADF;
 426         }
 427
 428         result = v9fs_t_remove(v9ses, fid, &fcall);
 429         if (result < 0) {
 430                 PRINT_FCALL_ERROR("remove fails", fcall);
 431                 goto Error;
 432         }
 433
 434         v9fs_put_idpool(fid, &v9ses->fidpool);
 435         v9fs_fid_destroy(v9fid);
 436
 437 Error:
 438         kfree(fcall);
 439         return result;
 440 }
 441
 442 static int
 443 v9fs_open_created(struct inode *inode, struct file *file)
 444 {
 445         return 0;
 446 }
 447
 448 /**
 449  * v9fs_vfs_create - VFS hook to create files
 450  * @inode: directory inode that is being deleted
 451  * @dentry:  dentry that is being deleted
 452  * @mode: create permissions
 453  * @nd: path information
 454  *
 455  */
 456
 457 static int
 458 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
 459                 struct nameidata *nd)
 460 {
 461         int err;
 462         u32 fid, perm, iounit;
 463         int flags;
 464         struct v9fs_session_info *v9ses;
 465         struct v9fs_fid *dfid, *vfid, *ffid;
 466         struct inode *inode;
 467         struct v9fs_qid qid;
 468         struct file *filp;
 469
 470         inode = NULL;
 471         vfid = NULL;
 472         v9ses = v9fs_inode2v9ses(dir);
 473         dfid = v9fs_fid_clone(dentry->d_parent);
 474         if(IS_ERR(dfid)) {
 475                 err = PTR_ERR(dfid);
 476                 goto error;
 477         }
 478
 479         perm = unixmode2p9mode(v9ses, mode);
 480         if (nd && nd->flags & LOOKUP_OPEN)
 481                 flags = nd->intent.open.flags - 1;
 482         else
 483                 flags = O_RDWR;
 484
 485         err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
 486                 perm, v9fs_uflags2omode(flags), NULL, &fid, &qid, &iounit);
 487
 488         if (err)
 489                 goto clunk_dfid;
 490
 491         vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
 492         v9fs_fid_clunk(v9ses, dfid);
 493         if (IS_ERR(vfid)) {
 494                 err = PTR_ERR(vfid);
 495                 vfid = NULL;
 496                 goto error;
 497         }
 498
 499         inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
 500         if (IS_ERR(inode)) {
 501                 err = PTR_ERR(inode);
 502                 inode = NULL;
 503                 goto error;
 504         }
 505
 506         if(v9ses->cache)
 507                 dentry->d_op = &v9fs_cached_dentry_operations;
 508         else
 509                 dentry->d_op = &v9fs_dentry_operations;
 510         d_instantiate(dentry, inode);
 511
 512         if (nd && nd->flags & LOOKUP_OPEN) {
 513                 ffid = v9fs_fid_create(v9ses, fid);
 514                 if (!ffid)
 515                         return -ENOMEM;
 516
 517                 filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
 518                 if (IS_ERR(filp)) {
 519                         v9fs_fid_destroy(ffid);
 520                         return PTR_ERR(filp);
 521                 }
 522
 523                 ffid->rdir_pos = 0;
 524                 ffid->rdir_fcall = NULL;
 525                 ffid->fidopen = 1;
 526                 ffid->iounit = iounit;
 527                 ffid->filp = filp;
 528                 filp->private_data = ffid;
 529         }
 530
 531         return 0;
 532
 533 clunk_dfid:
 534         v9fs_fid_clunk(v9ses, dfid);
 535
 536 error:
 537         if (vfid)
 538                 v9fs_fid_destroy(vfid);
 539
 540         return err;
 541 }
 542
 543 /**
 544  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
 545  * @inode:  inode that is being unlinked
 546  * @dentry: dentry that is being unlinked
 547  * @mode: mode for new directory
 548  *
 549  */
 550
 551 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 552 {
 553         int err;
 554         u32 fid, perm;
 555         struct v9fs_session_info *v9ses;
 556         struct v9fs_fid *dfid, *vfid;
 557         struct inode *inode;
 558
 559         inode = NULL;
 560         vfid = NULL;
 561         v9ses = v9fs_inode2v9ses(dir);
 562         dfid = v9fs_fid_clone(dentry->d_parent);
 563         if(IS_ERR(dfid)) {
 564                 err = PTR_ERR(dfid);
 565                 goto error;
 566         }
 567
 568         perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
 569
 570         err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
 571                 perm, V9FS_OREAD, NULL, &fid, NULL, NULL);
 572
 573         if (err) {
 574                 dprintk(DEBUG_ERROR, "create error %d\n", err);
 575                 goto clean_up_dfid;
 576         }
 577
 578         vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
 579         if (IS_ERR(vfid)) {
 580                 err = PTR_ERR(vfid);
 581                 vfid = NULL;
 582                 goto clean_up_dfid;
 583         }
 584
 585         v9fs_fid_clunk(v9ses, dfid);
 586         inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
 587         if (IS_ERR(inode)) {
 588                 err = PTR_ERR(inode);
 589                 inode = NULL;
 590                 v9fs_fid_destroy(vfid);
 591                 goto error;
 592         }
 593
 594         if(v9ses->cache)
 595                 dentry->d_op = &v9fs_cached_dentry_operations;
 596         else
 597                 dentry->d_op = &v9fs_dentry_operations;
 598         d_instantiate(dentry, inode);
 599         return 0;
 600
 601 clean_up_dfid:
 602         v9fs_fid_clunk(v9ses, dfid);
 603
 604 error:
 605         return err;
 606 }
 607
 608 /**
 609  * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
 610  * @dir:  inode that is being walked from
 611  * @dentry: dentry that is being walked to?
 612  * @nameidata: path data
 613  *
 614  */
 615
 616 static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 617                                       struct nameidata *nameidata)
 618 {
 619         struct super_block *sb;
 620         struct v9fs_session_info *v9ses;
 621         struct v9fs_fid *dirfid;
 622         struct v9fs_fid *fid;
 623         struct inode *inode;
 624         struct v9fs_fcall *fcall = NULL;
 625         int dirfidnum = -1;
 626         int newfid = -1;
 627         int result = 0;
 628
 629         dprintk(DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
 630                 dir, dentry->d_name.name, dentry, nameidata);
 631
 632         sb = dir->i_sb;
 633         v9ses = v9fs_inode2v9ses(dir);
 634         dirfid = v9fs_fid_lookup(dentry->d_parent);
 635
 636         if(IS_ERR(dirfid))
 637                 return ERR_PTR(PTR_ERR(dirfid));
 638
 639         dirfidnum = dirfid->fid;
 640
 641         newfid = v9fs_get_idpool(&v9ses->fidpool);
 642         if (newfid < 0) {
 643                 eprintk(KERN_WARNING, "newfid fails!\n");
 644                 result = -ENOSPC;
 645                 goto Release_Dirfid;
 646         }
 647
 648         result = v9fs_t_walk(v9ses, dirfidnum, newfid,
 649                 (char *)dentry->d_name.name, &fcall);
 650
 651         up(&dirfid->lock);
 652
 653         if (result < 0) {
 654                 if (fcall && fcall->id == RWALK)
 655                         v9fs_t_clunk(v9ses, newfid);
 656                 else
 657                         v9fs_put_idpool(newfid, &v9ses->fidpool);
 658
 659                 if (result == -ENOENT) {
 660                         d_add(dentry, NULL);
 661                         dprintk(DEBUG_VFS,
 662                                 "Return negative dentry %p count %d\n",
 663                                 dentry, atomic_read(&dentry->d_count));
 664                         kfree(fcall);
 665                         return NULL;
 666                 }
 667                 dprintk(DEBUG_ERROR, "walk error:%d\n", result);
 668                 goto FreeFcall;
 669         }
 670         kfree(fcall);
 671
 672         result = v9fs_t_stat(v9ses, newfid, &fcall);
 673         if (result < 0) {
 674                 dprintk(DEBUG_ERROR, "stat error\n");
 675                 goto FreeFcall;
 676         }
 677
 678         inode = v9fs_get_inode(sb, p9mode2unixmode(v9ses,
 679                 fcall->params.rstat.stat.mode));
 680
 681         if (IS_ERR(inode) && (PTR_ERR(inode) == -ENOSPC)) {
 682                 eprintk(KERN_WARNING, "inode alloc failes, returns %ld\n",
 683                         PTR_ERR(inode));
 684
 685                 result = -ENOSPC;
 686                 goto FreeFcall;
 687         }
 688
 689         inode->i_ino = v9fs_qid2ino(&fcall->params.rstat.stat.qid);
 690
 691         fid = v9fs_fid_create(v9ses, newfid);
 692         if (fid == NULL) {
 693                 dprintk(DEBUG_ERROR, "couldn't insert\n");
 694                 result = -ENOMEM;
 695                 goto FreeFcall;
 696         }
 697
 698         result = v9fs_fid_insert(fid, dentry);
 699         if (result < 0)
 700                 goto FreeFcall;
 701
 702         fid->qid = fcall->params.rstat.stat.qid;
 703         v9fs_stat2inode(&fcall->params.rstat.stat, inode, inode->i_sb);
 704         if((fid->qid.version)&&(v9ses->cache))
 705                 dentry->d_op = &v9fs_cached_dentry_operations;
 706         else
 707                 dentry->d_op = &v9fs_dentry_operations;
 708
 709         d_add(dentry, inode);
 710         kfree(fcall);
 711
 712         return NULL;
 713
 714 Release_Dirfid:
 715         up(&dirfid->lock);
 716
 717 FreeFcall:
 718         kfree(fcall);
 719
 720         return ERR_PTR(result);
 721 }
 722
 723 /**
 724  * v9fs_vfs_unlink - VFS unlink hook to delete an inode
 725  * @i:  inode that is being unlinked
 726  * @d: dentry that is being unlinked
 727  *
 728  */
 729
 730 static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
 731 {
 732         return v9fs_remove(i, d, 0);
 733 }
 734
 735 /**
 736  * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
 737  * @i:  inode that is being unlinked
 738  * @d: dentry that is being unlinked
 739  *
 740  */
 741
 742 static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
 743 {
 744         return v9fs_remove(i, d, 1);
 745 }
 746
 747 /**
 748  * v9fs_vfs_rename - VFS hook to rename an inode
 749  * @old_dir:  old dir inode
 750  * @old_dentry: old dentry
 751  * @new_dir: new dir inode
 752  * @new_dentry: new dentry
 753  *
 754  */
 755
 756 static int
 757 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 758                 struct inode *new_dir, struct dentry *new_dentry)
 759 {
 760         struct inode *old_inode = old_dentry->d_inode;
 761         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(old_inode);
 762         struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
 763         struct v9fs_fid *olddirfid;
 764         struct v9fs_fid *newdirfid;
 765         struct v9fs_wstat wstat;
 766         struct v9fs_fcall *fcall = NULL;
 767         int fid = -1;
 768         int olddirfidnum = -1;
 769         int newdirfidnum = -1;
 770         int retval = 0;
 771
 772         dprintk(DEBUG_VFS, "\n");
 773
 774         if(IS_ERR(oldfid))
 775                 return PTR_ERR(oldfid);
 776
 777         olddirfid = v9fs_fid_clone(old_dentry->d_parent);
 778         if(IS_ERR(olddirfid)) {
 779                 retval = PTR_ERR(olddirfid);
 780                 goto Release_lock;
 781         }
 782
 783         newdirfid = v9fs_fid_clone(new_dentry->d_parent);
 784         if(IS_ERR(newdirfid)) {
 785                 retval = PTR_ERR(newdirfid);
 786                 goto Clunk_olddir;
 787         }
 788
 789         /* 9P can only handle file rename in the same directory */
 790         if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
 791                 dprintk(DEBUG_ERROR, "old dir and new dir are different\n");
 792                 retval = -EXDEV;
 793                 goto Clunk_newdir;
 794         }
 795
 796         fid = oldfid->fid;
 797         olddirfidnum = olddirfid->fid;
 798         newdirfidnum = newdirfid->fid;
 799
 800         if (fid < 0) {
 801                 dprintk(DEBUG_ERROR, "no fid for old file #%lu\n",
 802                         old_inode->i_ino);
 803                 retval = -EBADF;
 804                 goto Clunk_newdir;
 805         }
 806
 807         v9fs_blank_wstat(&wstat);
 808         wstat.muid = v9ses->name;
 809         wstat.name = (char *) new_dentry->d_name.name;
 810
 811         retval = v9fs_t_wstat(v9ses, fid, &wstat, &fcall);
 812
 813         if (retval < 0)
 814                 PRINT_FCALL_ERROR("wstat error", fcall);
 815
 816         kfree(fcall);
 817
 818 Clunk_newdir:
 819         v9fs_fid_clunk(v9ses, newdirfid);
 820
 821 Clunk_olddir:
 822         v9fs_fid_clunk(v9ses, olddirfid);
 823
 824 Release_lock:
 825         up(&oldfid->lock);
 826
 827         return retval;
 828 }
 829
 830 /**
 831  * v9fs_vfs_getattr - retrieve file metadata
 832  * @mnt - mount information
 833  * @dentry - file to get attributes on
 834  * @stat - metadata structure to populate
 835  *
 836  */
 837
 838 static int
 839 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 840                  struct kstat *stat)
 841 {
 842         struct v9fs_fcall *fcall = NULL;
 843         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
 844         struct v9fs_fid *fid = v9fs_fid_clone(dentry);
 845         int err = -EPERM;
 846
 847         dprintk(DEBUG_VFS, "dentry: %p\n", dentry);
 848         if(IS_ERR(fid))
 849                 return PTR_ERR(fid);
 850
 851         err = v9fs_t_stat(v9ses, fid->fid, &fcall);
 852
 853         if (err < 0)
 854                 dprintk(DEBUG_ERROR, "stat error\n");
 855         else {
 856                 v9fs_stat2inode(&fcall->params.rstat.stat, dentry->d_inode,
 857                                   dentry->d_inode->i_sb);
 858                 generic_fillattr(dentry->d_inode, stat);
 859         }
 860
 861         kfree(fcall);
 862         v9fs_fid_clunk(v9ses, fid);
 863         return err;
 864 }
 865
 866 /**
 867  * v9fs_vfs_setattr - set file metadata
 868  * @dentry: file whose metadata to set
 869  * @iattr: metadata assignment structure
 870  *
 871  */
 872
 873 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
 874 {
 875         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
 876         struct v9fs_fid *fid = v9fs_fid_clone(dentry);
 877         struct v9fs_fcall *fcall = NULL;
 878         struct v9fs_wstat wstat;
 879         int res = -EPERM;
 880
 881         dprintk(DEBUG_VFS, "\n");
 882         if(IS_ERR(fid))
 883                 return PTR_ERR(fid);
 884
 885         v9fs_blank_wstat(&wstat);
 886         if (iattr->ia_valid & ATTR_MODE)
 887                 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
 888
 889         if (iattr->ia_valid & ATTR_MTIME)
 890                 wstat.mtime = iattr->ia_mtime.tv_sec;
 891
 892         if (iattr->ia_valid & ATTR_ATIME)
 893                 wstat.atime = iattr->ia_atime.tv_sec;
 894
 895         if (iattr->ia_valid & ATTR_SIZE)
 896                 wstat.length = iattr->ia_size;
 897
 898         if (v9ses->extended) {
 899                 if (iattr->ia_valid & ATTR_UID)
 900                         wstat.n_uid = iattr->ia_uid;
 901
 902                 if (iattr->ia_valid & ATTR_GID)
 903                         wstat.n_gid = iattr->ia_gid;
 904         }
 905
 906         res = v9fs_t_wstat(v9ses, fid->fid, &wstat, &fcall);
 907
 908         if (res < 0)
 909                 PRINT_FCALL_ERROR("wstat error", fcall);
 910
 911         kfree(fcall);
 912         if (res >= 0)
 913                 res = inode_setattr(dentry->d_inode, iattr);
 914
 915         v9fs_fid_clunk(v9ses, fid);
 916         return res;
 917 }
 918
 919 /**
 920  * v9fs_stat2inode - populate an inode structure with mistat info
 921  * @stat: Plan 9 metadata (mistat) structure
 922  * @inode: inode to populate
 923  * @sb: superblock of filesystem
 924  *
 925  */
 926
 927 void
 928 v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
 929         struct super_block *sb)
 930 {
 931         int n;
 932         char ext[32];
 933         struct v9fs_session_info *v9ses = sb->s_fs_info;
 934
 935         inode->i_nlink = 1;
 936
 937         inode->i_atime.tv_sec = stat->atime;
 938         inode->i_mtime.tv_sec = stat->mtime;
 939         inode->i_ctime.tv_sec = stat->mtime;
 940
 941         inode->i_uid = v9ses->uid;
 942         inode->i_gid = v9ses->gid;
 943
 944         if (v9ses->extended) {
 945                 inode->i_uid = stat->n_uid;
 946                 inode->i_gid = stat->n_gid;
 947         }
 948
 949         inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
 950         if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
 951                 char type = 0;
 952                 int major = -1;
 953                 int minor = -1;
 954
 955                 n = stat->extension.len;
 956                 if (n > sizeof(ext)-1)
 957                         n = sizeof(ext)-1;
 958                 memmove(ext, stat->extension.str, n);
 959                 ext[n] = 0;
 960                 sscanf(ext, "%c %u %u", &type, &major, &minor);
 961                 switch (type) {
 962                 case 'c':
 963                         inode->i_mode &= ~S_IFBLK;
 964                         inode->i_mode |= S_IFCHR;
 965                         break;
 966                 case 'b':
 967                         break;
 968                 default:
 969                         dprintk(DEBUG_ERROR, "Unknown special type %c (%.*s)\n",
 970                                 type, stat->extension.len, stat->extension.str);
 971                 };
 972                 inode->i_rdev = MKDEV(major, minor);
 973         } else
 974                 inode->i_rdev = 0;
 975
 976         inode->i_size = stat->length;
 977
 978         inode->i_blocks =
 979             (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
 980 }
 981
 982 /**
 983  * v9fs_qid2ino - convert qid into inode number
 984  * @qid: qid to hash
 985  *
 986  * BUG: potential for inode number collisions?
 987  */
 988
 989 ino_t v9fs_qid2ino(struct v9fs_qid *qid)
 990 {
 991         u64 path = qid->path + 2;
 992         ino_t i = 0;
 993
 994         if (sizeof(ino_t) == sizeof(path))
 995                 memcpy(&i, &path, sizeof(ino_t));
 996         else
 997                 i = (ino_t) (path ^ (path >> 32));
 998
 999         return i;
1000 }
1001
1002 /**
1003  * v9fs_readlink - read a symlink's location (internal version)
1004  * @dentry: dentry for symlink
1005  * @buffer: buffer to load symlink location into
1006  * @buflen: length of buffer
1007  *
1008  */
1009
1010 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1011 {
1012         int retval = -EPERM;
1013
1014         struct v9fs_fcall *fcall = NULL;
1015         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
1016         struct v9fs_fid *fid = v9fs_fid_clone(dentry);
1017
1018         if(IS_ERR(fid))
1019                 return PTR_ERR(fid);
1020
1021         if (!v9ses->extended) {
1022                 retval = -EBADF;
1023                 dprintk(DEBUG_ERROR, "not extended\n");
1024                 goto ClunkFid;
1025         }
1026
1027         dprintk(DEBUG_VFS, " %s\n", dentry->d_name.name);
1028         retval = v9fs_t_stat(v9ses, fid->fid, &fcall);
1029
1030         if (retval < 0) {
1031                 dprintk(DEBUG_ERROR, "stat error\n");
1032                 goto FreeFcall;
1033         }
1034
1035         if (!fcall) {
1036                 retval = -EIO;
1037                 goto ClunkFid;
1038         }
1039
1040         if (!(fcall->params.rstat.stat.mode & V9FS_DMSYMLINK)) {
1041                 retval = -EINVAL;
1042                 goto FreeFcall;
1043         }
1044
1045         /* copy extension buffer into buffer */
1046         if (fcall->params.rstat.stat.extension.len < buflen)
1047                 buflen = fcall->params.rstat.stat.extension.len + 1;
1048
1049         memmove(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
1050         buffer[buflen-1] = 0;
1051
1052         dprintk(DEBUG_ERROR, "%s -> %.*s (%s)\n", dentry->d_name.name, fcall->params.rstat.stat.extension.len,
1053                 fcall->params.rstat.stat.extension.str, buffer);
1054         retval = buflen;
1055
1056 FreeFcall:
1057         kfree(fcall);
1058
1059 ClunkFid:
1060         v9fs_fid_clunk(v9ses, fid);
1061
1062         return retval;
1063 }
1064
1065 /**
1066  * v9fs_vfs_readlink - read a symlink's location
1067  * @dentry: dentry for symlink
1068  * @buf: buffer to load symlink location into
1069  * @buflen: length of buffer
1070  *
1071  */
1072
1073 static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer,
1074                              int buflen)
1075 {
1076         int retval;
1077         int ret;
1078         char *link = __getname();
1079
1080         if (unlikely(!link))
1081                 return -ENOMEM;
1082
1083         if (buflen > PATH_MAX)
1084                 buflen = PATH_MAX;
1085
1086         dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
1087
1088         retval = v9fs_readlink(dentry, link, buflen);
1089
1090         if (retval > 0) {
1091                 if ((ret = copy_to_user(buffer, link, retval)) != 0) {
1092                         dprintk(DEBUG_ERROR, "problem copying to user: %d\n",
1093                                 ret);
1094                         retval = ret;
1095                 }
1096         }
1097
1098         __putname(link);
1099         return retval;
1100 }
1101
1102 /**
1103  * v9fs_vfs_follow_link - follow a symlink path
1104  * @dentry: dentry for symlink
1105  * @nd: nameidata
1106  *
1107  */
1108
1109 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1110 {
1111         int len = 0;
1112         char *link = __getname();
1113
1114         dprintk(DEBUG_VFS, "%s n", dentry->d_name.name);
1115
1116         if (!link)
1117                 link = ERR_PTR(-ENOMEM);
1118         else {
1119                 len = v9fs_readlink(dentry, link, PATH_MAX);
1120
1121                 if (len < 0) {
1122                         __putname(link);
1123                         link = ERR_PTR(len);
1124                 } else
1125                         link[len] = 0;
1126         }
1127         nd_set_link(nd, link);
1128
1129         return NULL;
1130 }
1131
1132 /**
1133  * v9fs_vfs_put_link - release a symlink path
1134  * @dentry: dentry for symlink
1135  * @nd: nameidata
1136  *
1137  */
1138
1139 static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1140 {
1141         char *s = nd_get_link(nd);
1142
1143         dprintk(DEBUG_VFS, " %s %s\n", dentry->d_name.name, s);
1144         if (!IS_ERR(s))
1145                 __putname(s);
1146 }
1147
1148 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1149         int mode, const char *extension)
1150 {
1151         int err;
1152         u32 fid, perm;
1153         struct v9fs_session_info *v9ses;
1154         struct v9fs_fid *dfid, *vfid = NULL;
1155         struct inode *inode = NULL;
1156
1157         v9ses = v9fs_inode2v9ses(dir);
1158         if (!v9ses->extended) {
1159                 dprintk(DEBUG_ERROR, "not extended\n");
1160                 return -EPERM;
1161         }
1162
1163         dfid = v9fs_fid_clone(dentry->d_parent);
1164         if(IS_ERR(dfid)) {
1165                 err = PTR_ERR(dfid);
1166                 goto error;
1167         }
1168
1169         perm = unixmode2p9mode(v9ses, mode);
1170
1171         err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
1172                 perm, V9FS_OREAD, (char *) extension, &fid, NULL, NULL);
1173
1174         if (err)
1175                 goto clunk_dfid;
1176
1177         err = v9fs_t_clunk(v9ses, fid);
1178         if (err)
1179                 goto clunk_dfid;
1180
1181         vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
1182         if (IS_ERR(vfid)) {
1183                 err = PTR_ERR(vfid);
1184                 vfid = NULL;
1185                 goto clunk_dfid;
1186         }
1187
1188         inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
1189         if (IS_ERR(inode)) {
1190                 err = PTR_ERR(inode);
1191                 inode = NULL;
1192                 goto free_vfid;
1193         }
1194
1195         if(v9ses->cache)
1196                 dentry->d_op = &v9fs_cached_dentry_operations;
1197         else
1198                 dentry->d_op = &v9fs_dentry_operations;
1199         d_instantiate(dentry, inode);
1200         return 0;
1201
1202 free_vfid:
1203         v9fs_fid_destroy(vfid);
1204
1205 clunk_dfid:
1206         v9fs_fid_clunk(v9ses, dfid);
1207
1208 error:
1209         return err;
1210
1211 }
1212
1213 /**
1214  * v9fs_vfs_symlink - helper function to create symlinks
1215  * @dir: directory inode containing symlink
1216  * @dentry: dentry for symlink
1217  * @symname: symlink data
1218  *
1219  * See 9P2000.u RFC for more information
1220  *
1221  */
1222
1223 static int
1224 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1225 {
1226         dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
1227                 symname);
1228
1229         return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1230 }
1231
1232 /**
1233  * v9fs_vfs_link - create a hardlink
1234  * @old_dentry: dentry for file to link to
1235  * @dir: inode destination for new link
1236  * @dentry: dentry for link
1237  *
1238  */
1239
1240 /* XXX - lots of code dup'd from symlink and creates,
1241  * figure out a better reuse strategy
1242  */
1243
1244 static int
1245 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1246               struct dentry *dentry)
1247 {
1248         int retval;
1249         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
1250         struct v9fs_fid *oldfid;
1251         char *name;
1252
1253         dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
1254                 old_dentry->d_name.name);
1255
1256         oldfid = v9fs_fid_clone(old_dentry);
1257         if(IS_ERR(oldfid))
1258                 return PTR_ERR(oldfid);
1259
1260         name = __getname();
1261         if (unlikely(!name)) {
1262                 retval = -ENOMEM;
1263                 goto clunk_fid;
1264         }
1265
1266         sprintf(name, "%d\n", oldfid->fid);
1267         retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
1268         __putname(name);
1269
1270 clunk_fid:
1271         v9fs_fid_clunk(v9ses, oldfid);
1272         return retval;
1273 }
1274
1275 /**
1276  * v9fs_vfs_mknod - create a special file
1277  * @dir: inode destination for new link
1278  * @dentry: dentry for file
1279  * @mode: mode for creation
1280  * @dev_t: device associated with special file
1281  *
1282  */
1283
1284 static int
1285 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1286 {
1287         int retval;
1288         char *name;
1289
1290         dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1291                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1292
1293         if (!new_valid_dev(rdev))
1294                 return -EINVAL;
1295
1296         name = __getname();
1297         if (!name)
1298                 return -ENOMEM;
1299         /* build extension */
1300         if (S_ISBLK(mode))
1301                 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1302         else if (S_ISCHR(mode))
1303                 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1304         else if (S_ISFIFO(mode))
1305                 *name = 0;
1306         else {
1307                 __putname(name);
1308                 return -EINVAL;
1309         }
1310
1311         retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1312         __putname(name);
1313
1314         return retval;
1315 }
1316
1317 static const struct inode_operations v9fs_dir_inode_operations_ext = {
1318         .create = v9fs_vfs_create,
1319         .lookup = v9fs_vfs_lookup,
1320         .symlink = v9fs_vfs_symlink,
1321         .link = v9fs_vfs_link,
1322         .unlink = v9fs_vfs_unlink,
1323         .mkdir = v9fs_vfs_mkdir,
1324         .rmdir = v9fs_vfs_rmdir,
1325         .mknod = v9fs_vfs_mknod,
1326         .rename = v9fs_vfs_rename,
1327         .readlink = v9fs_vfs_readlink,
1328         .getattr = v9fs_vfs_getattr,
1329         .setattr = v9fs_vfs_setattr,
1330 };
1331
1332 static const struct inode_operations v9fs_dir_inode_operations = {
1333         .create = v9fs_vfs_create,
1334         .lookup = v9fs_vfs_lookup,
1335         .unlink = v9fs_vfs_unlink,
1336         .mkdir = v9fs_vfs_mkdir,
1337         .rmdir = v9fs_vfs_rmdir,
1338         .mknod = v9fs_vfs_mknod,
1339         .rename = v9fs_vfs_rename,
1340         .getattr = v9fs_vfs_getattr,
1341         .setattr = v9fs_vfs_setattr,
1342 };
1343
1344 static const struct inode_operations v9fs_file_inode_operations = {
1345         .getattr = v9fs_vfs_getattr,
1346         .setattr = v9fs_vfs_setattr,
1347 };
1348
1349 static const struct inode_operations v9fs_symlink_inode_operations = {
1350         .readlink = v9fs_vfs_readlink,
1351         .follow_link = v9fs_vfs_follow_link,
1352         .put_link = v9fs_vfs_put_link,
1353         .getattr = v9fs_vfs_getattr,
1354         .setattr = v9fs_vfs_setattr,
1355 };