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 #include <linux/sched.h>
  37 #include <linux/slab.h>
  38 #include <linux/xattr.h>
  39 #include <linux/posix_acl.h>
  40 #include <net/9p/9p.h>
  41 #include <net/9p/client.h>
  42
  43 #include "v9fs.h"
  44 #include "v9fs_vfs.h"
  45 #include "fid.h"
  46 #include "cache.h"
  47 #include "xattr.h"
  48 #include "acl.h"
  49
  50 static const struct inode_operations v9fs_dir_inode_operations;
  51 static const struct inode_operations v9fs_dir_inode_operations_dotu;
  52 static const struct inode_operations v9fs_dir_inode_operations_dotl;
  53 static const struct inode_operations v9fs_file_inode_operations;
  54 static const struct inode_operations v9fs_file_inode_operations_dotl;
  55 static const struct inode_operations v9fs_symlink_inode_operations;
  56 static const struct inode_operations v9fs_symlink_inode_operations_dotl;
  57
  58 static int
  59 v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
  60                     dev_t rdev);
  61
  62 /**
  63  * unixmode2p9mode - convert unix mode bits to plan 9
  64  * @v9ses: v9fs session information
  65  * @mode: mode to convert
  66  *
  67  */
  68
  69 static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
  70 {
  71         int res;
  72         res = mode & 0777;
  73         if (S_ISDIR(mode))
  74                 res |= P9_DMDIR;
  75         if (v9fs_proto_dotu(v9ses)) {
  76                 if (S_ISLNK(mode))
  77                         res |= P9_DMSYMLINK;
  78                 if (v9ses->nodev == 0) {
  79                         if (S_ISSOCK(mode))
  80                                 res |= P9_DMSOCKET;
  81                         if (S_ISFIFO(mode))
  82                                 res |= P9_DMNAMEDPIPE;
  83                         if (S_ISBLK(mode))
  84                                 res |= P9_DMDEVICE;
  85                         if (S_ISCHR(mode))
  86                                 res |= P9_DMDEVICE;
  87                 }
  88
  89                 if ((mode & S_ISUID) == S_ISUID)
  90                         res |= P9_DMSETUID;
  91                 if ((mode & S_ISGID) == S_ISGID)
  92                         res |= P9_DMSETGID;
  93                 if ((mode & S_ISVTX) == S_ISVTX)
  94                         res |= P9_DMSETVTX;
  95                 if ((mode & P9_DMLINK))
  96                         res |= P9_DMLINK;
  97         }
  98
  99         return res;
 100 }
 101
 102 /**
 103  * p9mode2unixmode- convert plan9 mode bits to unix mode bits
 104  * @v9ses: v9fs session information
 105  * @mode: mode to convert
 106  *
 107  */
 108
 109 static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
 110 {
 111         int res;
 112
 113         res = mode & 0777;
 114
 115         if ((mode & P9_DMDIR) == P9_DMDIR)
 116                 res |= S_IFDIR;
 117         else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
 118                 res |= S_IFLNK;
 119         else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
 120                  && (v9ses->nodev == 0))
 121                 res |= S_IFSOCK;
 122         else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
 123                  && (v9ses->nodev == 0))
 124                 res |= S_IFIFO;
 125         else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
 126                  && (v9ses->nodev == 0))
 127                 res |= S_IFBLK;
 128         else
 129                 res |= S_IFREG;
 130
 131         if (v9fs_proto_dotu(v9ses)) {
 132                 if ((mode & P9_DMSETUID) == P9_DMSETUID)
 133                         res |= S_ISUID;
 134
 135                 if ((mode & P9_DMSETGID) == P9_DMSETGID)
 136                         res |= S_ISGID;
 137
 138                 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
 139                         res |= S_ISVTX;
 140         }
 141
 142         return res;
 143 }
 144
 145 /**
 146  * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
 147  * @uflags: flags to convert
 148  * @extended: if .u extensions are active
 149  */
 150
 151 int v9fs_uflags2omode(int uflags, int extended)
 152 {
 153         int ret;
 154
 155         ret = 0;
 156         switch (uflags&3) {
 157         default:
 158         case O_RDONLY:
 159                 ret = P9_OREAD;
 160                 break;
 161
 162         case O_WRONLY:
 163                 ret = P9_OWRITE;
 164                 break;
 165
 166         case O_RDWR:
 167                 ret = P9_ORDWR;
 168                 break;
 169         }
 170
 171         if (uflags & O_TRUNC)
 172                 ret |= P9_OTRUNC;
 173
 174         if (extended) {
 175                 if (uflags & O_EXCL)
 176                         ret |= P9_OEXCL;
 177
 178                 if (uflags & O_APPEND)
 179                         ret |= P9_OAPPEND;
 180         }
 181
 182         return ret;
 183 }
 184
 185 /**
 186  * v9fs_blank_wstat - helper function to setup a 9P stat structure
 187  * @wstat: structure to initialize
 188  *
 189  */
 190
 191 void
 192 v9fs_blank_wstat(struct p9_wstat *wstat)
 193 {
 194         wstat->type = ~0;
 195         wstat->dev = ~0;
 196         wstat->qid.type = ~0;
 197         wstat->qid.version = ~0;
 198         *((long long *)&wstat->qid.path) = ~0;
 199         wstat->mode = ~0;
 200         wstat->atime = ~0;
 201         wstat->mtime = ~0;
 202         wstat->length = ~0;
 203         wstat->name = NULL;
 204         wstat->uid = NULL;
 205         wstat->gid = NULL;
 206         wstat->muid = NULL;
 207         wstat->n_uid = ~0;
 208         wstat->n_gid = ~0;
 209         wstat->n_muid = ~0;
 210         wstat->extension = NULL;
 211 }
 212
 213 #ifdef CONFIG_9P_FSCACHE
 214 /**
 215  * v9fs_alloc_inode - helper function to allocate an inode
 216  * This callback is executed before setting up the inode so that we
 217  * can associate a vcookie with each inode.
 218  *
 219  */
 220
 221 struct inode *v9fs_alloc_inode(struct super_block *sb)
 222 {
 223         struct v9fs_cookie *vcookie;
 224         vcookie = (struct v9fs_cookie *)kmem_cache_alloc(vcookie_cache,
 225                                                          GFP_KERNEL);
 226         if (!vcookie)
 227                 return NULL;
 228
 229         vcookie->fscache = NULL;
 230         vcookie->qid = NULL;
 231         spin_lock_init(&vcookie->lock);
 232         return &vcookie->inode;
 233 }
 234
 235 /**
 236  * v9fs_destroy_inode - destroy an inode
 237  *
 238  */
 239
 240 void v9fs_destroy_inode(struct inode *inode)
 241 {
 242         kmem_cache_free(vcookie_cache, v9fs_inode2cookie(inode));
 243 }
 244 #endif
 245
 246 /**
 247  * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a
 248  * new file system object. This checks the S_ISGID to determine the owning
 249  * group of the new file system object.
 250  */
 251
 252 static gid_t v9fs_get_fsgid_for_create(struct inode *dir_inode)
 253 {
 254         BUG_ON(dir_inode == NULL);
 255
 256         if (dir_inode->i_mode & S_ISGID) {
 257                 /* set_gid bit is set.*/
 258                 return dir_inode->i_gid;
 259         }
 260         return current_fsgid();
 261 }
 262
 263 /**
 264  * v9fs_dentry_from_dir_inode - helper function to get the dentry from
 265  * dir inode.
 266  *
 267  */
 268
 269 static struct dentry *v9fs_dentry_from_dir_inode(struct inode *inode)
 270 {
 271         struct dentry *dentry;
 272
 273         spin_lock(&dcache_lock);
 274         /* Directory should have only one entry. */
 275         BUG_ON(S_ISDIR(inode->i_mode) && !list_is_singular(&inode->i_dentry));
 276         dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias);
 277         spin_unlock(&dcache_lock);
 278         return dentry;
 279 }
 280
 281 /**
 282  * v9fs_get_inode - helper function to setup an inode
 283  * @sb: superblock
 284  * @mode: mode to setup inode with
 285  *
 286  */
 287
 288 struct inode *v9fs_get_inode(struct super_block *sb, int mode)
 289 {
 290         int err;
 291         struct inode *inode;
 292         struct v9fs_session_info *v9ses = sb->s_fs_info;
 293
 294         P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
 295
 296         inode = new_inode(sb);
 297         if (!inode) {
 298                 P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
 299                 return ERR_PTR(-ENOMEM);
 300         }
 301
 302         inode_init_owner(inode, NULL, mode);
 303         inode->i_blocks = 0;
 304         inode->i_rdev = 0;
 305         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 306         inode->i_mapping->a_ops = &v9fs_addr_operations;
 307
 308         switch (mode & S_IFMT) {
 309         case S_IFIFO:
 310         case S_IFBLK:
 311         case S_IFCHR:
 312         case S_IFSOCK:
 313                 if (v9fs_proto_dotl(v9ses)) {
 314                         inode->i_op = &v9fs_file_inode_operations_dotl;
 315                         inode->i_fop = &v9fs_file_operations_dotl;
 316                 } else if (v9fs_proto_dotu(v9ses)) {
 317                         inode->i_op = &v9fs_file_inode_operations;
 318                         inode->i_fop = &v9fs_file_operations;
 319                 } else {
 320                         P9_DPRINTK(P9_DEBUG_ERROR,
 321                                    "special files without extended mode\n");
 322                         err = -EINVAL;
 323                         goto error;
 324                 }
 325                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
 326                 break;
 327         case S_IFREG:
 328                 if (v9fs_proto_dotl(v9ses)) {
 329                         inode->i_op = &v9fs_file_inode_operations_dotl;
 330                         inode->i_fop = &v9fs_file_operations_dotl;
 331                 } else {
 332                         inode->i_op = &v9fs_file_inode_operations;
 333                         inode->i_fop = &v9fs_file_operations;
 334                 }
 335
 336                 break;
 337
 338         case S_IFLNK:
 339                 if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
 340                         P9_DPRINTK(P9_DEBUG_ERROR, "extended modes used with "
 341                                                 "legacy protocol.\n");
 342                         err = -EINVAL;
 343                         goto error;
 344                 }
 345
 346                 if (v9fs_proto_dotl(v9ses))
 347                         inode->i_op = &v9fs_symlink_inode_operations_dotl;
 348                 else
 349                         inode->i_op = &v9fs_symlink_inode_operations;
 350
 351                 break;
 352         case S_IFDIR:
 353                 inc_nlink(inode);
 354                 if (v9fs_proto_dotl(v9ses))
 355                         inode->i_op = &v9fs_dir_inode_operations_dotl;
 356                 else if (v9fs_proto_dotu(v9ses))
 357                         inode->i_op = &v9fs_dir_inode_operations_dotu;
 358                 else
 359                         inode->i_op = &v9fs_dir_inode_operations;
 360
 361                 if (v9fs_proto_dotl(v9ses))
 362                         inode->i_fop = &v9fs_dir_operations_dotl;
 363                 else
 364                         inode->i_fop = &v9fs_dir_operations;
 365
 366                 break;
 367         default:
 368                 P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
 369                            mode, mode & S_IFMT);
 370                 err = -EINVAL;
 371                 goto error;
 372         }
 373
 374         return inode;
 375
 376 error:
 377         iput(inode);
 378         return ERR_PTR(err);
 379 }
 380
 381 /*
 382 static struct v9fs_fid*
 383 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
 384 {
 385         int err;
 386         int nfid;
 387         struct v9fs_fid *ret;
 388         struct v9fs_fcall *fcall;
 389
 390         nfid = v9fs_get_idpool(&v9ses->fidpool);
 391         if (nfid < 0) {
 392                 eprintk(KERN_WARNING, "no free fids available\n");
 393                 return ERR_PTR(-ENOSPC);
 394         }
 395
 396         err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
 397                 &fcall);
 398
 399         if (err < 0) {
 400                 if (fcall && fcall->id == RWALK)
 401                         goto clunk_fid;
 402
 403                 PRINT_FCALL_ERROR("walk error", fcall);
 404                 v9fs_put_idpool(nfid, &v9ses->fidpool);
 405                 goto error;
 406         }
 407
 408         kfree(fcall);
 409         fcall = NULL;
 410         ret = v9fs_fid_create(v9ses, nfid);
 411         if (!ret) {
 412                 err = -ENOMEM;
 413                 goto clunk_fid;
 414         }
 415
 416         err = v9fs_fid_insert(ret, dentry);
 417         if (err < 0) {
 418                 v9fs_fid_destroy(ret);
 419                 goto clunk_fid;
 420         }
 421
 422         return ret;
 423
 424 clunk_fid:
 425         v9fs_t_clunk(v9ses, nfid);
 426
 427 error:
 428         kfree(fcall);
 429         return ERR_PTR(err);
 430 }
 431 */
 432
 433
 434 /**
 435  * v9fs_clear_inode - release an inode
 436  * @inode: inode to release
 437  *
 438  */
 439 void v9fs_evict_inode(struct inode *inode)
 440 {
 441         truncate_inode_pages(inode->i_mapping, 0);
 442         end_writeback(inode);
 443         filemap_fdatawrite(inode->i_mapping);
 444
 445 #ifdef CONFIG_9P_FSCACHE
 446         v9fs_cache_inode_put_cookie(inode);
 447 #endif
 448 }
 449
 450 static struct inode *
 451 v9fs_inode(struct v9fs_session_info *v9ses, struct p9_fid *fid,
 452         struct super_block *sb)
 453 {
 454         int err, umode;
 455         struct inode *ret = NULL;
 456         struct p9_wstat *st;
 457
 458         st = p9_client_stat(fid);
 459         if (IS_ERR(st))
 460                 return ERR_CAST(st);
 461
 462         umode = p9mode2unixmode(v9ses, st->mode);
 463         ret = v9fs_get_inode(sb, umode);
 464         if (IS_ERR(ret)) {
 465                 err = PTR_ERR(ret);
 466                 goto error;
 467         }
 468
 469         v9fs_stat2inode(st, ret, sb);
 470         ret->i_ino = v9fs_qid2ino(&st->qid);
 471
 472 #ifdef CONFIG_9P_FSCACHE
 473         v9fs_vcookie_set_qid(ret, &st->qid);
 474         v9fs_cache_inode_get_cookie(ret);
 475 #endif
 476         p9stat_free(st);
 477         kfree(st);
 478         return ret;
 479 error:
 480         p9stat_free(st);
 481         kfree(st);
 482         return ERR_PTR(err);
 483 }
 484
 485 static struct inode *
 486 v9fs_inode_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid,
 487         struct super_block *sb)
 488 {
 489         struct inode *ret = NULL;
 490         int err;
 491         struct p9_stat_dotl *st;
 492
 493         st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
 494         if (IS_ERR(st))
 495                 return ERR_CAST(st);
 496
 497         ret = v9fs_get_inode(sb, st->st_mode);
 498         if (IS_ERR(ret)) {
 499                 err = PTR_ERR(ret);
 500                 goto error;
 501         }
 502
 503         v9fs_stat2inode_dotl(st, ret);
 504         ret->i_ino = v9fs_qid2ino(&st->qid);
 505 #ifdef CONFIG_9P_FSCACHE
 506         v9fs_vcookie_set_qid(ret, &st->qid);
 507         v9fs_cache_inode_get_cookie(ret);
 508 #endif
 509         err = v9fs_get_acl(ret, fid);
 510         if (err) {
 511                 iput(ret);
 512                 goto error;
 513         }
 514         kfree(st);
 515         return ret;
 516 error:
 517         kfree(st);
 518         return ERR_PTR(err);
 519 }
 520
 521 /**
 522  * v9fs_inode_from_fid - Helper routine to populate an inode by
 523  * issuing a attribute request
 524  * @v9ses: session information
 525  * @fid: fid to issue attribute request for
 526  * @sb: superblock on which to create inode
 527  *
 528  */
 529 static inline struct inode *
 530 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
 531                         struct super_block *sb)
 532 {
 533         if (v9fs_proto_dotl(v9ses))
 534                 return v9fs_inode_dotl(v9ses, fid, sb);
 535         else
 536                 return v9fs_inode(v9ses, fid, sb);
 537 }
 538
 539 /**
 540  * v9fs_remove - helper function to remove files and directories
 541  * @dir: directory inode that is being deleted
 542  * @file:  dentry that is being deleted
 543  * @rmdir: removing a directory
 544  *
 545  */
 546
 547 static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
 548 {
 549         int retval;
 550         struct inode *file_inode;
 551         struct p9_fid *v9fid;
 552
 553         P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
 554                 rmdir);
 555
 556         file_inode = file->d_inode;
 557         v9fid = v9fs_fid_clone(file);
 558         if (IS_ERR(v9fid))
 559                 return PTR_ERR(v9fid);
 560
 561         retval = p9_client_remove(v9fid);
 562         if (!retval)
 563                 drop_nlink(file_inode);
 564         return retval;
 565 }
 566
 567 /**
 568  * v9fs_create - Create a file
 569  * @v9ses: session information
 570  * @dir: directory that dentry is being created in
 571  * @dentry:  dentry that is being created
 572  * @extension: 9p2000.u extension string to support devices, etc.
 573  * @perm: create permissions
 574  * @mode: open mode
 575  *
 576  */
 577 static struct p9_fid *
 578 v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
 579                 struct dentry *dentry, char *extension, u32 perm, u8 mode)
 580 {
 581         int err;
 582         char *name;
 583         struct p9_fid *dfid, *ofid, *fid;
 584         struct inode *inode;
 585
 586         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
 587
 588         err = 0;
 589         ofid = NULL;
 590         fid = NULL;
 591         name = (char *) dentry->d_name.name;
 592         dfid = v9fs_fid_lookup(dentry->d_parent);
 593         if (IS_ERR(dfid)) {
 594                 err = PTR_ERR(dfid);
 595                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
 596                 return ERR_PTR(err);
 597         }
 598
 599         /* clone a fid to use for creation */
 600         ofid = p9_client_walk(dfid, 0, NULL, 1);
 601         if (IS_ERR(ofid)) {
 602                 err = PTR_ERR(ofid);
 603                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
 604                 return ERR_PTR(err);
 605         }
 606
 607         err = p9_client_fcreate(ofid, name, perm, mode, extension);
 608         if (err < 0) {
 609                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
 610                 goto error;
 611         }
 612
 613         /* now walk from the parent so we can get unopened fid */
 614         fid = p9_client_walk(dfid, 1, &name, 1);
 615         if (IS_ERR(fid)) {
 616                 err = PTR_ERR(fid);
 617                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
 618                 fid = NULL;
 619                 goto error;
 620         }
 621
 622         /* instantiate inode and assign the unopened fid to the dentry */
 623         inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
 624         if (IS_ERR(inode)) {
 625                 err = PTR_ERR(inode);
 626                 P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
 627                 goto error;
 628         }
 629
 630         if (v9ses->cache)
 631                 dentry->d_op = &v9fs_cached_dentry_operations;
 632         else
 633                 dentry->d_op = &v9fs_dentry_operations;
 634
 635         d_instantiate(dentry, inode);
 636         err = v9fs_fid_add(dentry, fid);
 637         if (err < 0)
 638                 goto error;
 639
 640         return ofid;
 641
 642 error:
 643         if (ofid)
 644                 p9_client_clunk(ofid);
 645
 646         if (fid)
 647                 p9_client_clunk(fid);
 648
 649         return ERR_PTR(err);
 650 }
 651
 652 /**
 653  * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol.
 654  * @dir: directory inode that is being created
 655  * @dentry:  dentry that is being deleted
 656  * @mode: create permissions
 657  * @nd: path information
 658  *
 659  */
 660
 661 static int
 662 v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int omode,
 663                 struct nameidata *nd)
 664 {
 665         int err = 0;
 666         char *name = NULL;
 667         gid_t gid;
 668         int flags;
 669         mode_t mode;
 670         struct v9fs_session_info *v9ses;
 671         struct p9_fid *fid = NULL;
 672         struct p9_fid *dfid, *ofid;
 673         struct file *filp;
 674         struct p9_qid qid;
 675         struct inode *inode;
 676         struct posix_acl *pacl = NULL, *dacl = NULL;
 677
 678         v9ses = v9fs_inode2v9ses(dir);
 679         if (nd && nd->flags & LOOKUP_OPEN)
 680                 flags = nd->intent.open.flags - 1;
 681         else {
 682                 /*
 683                  * create call without LOOKUP_OPEN is due
 684                  * to mknod of regular files. So use mknod
 685                  * operation.
 686                  */
 687                 return v9fs_vfs_mknod_dotl(dir, dentry, omode, 0);
 688         }
 689
 690         name = (char *) dentry->d_name.name;
 691         P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_create_dotl: name:%s flags:0x%x "
 692                         "mode:0x%x\n", name, flags, omode);
 693
 694         dfid = v9fs_fid_lookup(dentry->d_parent);
 695         if (IS_ERR(dfid)) {
 696                 err = PTR_ERR(dfid);
 697                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
 698                 return err;
 699         }
 700
 701         /* clone a fid to use for creation */
 702         ofid = p9_client_walk(dfid, 0, NULL, 1);
 703         if (IS_ERR(ofid)) {
 704                 err = PTR_ERR(ofid);
 705                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
 706                 return err;
 707         }
 708
 709         gid = v9fs_get_fsgid_for_create(dir);
 710
 711         mode = omode;
 712         /* Update mode based on ACL value */
 713         err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
 714         if (err) {
 715                 P9_DPRINTK(P9_DEBUG_VFS,
 716                            "Failed to get acl values in creat %d\n", err);
 717                 goto error;
 718         }
 719         err = p9_client_create_dotl(ofid, name, flags, mode, gid, &qid);
 720         if (err < 0) {
 721                 P9_DPRINTK(P9_DEBUG_VFS,
 722                                 "p9_client_open_dotl failed in creat %d\n",
 723                                 err);
 724                 goto error;
 725         }
 726         /* instantiate inode and assign the unopened fid to the dentry */
 727         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE ||
 728             (nd && nd->flags & LOOKUP_OPEN)) {
 729                 fid = p9_client_walk(dfid, 1, &name, 1);
 730                 if (IS_ERR(fid)) {
 731                         err = PTR_ERR(fid);
 732                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
 733                                 err);
 734                         fid = NULL;
 735                         goto error;
 736                 }
 737
 738                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
 739                 if (IS_ERR(inode)) {
 740                         err = PTR_ERR(inode);
 741                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
 742                                 err);
 743                         goto error;
 744                 }
 745                 dentry->d_op = &v9fs_cached_dentry_operations;
 746                 d_instantiate(dentry, inode);
 747                 err = v9fs_fid_add(dentry, fid);
 748                 if (err < 0)
 749                         goto error;
 750                 /* The fid would get clunked via a dput */
 751                 fid = NULL;
 752         } else {
 753                 /*
 754                  * Not in cached mode. No need to populate
 755                  * inode with stat. We need to get an inode
 756                  * so that we can set the acl with dentry
 757                  */
 758                 inode = v9fs_get_inode(dir->i_sb, mode);
 759                 if (IS_ERR(inode)) {
 760                         err = PTR_ERR(inode);
 761                         goto error;
 762                 }
 763                 dentry->d_op = &v9fs_dentry_operations;
 764                 d_instantiate(dentry, inode);
 765         }
 766         /* Now set the ACL based on the default value */
 767         v9fs_set_create_acl(dentry, dacl, pacl);
 768
 769         /* if we are opening a file, assign the open fid to the file */
 770         if (nd && nd->flags & LOOKUP_OPEN) {
 771                 filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
 772                 if (IS_ERR(filp)) {
 773                         p9_client_clunk(ofid);
 774                         return PTR_ERR(filp);
 775                 }
 776                 filp->private_data = ofid;
 777         } else
 778                 p9_client_clunk(ofid);
 779
 780         return 0;
 781
 782 error:
 783         if (ofid)
 784                 p9_client_clunk(ofid);
 785         if (fid)
 786                 p9_client_clunk(fid);
 787         return err;
 788 }
 789
 790 /**
 791  * v9fs_vfs_create - VFS hook to create files
 792  * @dir: directory inode that is being created
 793  * @dentry:  dentry that is being deleted
 794  * @mode: create permissions
 795  * @nd: path information
 796  *
 797  */
 798
 799 static int
 800 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
 801                 struct nameidata *nd)
 802 {
 803         int err;
 804         u32 perm;
 805         int flags;
 806         struct v9fs_session_info *v9ses;
 807         struct p9_fid *fid;
 808         struct file *filp;
 809
 810         err = 0;
 811         fid = NULL;
 812         v9ses = v9fs_inode2v9ses(dir);
 813         perm = unixmode2p9mode(v9ses, mode);
 814         if (nd && nd->flags & LOOKUP_OPEN)
 815                 flags = nd->intent.open.flags - 1;
 816         else
 817                 flags = O_RDWR;
 818
 819         fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
 820                                 v9fs_uflags2omode(flags,
 821                                                 v9fs_proto_dotu(v9ses)));
 822         if (IS_ERR(fid)) {
 823                 err = PTR_ERR(fid);
 824                 fid = NULL;
 825                 goto error;
 826         }
 827
 828         /* if we are opening a file, assign the open fid to the file */
 829         if (nd && nd->flags & LOOKUP_OPEN) {
 830                 filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
 831                 if (IS_ERR(filp)) {
 832                         err = PTR_ERR(filp);
 833                         goto error;
 834                 }
 835
 836                 filp->private_data = fid;
 837         } else
 838                 p9_client_clunk(fid);
 839
 840         return 0;
 841
 842 error:
 843         if (fid)
 844                 p9_client_clunk(fid);
 845
 846         return err;
 847 }
 848
 849 /**
 850  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
 851  * @dir:  inode that is being unlinked
 852  * @dentry: dentry that is being unlinked
 853  * @mode: mode for new directory
 854  *
 855  */
 856
 857 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 858 {
 859         int err;
 860         u32 perm;
 861         struct v9fs_session_info *v9ses;
 862         struct p9_fid *fid;
 863
 864         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
 865         err = 0;
 866         v9ses = v9fs_inode2v9ses(dir);
 867         perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
 868         fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
 869         if (IS_ERR(fid)) {
 870                 err = PTR_ERR(fid);
 871                 fid = NULL;
 872         }
 873
 874         if (fid)
 875                 p9_client_clunk(fid);
 876
 877         return err;
 878 }
 879
 880
 881 /**
 882  * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory
 883  * @dir:  inode that is being unlinked
 884  * @dentry: dentry that is being unlinked
 885  * @mode: mode for new directory
 886  *
 887  */
 888
 889 static int v9fs_vfs_mkdir_dotl(struct inode *dir,
 890                                struct dentry *dentry, int omode)
 891 {
 892         int err;
 893         struct v9fs_session_info *v9ses;
 894         struct p9_fid *fid = NULL, *dfid = NULL;
 895         gid_t gid;
 896         char *name;
 897         mode_t mode;
 898         struct inode *inode;
 899         struct p9_qid qid;
 900         struct dentry *dir_dentry;
 901         struct posix_acl *dacl = NULL, *pacl = NULL;
 902
 903         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
 904         err = 0;
 905         v9ses = v9fs_inode2v9ses(dir);
 906
 907         omode |= S_IFDIR;
 908         if (dir->i_mode & S_ISGID)
 909                 omode |= S_ISGID;
 910
 911         dir_dentry = v9fs_dentry_from_dir_inode(dir);
 912         dfid = v9fs_fid_lookup(dir_dentry);
 913         if (IS_ERR(dfid)) {
 914                 err = PTR_ERR(dfid);
 915                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
 916                 dfid = NULL;
 917                 goto error;
 918         }
 919
 920         gid = v9fs_get_fsgid_for_create(dir);
 921         mode = omode;
 922         /* Update mode based on ACL value */
 923         err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
 924         if (err) {
 925                 P9_DPRINTK(P9_DEBUG_VFS,
 926                            "Failed to get acl values in mkdir %d\n", err);
 927                 goto error;
 928         }
 929         name = (char *) dentry->d_name.name;
 930         err = p9_client_mkdir_dotl(dfid, name, mode, gid, &qid);
 931         if (err < 0)
 932                 goto error;
 933
 934         /* instantiate inode and assign the unopened fid to the dentry */
 935         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
 936                 fid = p9_client_walk(dfid, 1, &name, 1);
 937                 if (IS_ERR(fid)) {
 938                         err = PTR_ERR(fid);
 939                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
 940                                 err);
 941                         fid = NULL;
 942                         goto error;
 943                 }
 944
 945                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
 946                 if (IS_ERR(inode)) {
 947                         err = PTR_ERR(inode);
 948                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
 949                                 err);
 950                         goto error;
 951                 }
 952                 dentry->d_op = &v9fs_cached_dentry_operations;
 953                 d_instantiate(dentry, inode);
 954                 err = v9fs_fid_add(dentry, fid);
 955                 if (err < 0)
 956                         goto error;
 957                 fid = NULL;
 958         } else {
 959                 /*
 960                  * Not in cached mode. No need to populate
 961                  * inode with stat. We need to get an inode
 962                  * so that we can set the acl with dentry
 963                  */
 964                 inode = v9fs_get_inode(dir->i_sb, mode);
 965                 if (IS_ERR(inode)) {
 966                         err = PTR_ERR(inode);
 967                         goto error;
 968                 }
 969                 dentry->d_op = &v9fs_dentry_operations;
 970                 d_instantiate(dentry, inode);
 971         }
 972         /* Now set the ACL based on the default value */
 973         v9fs_set_create_acl(dentry, dacl, pacl);
 974
 975 error:
 976         if (fid)
 977                 p9_client_clunk(fid);
 978         return err;
 979 }
 980
 981 /**
 982  * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
 983  * @dir:  inode that is being walked from
 984  * @dentry: dentry that is being walked to?
 985  * @nameidata: path data
 986  *
 987  */
 988
 989 static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 990                                       struct nameidata *nameidata)
 991 {
 992         struct super_block *sb;
 993         struct v9fs_session_info *v9ses;
 994         struct p9_fid *dfid, *fid;
 995         struct inode *inode;
 996         char *name;
 997         int result = 0;
 998
 999         P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
1000                 dir, dentry->d_name.name, dentry, nameidata);
1001
1002         if (dentry->d_name.len > NAME_MAX)
1003                 return ERR_PTR(-ENAMETOOLONG);
1004
1005         sb = dir->i_sb;
1006         v9ses = v9fs_inode2v9ses(dir);
1007         /* We can walk d_parent because we hold the dir->i_mutex */
1008         dfid = v9fs_fid_lookup(dentry->d_parent);
1009         if (IS_ERR(dfid))
1010                 return ERR_CAST(dfid);
1011
1012         name = (char *) dentry->d_name.name;
1013         fid = p9_client_walk(dfid, 1, &name, 1);
1014         if (IS_ERR(fid)) {
1015                 result = PTR_ERR(fid);
1016                 if (result == -ENOENT) {
1017                         inode = NULL;
1018                         goto inst_out;
1019                 }
1020
1021                 return ERR_PTR(result);
1022         }
1023
1024         inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
1025         if (IS_ERR(inode)) {
1026                 result = PTR_ERR(inode);
1027                 inode = NULL;
1028                 goto error;
1029         }
1030
1031         result = v9fs_fid_add(dentry, fid);
1032         if (result < 0)
1033                 goto error_iput;
1034
1035 inst_out:
1036         if (v9ses->cache)
1037                 dentry->d_op = &v9fs_cached_dentry_operations;
1038         else
1039                 dentry->d_op = &v9fs_dentry_operations;
1040
1041         d_add(dentry, inode);
1042         return NULL;
1043
1044 error_iput:
1045         iput(inode);
1046 error:
1047         p9_client_clunk(fid);
1048
1049         return ERR_PTR(result);
1050 }
1051
1052 /**
1053  * v9fs_vfs_unlink - VFS unlink hook to delete an inode
1054  * @i:  inode that is being unlinked
1055  * @d: dentry that is being unlinked
1056  *
1057  */
1058
1059 static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
1060 {
1061         return v9fs_remove(i, d, 0);
1062 }
1063
1064 /**
1065  * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
1066  * @i:  inode that is being unlinked
1067  * @d: dentry that is being unlinked
1068  *
1069  */
1070
1071 static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
1072 {
1073         return v9fs_remove(i, d, 1);
1074 }
1075
1076 /**
1077  * v9fs_vfs_rename - VFS hook to rename an inode
1078  * @old_dir:  old dir inode
1079  * @old_dentry: old dentry
1080  * @new_dir: new dir inode
1081  * @new_dentry: new dentry
1082  *
1083  */
1084
1085 static int
1086 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1087                 struct inode *new_dir, struct dentry *new_dentry)
1088 {
1089         struct inode *old_inode;
1090         struct v9fs_session_info *v9ses;
1091         struct p9_fid *oldfid;
1092         struct p9_fid *olddirfid;
1093         struct p9_fid *newdirfid;
1094         struct p9_wstat wstat;
1095         int retval;
1096
1097         P9_DPRINTK(P9_DEBUG_VFS, "\n");
1098         retval = 0;
1099         old_inode = old_dentry->d_inode;
1100         v9ses = v9fs_inode2v9ses(old_inode);
1101         oldfid = v9fs_fid_lookup(old_dentry);
1102         if (IS_ERR(oldfid))
1103                 return PTR_ERR(oldfid);
1104
1105         olddirfid = v9fs_fid_clone(old_dentry->d_parent);
1106         if (IS_ERR(olddirfid)) {
1107                 retval = PTR_ERR(olddirfid);
1108                 goto done;
1109         }
1110
1111         newdirfid = v9fs_fid_clone(new_dentry->d_parent);
1112         if (IS_ERR(newdirfid)) {
1113                 retval = PTR_ERR(newdirfid);
1114                 goto clunk_olddir;
1115         }
1116
1117         down_write(&v9ses->rename_sem);
1118         if (v9fs_proto_dotl(v9ses)) {
1119                 retval = p9_client_rename(oldfid, newdirfid,
1120                                         (char *) new_dentry->d_name.name);
1121                 if (retval != -ENOSYS)
1122                         goto clunk_newdir;
1123         }
1124         if (old_dentry->d_parent != new_dentry->d_parent) {
1125                 /*
1126                  * 9P .u can only handle file rename in the same directory
1127                  */
1128
1129                 P9_DPRINTK(P9_DEBUG_ERROR,
1130                                 "old dir and new dir are different\n");
1131                 retval = -EXDEV;
1132                 goto clunk_newdir;
1133         }
1134         v9fs_blank_wstat(&wstat);
1135         wstat.muid = v9ses->uname;
1136         wstat.name = (char *) new_dentry->d_name.name;
1137         retval = p9_client_wstat(oldfid, &wstat);
1138
1139 clunk_newdir:
1140         if (!retval)
1141                 /* successful rename */
1142                 d_move(old_dentry, new_dentry);
1143         up_write(&v9ses->rename_sem);
1144         p9_client_clunk(newdirfid);
1145
1146 clunk_olddir:
1147         p9_client_clunk(olddirfid);
1148
1149 done:
1150         return retval;
1151 }
1152
1153 /**
1154  * v9fs_vfs_getattr - retrieve file metadata
1155  * @mnt: mount information
1156  * @dentry: file to get attributes on
1157  * @stat: metadata structure to populate
1158  *
1159  */
1160
1161 static int
1162 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1163                  struct kstat *stat)
1164 {
1165         int err;
1166         struct v9fs_session_info *v9ses;
1167         struct p9_fid *fid;
1168         struct p9_wstat *st;
1169
1170         P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1171         err = -EPERM;
1172         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1173         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
1174                 return simple_getattr(mnt, dentry, stat);
1175
1176         fid = v9fs_fid_lookup(dentry);
1177         if (IS_ERR(fid))
1178                 return PTR_ERR(fid);
1179
1180         st = p9_client_stat(fid);
1181         if (IS_ERR(st))
1182                 return PTR_ERR(st);
1183
1184         v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
1185                 generic_fillattr(dentry->d_inode, stat);
1186
1187         p9stat_free(st);
1188         kfree(st);
1189         return 0;
1190 }
1191
1192 static int
1193 v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
1194                  struct kstat *stat)
1195 {
1196         int err;
1197         struct v9fs_session_info *v9ses;
1198         struct p9_fid *fid;
1199         struct p9_stat_dotl *st;
1200
1201         P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1202         err = -EPERM;
1203         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1204         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
1205                 return simple_getattr(mnt, dentry, stat);
1206
1207         fid = v9fs_fid_lookup(dentry);
1208         if (IS_ERR(fid))
1209                 return PTR_ERR(fid);
1210
1211         /* Ask for all the fields in stat structure. Server will return
1212          * whatever it supports
1213          */
1214
1215         st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
1216         if (IS_ERR(st))
1217                 return PTR_ERR(st);
1218
1219         v9fs_stat2inode_dotl(st, dentry->d_inode);
1220         generic_fillattr(dentry->d_inode, stat);
1221         /* Change block size to what the server returned */
1222         stat->blksize = st->st_blksize;
1223
1224         kfree(st);
1225         return 0;
1226 }
1227
1228 /**
1229  * v9fs_vfs_setattr - set file metadata
1230  * @dentry: file whose metadata to set
1231  * @iattr: metadata assignment structure
1232  *
1233  */
1234
1235 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
1236 {
1237         int retval;
1238         struct v9fs_session_info *v9ses;
1239         struct p9_fid *fid;
1240         struct p9_wstat wstat;
1241
1242         P9_DPRINTK(P9_DEBUG_VFS, "\n");
1243         retval = -EPERM;
1244         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1245         fid = v9fs_fid_lookup(dentry);
1246         if(IS_ERR(fid))
1247                 return PTR_ERR(fid);
1248
1249         v9fs_blank_wstat(&wstat);
1250         if (iattr->ia_valid & ATTR_MODE)
1251                 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
1252
1253         if (iattr->ia_valid & ATTR_MTIME)
1254                 wstat.mtime = iattr->ia_mtime.tv_sec;
1255
1256         if (iattr->ia_valid & ATTR_ATIME)
1257                 wstat.atime = iattr->ia_atime.tv_sec;
1258
1259         if (iattr->ia_valid & ATTR_SIZE)
1260                 wstat.length = iattr->ia_size;
1261
1262         if (v9fs_proto_dotu(v9ses)) {
1263                 if (iattr->ia_valid & ATTR_UID)
1264                         wstat.n_uid = iattr->ia_uid;
1265
1266                 if (iattr->ia_valid & ATTR_GID)
1267                         wstat.n_gid = iattr->ia_gid;
1268         }
1269
1270         retval = p9_client_wstat(fid, &wstat);
1271         if (retval < 0)
1272                 return retval;
1273
1274         if ((iattr->ia_valid & ATTR_SIZE) &&
1275             iattr->ia_size != i_size_read(dentry->d_inode)) {
1276                 retval = vmtruncate(dentry->d_inode, iattr->ia_size);
1277                 if (retval)
1278                         return retval;
1279         }
1280
1281         setattr_copy(dentry->d_inode, iattr);
1282         mark_inode_dirty(dentry->d_inode);
1283         return 0;
1284 }
1285
1286 /**
1287  * v9fs_vfs_setattr_dotl - set file metadata
1288  * @dentry: file whose metadata to set
1289  * @iattr: metadata assignment structure
1290  *
1291  */
1292
1293 int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
1294 {
1295         int retval;
1296         struct v9fs_session_info *v9ses;
1297         struct p9_fid *fid;
1298         struct p9_iattr_dotl p9attr;
1299
1300         P9_DPRINTK(P9_DEBUG_VFS, "\n");
1301
1302         retval = inode_change_ok(dentry->d_inode, iattr);
1303         if (retval)
1304                 return retval;
1305
1306         p9attr.valid = iattr->ia_valid;
1307         p9attr.mode = iattr->ia_mode;
1308         p9attr.uid = iattr->ia_uid;
1309         p9attr.gid = iattr->ia_gid;
1310         p9attr.size = iattr->ia_size;
1311         p9attr.atime_sec = iattr->ia_atime.tv_sec;
1312         p9attr.atime_nsec = iattr->ia_atime.tv_nsec;
1313         p9attr.mtime_sec = iattr->ia_mtime.tv_sec;
1314         p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec;
1315
1316         retval = -EPERM;
1317         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1318         fid = v9fs_fid_lookup(dentry);
1319         if (IS_ERR(fid))
1320                 return PTR_ERR(fid);
1321
1322         retval = p9_client_setattr(fid, &p9attr);
1323         if (retval < 0)
1324                 return retval;
1325
1326         if ((iattr->ia_valid & ATTR_SIZE) &&
1327             iattr->ia_size != i_size_read(dentry->d_inode)) {
1328                 retval = vmtruncate(dentry->d_inode, iattr->ia_size);
1329                 if (retval)
1330                         return retval;
1331         }
1332
1333         setattr_copy(dentry->d_inode, iattr);
1334         mark_inode_dirty(dentry->d_inode);
1335         if (iattr->ia_valid & ATTR_MODE) {
1336                 /* We also want to update ACL when we update mode bits */
1337                 retval = v9fs_acl_chmod(dentry);
1338                 if (retval < 0)
1339                         return retval;
1340         }
1341         return 0;
1342 }
1343
1344 /**
1345  * v9fs_stat2inode - populate an inode structure with mistat info
1346  * @stat: Plan 9 metadata (mistat) structure
1347  * @inode: inode to populate
1348  * @sb: superblock of filesystem
1349  *
1350  */
1351
1352 void
1353 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
1354         struct super_block *sb)
1355 {
1356         char ext[32];
1357         char tag_name[14];
1358         unsigned int i_nlink;
1359         struct v9fs_session_info *v9ses = sb->s_fs_info;
1360
1361         inode->i_nlink = 1;
1362
1363         inode->i_atime.tv_sec = stat->atime;
1364         inode->i_mtime.tv_sec = stat->mtime;
1365         inode->i_ctime.tv_sec = stat->mtime;
1366
1367         inode->i_uid = v9ses->dfltuid;
1368         inode->i_gid = v9ses->dfltgid;
1369
1370         if (v9fs_proto_dotu(v9ses)) {
1371                 inode->i_uid = stat->n_uid;
1372                 inode->i_gid = stat->n_gid;
1373         }
1374         if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1375                 if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1376                         /*
1377                          * Hadlink support got added later to
1378                          * to the .u extension. So there can be
1379                          * server out there that doesn't support
1380                          * this even with .u extension. So check
1381                          * for non NULL stat->extension
1382                          */
1383                         strncpy(ext, stat->extension, sizeof(ext));
1384                         /* HARDLINKCOUNT %u */
1385                         sscanf(ext, "%13s %u", tag_name, &i_nlink);
1386                         if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
1387                                 inode->i_nlink = i_nlink;
1388                 }
1389         }
1390         inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
1391         if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
1392                 char type = 0;
1393                 int major = -1;
1394                 int minor = -1;
1395
1396                 strncpy(ext, stat->extension, sizeof(ext));
1397                 sscanf(ext, "%c %u %u", &type, &major, &minor);
1398                 switch (type) {
1399                 case 'c':
1400                         inode->i_mode &= ~S_IFBLK;
1401                         inode->i_mode |= S_IFCHR;
1402                         break;
1403                 case 'b':
1404                         break;
1405                 default:
1406                         P9_DPRINTK(P9_DEBUG_ERROR,
1407                                 "Unknown special type %c %s\n", type,
1408                                 stat->extension);
1409                 };
1410                 inode->i_rdev = MKDEV(major, minor);
1411                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1412         } else
1413                 inode->i_rdev = 0;
1414
1415         i_size_write(inode, stat->length);
1416
1417         /* not real number of blocks, but 512 byte ones ... */
1418         inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
1419 }
1420
1421 /**
1422  * v9fs_stat2inode_dotl - populate an inode structure with stat info
1423  * @stat: stat structure
1424  * @inode: inode to populate
1425  * @sb: superblock of filesystem
1426  *
1427  */
1428
1429 void
1430 v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
1431 {
1432
1433         if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
1434                 inode->i_atime.tv_sec = stat->st_atime_sec;
1435                 inode->i_atime.tv_nsec = stat->st_atime_nsec;
1436                 inode->i_mtime.tv_sec = stat->st_mtime_sec;
1437                 inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
1438                 inode->i_ctime.tv_sec = stat->st_ctime_sec;
1439                 inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
1440                 inode->i_uid = stat->st_uid;
1441                 inode->i_gid = stat->st_gid;
1442                 inode->i_nlink = stat->st_nlink;
1443                 inode->i_mode = stat->st_mode;
1444                 inode->i_rdev = new_decode_dev(stat->st_rdev);
1445
1446                 if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode)))
1447                         init_special_inode(inode, inode->i_mode, inode->i_rdev);
1448
1449                 i_size_write(inode, stat->st_size);
1450                 inode->i_blocks = stat->st_blocks;
1451         } else {
1452                 if (stat->st_result_mask & P9_STATS_ATIME) {
1453                         inode->i_atime.tv_sec = stat->st_atime_sec;
1454                         inode->i_atime.tv_nsec = stat->st_atime_nsec;
1455                 }
1456                 if (stat->st_result_mask & P9_STATS_MTIME) {
1457                         inode->i_mtime.tv_sec = stat->st_mtime_sec;
1458                         inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
1459                 }
1460                 if (stat->st_result_mask & P9_STATS_CTIME) {
1461                         inode->i_ctime.tv_sec = stat->st_ctime_sec;
1462                         inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
1463                 }
1464                 if (stat->st_result_mask & P9_STATS_UID)
1465                         inode->i_uid = stat->st_uid;
1466                 if (stat->st_result_mask & P9_STATS_GID)
1467                         inode->i_gid = stat->st_gid;
1468                 if (stat->st_result_mask & P9_STATS_NLINK)
1469                         inode->i_nlink = stat->st_nlink;
1470                 if (stat->st_result_mask & P9_STATS_MODE) {
1471                         inode->i_mode = stat->st_mode;
1472                         if ((S_ISBLK(inode->i_mode)) ||
1473                                                 (S_ISCHR(inode->i_mode)))
1474                                 init_special_inode(inode, inode->i_mode,
1475                                                                 inode->i_rdev);
1476                 }
1477                 if (stat->st_result_mask & P9_STATS_RDEV)
1478                         inode->i_rdev = new_decode_dev(stat->st_rdev);
1479                 if (stat->st_result_mask & P9_STATS_SIZE)
1480                         i_size_write(inode, stat->st_size);
1481                 if (stat->st_result_mask & P9_STATS_BLOCKS)
1482                         inode->i_blocks = stat->st_blocks;
1483         }
1484         if (stat->st_result_mask & P9_STATS_GEN)
1485                         inode->i_generation = stat->st_gen;
1486
1487         /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
1488          * because the inode structure does not have fields for them.
1489          */
1490 }
1491
1492 /**
1493  * v9fs_qid2ino - convert qid into inode number
1494  * @qid: qid to hash
1495  *
1496  * BUG: potential for inode number collisions?
1497  */
1498
1499 ino_t v9fs_qid2ino(struct p9_qid *qid)
1500 {
1501         u64 path = qid->path + 2;
1502         ino_t i = 0;
1503
1504         if (sizeof(ino_t) == sizeof(path))
1505                 memcpy(&i, &path, sizeof(ino_t));
1506         else
1507                 i = (ino_t) (path ^ (path >> 32));
1508
1509         return i;
1510 }
1511
1512 /**
1513  * v9fs_readlink - read a symlink's location (internal version)
1514  * @dentry: dentry for symlink
1515  * @buffer: buffer to load symlink location into
1516  * @buflen: length of buffer
1517  *
1518  */
1519
1520 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1521 {
1522         int retval;
1523
1524         struct v9fs_session_info *v9ses;
1525         struct p9_fid *fid;
1526         struct p9_wstat *st;
1527
1528         P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
1529         retval = -EPERM;
1530         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1531         fid = v9fs_fid_lookup(dentry);
1532         if (IS_ERR(fid))
1533                 return PTR_ERR(fid);
1534
1535         if (!v9fs_proto_dotu(v9ses))
1536                 return -EBADF;
1537
1538         st = p9_client_stat(fid);
1539         if (IS_ERR(st))
1540                 return PTR_ERR(st);
1541
1542         if (!(st->mode & P9_DMSYMLINK)) {
1543                 retval = -EINVAL;
1544                 goto done;
1545         }
1546
1547         /* copy extension buffer into buffer */
1548         strncpy(buffer, st->extension, buflen);
1549
1550         P9_DPRINTK(P9_DEBUG_VFS,
1551                 "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
1552
1553         retval = strnlen(buffer, buflen);
1554 done:
1555         p9stat_free(st);
1556         kfree(st);
1557         return retval;
1558 }
1559
1560 /**
1561  * v9fs_vfs_follow_link - follow a symlink path
1562  * @dentry: dentry for symlink
1563  * @nd: nameidata
1564  *
1565  */
1566
1567 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1568 {
1569         int len = 0;
1570         char *link = __getname();
1571
1572         P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
1573
1574         if (!link)
1575                 link = ERR_PTR(-ENOMEM);
1576         else {
1577                 len = v9fs_readlink(dentry, link, PATH_MAX);
1578
1579                 if (len < 0) {
1580                         __putname(link);
1581                         link = ERR_PTR(len);
1582                 } else
1583                         link[min(len, PATH_MAX-1)] = 0;
1584         }
1585         nd_set_link(nd, link);
1586
1587         return NULL;
1588 }
1589
1590 /**
1591  * v9fs_vfs_put_link - release a symlink path
1592  * @dentry: dentry for symlink
1593  * @nd: nameidata
1594  * @p: unused
1595  *
1596  */
1597
1598 static void
1599 v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1600 {
1601         char *s = nd_get_link(nd);
1602
1603         P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name,
1604                 IS_ERR(s) ? "<error>" : s);
1605         if (!IS_ERR(s))
1606                 __putname(s);
1607 }
1608
1609 /**
1610  * v9fs_vfs_mkspecial - create a special file
1611  * @dir: inode to create special file in
1612  * @dentry: dentry to create
1613  * @mode: mode to create special file
1614  * @extension: 9p2000.u format extension string representing special file
1615  *
1616  */
1617
1618 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1619         int mode, const char *extension)
1620 {
1621         u32 perm;
1622         struct v9fs_session_info *v9ses;
1623         struct p9_fid *fid;
1624
1625         v9ses = v9fs_inode2v9ses(dir);
1626         if (!v9fs_proto_dotu(v9ses)) {
1627                 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
1628                 return -EPERM;
1629         }
1630
1631         perm = unixmode2p9mode(v9ses, mode);
1632         fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1633                                                                 P9_OREAD);
1634         if (IS_ERR(fid))
1635                 return PTR_ERR(fid);
1636
1637         p9_client_clunk(fid);
1638         return 0;
1639 }
1640
1641 /**
1642  * v9fs_vfs_symlink_dotl - helper function to create symlinks
1643  * @dir: directory inode containing symlink
1644  * @dentry: dentry for symlink
1645  * @symname: symlink data
1646  *
1647  * See Also: 9P2000.L RFC for more information
1648  *
1649  */
1650
1651 static int
1652 v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
1653                 const char *symname)
1654 {
1655         struct v9fs_session_info *v9ses;
1656         struct p9_fid *dfid;
1657         struct p9_fid *fid = NULL;
1658         struct inode *inode;
1659         struct p9_qid qid;
1660         char *name;
1661         int err;
1662         gid_t gid;
1663
1664         name = (char *) dentry->d_name.name;
1665         P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_symlink_dotl : %lu,%s,%s\n",
1666                         dir->i_ino, name, symname);
1667         v9ses = v9fs_inode2v9ses(dir);
1668
1669         dfid = v9fs_fid_lookup(dentry->d_parent);
1670         if (IS_ERR(dfid)) {
1671                 err = PTR_ERR(dfid);
1672                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
1673                 return err;
1674         }
1675
1676         gid = v9fs_get_fsgid_for_create(dir);
1677
1678         /* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */
1679         err = p9_client_symlink(dfid, name, (char *)symname, gid, &qid);
1680
1681         if (err < 0) {
1682                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_symlink failed %d\n", err);
1683                 goto error;
1684         }
1685
1686         if (v9ses->cache) {
1687                 /* Now walk from the parent so we can get an unopened fid. */
1688                 fid = p9_client_walk(dfid, 1, &name, 1);
1689                 if (IS_ERR(fid)) {
1690                         err = PTR_ERR(fid);
1691                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
1692                                         err);
1693                         fid = NULL;
1694                         goto error;
1695                 }
1696
1697                 /* instantiate inode and assign the unopened fid to dentry */
1698                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
1699                 if (IS_ERR(inode)) {
1700                         err = PTR_ERR(inode);
1701                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
1702                                         err);
1703                         goto error;
1704                 }
1705                 dentry->d_op = &v9fs_cached_dentry_operations;
1706                 d_instantiate(dentry, inode);
1707                 err = v9fs_fid_add(dentry, fid);
1708                 if (err < 0)
1709                         goto error;
1710                 fid = NULL;
1711         } else {
1712                 /* Not in cached mode. No need to populate inode with stat */
1713                 inode = v9fs_get_inode(dir->i_sb, S_IFLNK);
1714                 if (IS_ERR(inode)) {
1715                         err = PTR_ERR(inode);
1716                         goto error;
1717                 }
1718                 dentry->d_op = &v9fs_dentry_operations;
1719                 d_instantiate(dentry, inode);
1720         }
1721
1722 error:
1723         if (fid)
1724                 p9_client_clunk(fid);
1725
1726         return err;
1727 }
1728
1729 /**
1730  * v9fs_vfs_symlink - helper function to create symlinks
1731  * @dir: directory inode containing symlink
1732  * @dentry: dentry for symlink
1733  * @symname: symlink data
1734  *
1735  * See Also: 9P2000.u RFC for more information
1736  *
1737  */
1738
1739 static int
1740 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1741 {
1742         P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
1743                                         dentry->d_name.name, symname);
1744
1745         return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1746 }
1747
1748 /**
1749  * v9fs_vfs_link - create a hardlink
1750  * @old_dentry: dentry for file to link to
1751  * @dir: inode destination for new link
1752  * @dentry: dentry for link
1753  *
1754  */
1755
1756 static int
1757 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1758               struct dentry *dentry)
1759 {
1760         int retval;
1761         struct p9_fid *oldfid;
1762         char *name;
1763
1764         P9_DPRINTK(P9_DEBUG_VFS,
1765                 " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
1766                 old_dentry->d_name.name);
1767
1768         oldfid = v9fs_fid_clone(old_dentry);
1769         if (IS_ERR(oldfid))
1770                 return PTR_ERR(oldfid);
1771
1772         name = __getname();
1773         if (unlikely(!name)) {
1774                 retval = -ENOMEM;
1775                 goto clunk_fid;
1776         }
1777
1778         sprintf(name, "%d\n", oldfid->fid);
1779         retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1780         __putname(name);
1781
1782 clunk_fid:
1783         p9_client_clunk(oldfid);
1784         return retval;
1785 }
1786
1787 /**
1788  * v9fs_vfs_link_dotl - create a hardlink for dotl
1789  * @old_dentry: dentry for file to link to
1790  * @dir: inode destination for new link
1791  * @dentry: dentry for link
1792  *
1793  */
1794
1795 static int
1796 v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
1797                 struct dentry *dentry)
1798 {
1799         int err;
1800         struct p9_fid *dfid, *oldfid;
1801         char *name;
1802         struct v9fs_session_info *v9ses;
1803         struct dentry *dir_dentry;
1804
1805         P9_DPRINTK(P9_DEBUG_VFS, "dir ino: %lu, old_name: %s, new_name: %s\n",
1806                         dir->i_ino, old_dentry->d_name.name,
1807                         dentry->d_name.name);
1808
1809         v9ses = v9fs_inode2v9ses(dir);
1810         dir_dentry = v9fs_dentry_from_dir_inode(dir);
1811         dfid = v9fs_fid_lookup(dir_dentry);
1812         if (IS_ERR(dfid))
1813                 return PTR_ERR(dfid);
1814
1815         oldfid = v9fs_fid_lookup(old_dentry);
1816         if (IS_ERR(oldfid))
1817                 return PTR_ERR(oldfid);
1818
1819         name = (char *) dentry->d_name.name;
1820
1821         err = p9_client_link(dfid, oldfid, (char *)dentry->d_name.name);
1822
1823         if (err < 0) {
1824                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_link failed %d\n", err);
1825                 return err;
1826         }
1827
1828         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1829                 /* Get the latest stat info from server. */
1830                 struct p9_fid *fid;
1831                 struct p9_stat_dotl *st;
1832
1833                 fid = v9fs_fid_lookup(old_dentry);
1834                 if (IS_ERR(fid))
1835                         return PTR_ERR(fid);
1836
1837                 st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
1838                 if (IS_ERR(st))
1839                         return PTR_ERR(st);
1840
1841                 v9fs_stat2inode_dotl(st, old_dentry->d_inode);
1842
1843                 kfree(st);
1844         } else {
1845                 /* Caching disabled. No need to get upto date stat info.
1846                  * This dentry will be released immediately. So, just hold the
1847                  * inode
1848                  */
1849                 ihold(old_dentry->d_inode);
1850         }
1851
1852         dentry->d_op = old_dentry->d_op;
1853         d_instantiate(dentry, old_dentry->d_inode);
1854
1855         return err;
1856 }
1857
1858 /**
1859  * v9fs_vfs_mknod - create a special file
1860  * @dir: inode destination for new link
1861  * @dentry: dentry for file
1862  * @mode: mode for creation
1863  * @rdev: device associated with special file
1864  *
1865  */
1866
1867 static int
1868 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1869 {
1870         int retval;
1871         char *name;
1872
1873         P9_DPRINTK(P9_DEBUG_VFS,
1874                 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1875                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1876
1877         if (!new_valid_dev(rdev))
1878                 return -EINVAL;
1879
1880         name = __getname();
1881         if (!name)
1882                 return -ENOMEM;
1883         /* build extension */
1884         if (S_ISBLK(mode))
1885                 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1886         else if (S_ISCHR(mode))
1887                 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1888         else if (S_ISFIFO(mode))
1889                 *name = 0;
1890         else if (S_ISSOCK(mode))
1891                 *name = 0;
1892         else {
1893                 __putname(name);
1894                 return -EINVAL;
1895         }
1896
1897         retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1898         __putname(name);
1899
1900         return retval;
1901 }
1902
1903 /**
1904  * v9fs_vfs_mknod_dotl - create a special file
1905  * @dir: inode destination for new link
1906  * @dentry: dentry for file
1907  * @mode: mode for creation
1908  * @rdev: device associated with special file
1909  *
1910  */
1911 static int
1912 v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
1913                 dev_t rdev)
1914 {
1915         int err;
1916         char *name;
1917         mode_t mode;
1918         struct v9fs_session_info *v9ses;
1919         struct p9_fid *fid = NULL, *dfid = NULL;
1920         struct inode *inode;
1921         gid_t gid;
1922         struct p9_qid qid;
1923         struct dentry *dir_dentry;
1924         struct posix_acl *dacl = NULL, *pacl = NULL;
1925
1926         P9_DPRINTK(P9_DEBUG_VFS,
1927                 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1928                 dentry->d_name.name, omode, MAJOR(rdev), MINOR(rdev));
1929
1930         if (!new_valid_dev(rdev))
1931                 return -EINVAL;
1932
1933         v9ses = v9fs_inode2v9ses(dir);
1934         dir_dentry = v9fs_dentry_from_dir_inode(dir);
1935         dfid = v9fs_fid_lookup(dir_dentry);
1936         if (IS_ERR(dfid)) {
1937                 err = PTR_ERR(dfid);
1938                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
1939                 dfid = NULL;
1940                 goto error;
1941         }
1942
1943         gid = v9fs_get_fsgid_for_create(dir);
1944         mode = omode;
1945         /* Update mode based on ACL value */
1946         err = v9fs_acl_mode(dir, &mode, &dacl, &pacl);
1947         if (err) {
1948                 P9_DPRINTK(P9_DEBUG_VFS,
1949                            "Failed to get acl values in mknod %d\n", err);
1950                 goto error;
1951         }
1952         name = (char *) dentry->d_name.name;
1953
1954         err = p9_client_mknod_dotl(dfid, name, mode, rdev, gid, &qid);
1955         if (err < 0)
1956                 goto error;
1957
1958         /* instantiate inode and assign the unopened fid to the dentry */
1959         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1960                 fid = p9_client_walk(dfid, 1, &name, 1);
1961                 if (IS_ERR(fid)) {
1962                         err = PTR_ERR(fid);
1963                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
1964                                 err);
1965                         fid = NULL;
1966                         goto error;
1967                 }
1968
1969                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
1970                 if (IS_ERR(inode)) {
1971                         err = PTR_ERR(inode);
1972                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
1973                                 err);
1974                         goto error;
1975                 }
1976                 dentry->d_op = &v9fs_cached_dentry_operations;
1977                 d_instantiate(dentry, inode);
1978                 err = v9fs_fid_add(dentry, fid);
1979                 if (err < 0)
1980                         goto error;
1981                 fid = NULL;
1982         } else {
1983                 /*
1984                  * Not in cached mode. No need to populate inode with stat.
1985                  * socket syscall returns a fd, so we need instantiate
1986                  */
1987                 inode = v9fs_get_inode(dir->i_sb, mode);
1988                 if (IS_ERR(inode)) {
1989                         err = PTR_ERR(inode);
1990                         goto error;
1991                 }
1992                 dentry->d_op = &v9fs_dentry_operations;
1993                 d_instantiate(dentry, inode);
1994         }
1995         /* Now set the ACL based on the default value */
1996         v9fs_set_create_acl(dentry, dacl, pacl);
1997 error:
1998         if (fid)
1999                 p9_client_clunk(fid);
2000         return err;
2001 }
2002
2003 static int
2004 v9fs_vfs_readlink_dotl(struct dentry *dentry, char *buffer, int buflen)
2005 {
2006         int retval;
2007         struct p9_fid *fid;
2008         char *target = NULL;
2009
2010         P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
2011         retval = -EPERM;
2012         fid = v9fs_fid_lookup(dentry);
2013         if (IS_ERR(fid))
2014                 return PTR_ERR(fid);
2015
2016         retval = p9_client_readlink(fid, &target);
2017         if (retval < 0)
2018                 return retval;
2019
2020         strncpy(buffer, target, buflen);
2021         P9_DPRINTK(P9_DEBUG_VFS, "%s -> %s\n", dentry->d_name.name, buffer);
2022
2023         retval = strnlen(buffer, buflen);
2024         return retval;
2025 }
2026
2027 /**
2028  * v9fs_vfs_follow_link_dotl - follow a symlink path
2029  * @dentry: dentry for symlink
2030  * @nd: nameidata
2031  *
2032  */
2033
2034 static void *
2035 v9fs_vfs_follow_link_dotl(struct dentry *dentry, struct nameidata *nd)
2036 {
2037         int len = 0;
2038         char *link = __getname();
2039
2040         P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
2041
2042         if (!link)
2043                 link = ERR_PTR(-ENOMEM);
2044         else {
2045                 len = v9fs_vfs_readlink_dotl(dentry, link, PATH_MAX);
2046                 if (len < 0) {
2047                         __putname(link);
2048                         link = ERR_PTR(len);
2049                 } else
2050                         link[min(len, PATH_MAX-1)] = 0;
2051         }
2052         nd_set_link(nd, link);
2053
2054         return NULL;
2055 }
2056
2057 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
2058         .create = v9fs_vfs_create,
2059         .lookup = v9fs_vfs_lookup,
2060         .symlink = v9fs_vfs_symlink,
2061         .link = v9fs_vfs_link,
2062         .unlink = v9fs_vfs_unlink,
2063         .mkdir = v9fs_vfs_mkdir,
2064         .rmdir = v9fs_vfs_rmdir,
2065         .mknod = v9fs_vfs_mknod,
2066         .rename = v9fs_vfs_rename,
2067         .getattr = v9fs_vfs_getattr,
2068         .setattr = v9fs_vfs_setattr,
2069 };
2070
2071 static const struct inode_operations v9fs_dir_inode_operations_dotl = {
2072         .create = v9fs_vfs_create_dotl,
2073         .lookup = v9fs_vfs_lookup,
2074         .link = v9fs_vfs_link_dotl,
2075         .symlink = v9fs_vfs_symlink_dotl,
2076         .unlink = v9fs_vfs_unlink,
2077         .mkdir = v9fs_vfs_mkdir_dotl,
2078         .rmdir = v9fs_vfs_rmdir,
2079         .mknod = v9fs_vfs_mknod_dotl,
2080         .rename = v9fs_vfs_rename,
2081         .getattr = v9fs_vfs_getattr_dotl,
2082         .setattr = v9fs_vfs_setattr_dotl,
2083         .setxattr = generic_setxattr,
2084         .getxattr = generic_getxattr,
2085         .removexattr = generic_removexattr,
2086         .listxattr = v9fs_listxattr,
2087         .check_acl = v9fs_check_acl,
2088 };
2089
2090 static const struct inode_operations v9fs_dir_inode_operations = {
2091         .create = v9fs_vfs_create,
2092         .lookup = v9fs_vfs_lookup,
2093         .unlink = v9fs_vfs_unlink,
2094         .mkdir = v9fs_vfs_mkdir,
2095         .rmdir = v9fs_vfs_rmdir,
2096         .mknod = v9fs_vfs_mknod,
2097         .rename = v9fs_vfs_rename,
2098         .getattr = v9fs_vfs_getattr,
2099         .setattr = v9fs_vfs_setattr,
2100 };
2101
2102 static const struct inode_operations v9fs_file_inode_operations = {
2103         .getattr = v9fs_vfs_getattr,
2104         .setattr = v9fs_vfs_setattr,
2105 };
2106
2107 static const struct inode_operations v9fs_file_inode_operations_dotl = {
2108         .getattr = v9fs_vfs_getattr_dotl,
2109         .setattr = v9fs_vfs_setattr_dotl,
2110         .setxattr = generic_setxattr,
2111         .getxattr = generic_getxattr,
2112         .removexattr = generic_removexattr,
2113         .listxattr = v9fs_listxattr,
2114         .check_acl = v9fs_check_acl,
2115 };
2116
2117 static const struct inode_operations v9fs_symlink_inode_operations = {
2118         .readlink = generic_readlink,
2119         .follow_link = v9fs_vfs_follow_link,
2120         .put_link = v9fs_vfs_put_link,
2121         .getattr = v9fs_vfs_getattr,
2122         .setattr = v9fs_vfs_setattr,
2123 };
2124
2125 static const struct inode_operations v9fs_symlink_inode_operations_dotl = {
2126         .readlink = v9fs_vfs_readlink_dotl,
2127         .follow_link = v9fs_vfs_follow_link_dotl,
2128         .put_link = v9fs_vfs_put_link,
2129         .getattr = v9fs_vfs_getattr_dotl,
2130         .setattr = v9fs_vfs_setattr_dotl,
2131         .setxattr = generic_setxattr,
2132         .getxattr = generic_getxattr,
2133         .removexattr = generic_removexattr,
2134         .listxattr = v9fs_listxattr,
2135 };