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