SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/afs/dir.c

   1 /* dir.c: AFS filesystem directory handling
   2  *
   3  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/fs.h>
  17 #include <linux/pagemap.h>
  18 #include <linux/ctype.h>
  19 #include <linux/sched.h>
  20 #include "internal.h"
  21
  22 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
  23                                  struct nameidata *nd);
  24 static int afs_dir_open(struct inode *inode, struct file *file);
  25 static int afs_readdir(struct file *file, void *dirent, filldir_t filldir);
  26 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
  27 static int afs_d_delete(struct dentry *dentry);
  28 static void afs_d_release(struct dentry *dentry);
  29 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
  30                                   loff_t fpos, u64 ino, unsigned dtype);
  31 static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
  32                       struct nameidata *nd);
  33 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
  34 static int afs_rmdir(struct inode *dir, struct dentry *dentry);
  35 static int afs_unlink(struct inode *dir, struct dentry *dentry);
  36 static int afs_link(struct dentry *from, struct inode *dir,
  37                     struct dentry *dentry);
  38 static int afs_symlink(struct inode *dir, struct dentry *dentry,
  39                        const char *content);
  40 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
  41                       struct inode *new_dir, struct dentry *new_dentry);
  42
  43 const struct file_operations afs_dir_file_operations = {
  44         .open           = afs_dir_open,
  45         .release        = afs_release,
  46         .readdir        = afs_readdir,
  47 };
  48
  49 const struct inode_operations afs_dir_inode_operations = {
  50         .create         = afs_create,
  51         .lookup         = afs_lookup,
  52         .link           = afs_link,
  53         .unlink         = afs_unlink,
  54         .symlink        = afs_symlink,
  55         .mkdir          = afs_mkdir,
  56         .rmdir          = afs_rmdir,
  57         .rename         = afs_rename,
  58         .permission     = afs_permission,
  59         .getattr        = afs_getattr,
  60         .setattr        = afs_setattr,
  61 };
  62
  63 static struct dentry_operations afs_fs_dentry_operations = {
  64         .d_revalidate   = afs_d_revalidate,
  65         .d_delete       = afs_d_delete,
  66         .d_release      = afs_d_release,
  67 };
  68
  69 #define AFS_DIR_HASHTBL_SIZE    128
  70 #define AFS_DIR_DIRENT_SIZE     32
  71 #define AFS_DIRENT_PER_BLOCK    64
  72
  73 union afs_dirent {
  74         struct {
  75                 uint8_t         valid;
  76                 uint8_t         unused[1];
  77                 __be16          hash_next;
  78                 __be32          vnode;
  79                 __be32          unique;
  80                 uint8_t         name[16];
  81                 uint8_t         overflow[4];    /* if any char of the name (inc
  82                                                  * NUL) reaches here, consume
  83                                                  * the next dirent too */
  84         } u;
  85         uint8_t extended_name[32];
  86 };
  87
  88 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */
  89 struct afs_dir_pagehdr {
  90         __be16          npages;
  91         __be16          magic;
  92 #define AFS_DIR_MAGIC htons(1234)
  93         uint8_t         nentries;
  94         uint8_t         bitmap[8];
  95         uint8_t         pad[19];
  96 };
  97
  98 /* directory block layout */
  99 union afs_dir_block {
 100
 101         struct afs_dir_pagehdr pagehdr;
 102
 103         struct {
 104                 struct afs_dir_pagehdr  pagehdr;
 105                 uint8_t                 alloc_ctrs[128];
 106                 /* dir hash table */
 107                 uint16_t                hashtable[AFS_DIR_HASHTBL_SIZE];
 108         } hdr;
 109
 110         union afs_dirent dirents[AFS_DIRENT_PER_BLOCK];
 111 };
 112
 113 /* layout on a linux VM page */
 114 struct afs_dir_page {
 115         union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];
 116 };
 117
 118 struct afs_lookup_cookie {
 119         struct afs_fid  fid;
 120         const char      *name;
 121         size_t          nlen;
 122         int             found;
 123 };
 124
 125 /*
 126  * check that a directory page is valid
 127  */
 128 static inline void afs_dir_check_page(struct inode *dir, struct page *page)
 129 {
 130         struct afs_dir_page *dbuf;
 131         loff_t latter;
 132         int tmp, qty;
 133
 134 #if 0
 135         /* check the page count */
 136         qty = desc.size / sizeof(dbuf->blocks[0]);
 137         if (qty == 0)
 138                 goto error;
 139
 140         if (page->index == 0 && qty != ntohs(dbuf->blocks[0].pagehdr.npages)) {
 141                 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n",
 142                        __FUNCTION__, dir->i_ino, qty,
 143                        ntohs(dbuf->blocks[0].pagehdr.npages));
 144                 goto error;
 145         }
 146 #endif
 147
 148         /* determine how many magic numbers there should be in this page */
 149         latter = dir->i_size - page_offset(page);
 150         if (latter >= PAGE_SIZE)
 151                 qty = PAGE_SIZE;
 152         else
 153                 qty = latter;
 154         qty /= sizeof(union afs_dir_block);
 155
 156         /* check them */
 157         dbuf = page_address(page);
 158         for (tmp = 0; tmp < qty; tmp++) {
 159                 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) {
 160                         printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
 161                                __FUNCTION__, dir->i_ino, tmp, qty,
 162                                ntohs(dbuf->blocks[tmp].pagehdr.magic));
 163                         goto error;
 164                 }
 165         }
 166
 167         SetPageChecked(page);
 168         return;
 169
 170 error:
 171         SetPageChecked(page);
 172         SetPageError(page);
 173 }
 174
 175 /*
 176  * discard a page cached in the pagecache
 177  */
 178 static inline void afs_dir_put_page(struct page *page)
 179 {
 180         kunmap(page);
 181         page_cache_release(page);
 182 }
 183
 184 /*
 185  * get a page into the pagecache
 186  */
 187 static struct page *afs_dir_get_page(struct inode *dir, unsigned long index,
 188                                      struct key *key)
 189 {
 190         struct page *page;
 191         struct file file = {
 192                 .private_data = key,
 193         };
 194
 195         _enter("{%lu},%lu", dir->i_ino, index);
 196
 197         page = read_mapping_page(dir->i_mapping, index, &file);
 198         if (!IS_ERR(page)) {
 199                 kmap(page);
 200                 if (!PageChecked(page))
 201                         afs_dir_check_page(dir, page);
 202                 if (PageError(page))
 203                         goto fail;
 204         }
 205         return page;
 206
 207 fail:
 208         afs_dir_put_page(page);
 209         _leave(" = -EIO");
 210         return ERR_PTR(-EIO);
 211 }
 212
 213 /*
 214  * open an AFS directory file
 215  */
 216 static int afs_dir_open(struct inode *inode, struct file *file)
 217 {
 218         _enter("{%lu}", inode->i_ino);
 219
 220         BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
 221         BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
 222
 223         if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))
 224                 return -ENOENT;
 225
 226         return afs_open(inode, file);
 227 }
 228
 229 /*
 230  * deal with one block in an AFS directory
 231  */
 232 static int afs_dir_iterate_block(unsigned *fpos,
 233                                  union afs_dir_block *block,
 234                                  unsigned blkoff,
 235                                  void *cookie,
 236                                  filldir_t filldir)
 237 {
 238         union afs_dirent *dire;
 239         unsigned offset, next, curr;
 240         size_t nlen;
 241         int tmp, ret;
 242
 243         _enter("%u,%x,%p,,",*fpos,blkoff,block);
 244
 245         curr = (*fpos - blkoff) / sizeof(union afs_dirent);
 246
 247         /* walk through the block, an entry at a time */
 248         for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries;
 249              offset < AFS_DIRENT_PER_BLOCK;
 250              offset = next
 251              ) {
 252                 next = offset + 1;
 253
 254                 /* skip entries marked unused in the bitmap */
 255                 if (!(block->pagehdr.bitmap[offset / 8] &
 256                       (1 << (offset % 8)))) {
 257                         _debug("ENT[%Zu.%u]: unused",
 258                                blkoff / sizeof(union afs_dir_block), offset);
 259                         if (offset >= curr)
 260                                 *fpos = blkoff +
 261                                         next * sizeof(union afs_dirent);
 262                         continue;
 263                 }
 264
 265                 /* got a valid entry */
 266                 dire = &block->dirents[offset];
 267                 nlen = strnlen(dire->u.name,
 268                                sizeof(*block) -
 269                                offset * sizeof(union afs_dirent));
 270
 271                 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"",
 272                        blkoff / sizeof(union afs_dir_block), offset,
 273                        (offset < curr ? "skip" : "fill"),
 274                        nlen, dire->u.name);
 275
 276                 /* work out where the next possible entry is */
 277                 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) {
 278                         if (next >= AFS_DIRENT_PER_BLOCK) {
 279                                 _debug("ENT[%Zu.%u]:"
 280                                        " %u travelled beyond end dir block"
 281                                        " (len %u/%Zu)",
 282                                        blkoff / sizeof(union afs_dir_block),
 283                                        offset, next, tmp, nlen);
 284                                 return -EIO;
 285                         }
 286                         if (!(block->pagehdr.bitmap[next / 8] &
 287                               (1 << (next % 8)))) {
 288                                 _debug("ENT[%Zu.%u]:"
 289                                        " %u unmarked extension (len %u/%Zu)",
 290                                        blkoff / sizeof(union afs_dir_block),
 291                                        offset, next, tmp, nlen);
 292                                 return -EIO;
 293                         }
 294
 295                         _debug("ENT[%Zu.%u]: ext %u/%Zu",
 296                                blkoff / sizeof(union afs_dir_block),
 297                                next, tmp, nlen);
 298                         next++;
 299                 }
 300
 301                 /* skip if starts before the current position */
 302                 if (offset < curr)
 303                         continue;
 304
 305                 /* found the next entry */
 306                 ret = filldir(cookie,
 307                               dire->u.name,
 308                               nlen,
 309                               blkoff + offset * sizeof(union afs_dirent),
 310                               ntohl(dire->u.vnode),
 311                               filldir == afs_lookup_filldir ?
 312                               ntohl(dire->u.unique) : DT_UNKNOWN);
 313                 if (ret < 0) {
 314                         _leave(" = 0 [full]");
 315                         return 0;
 316                 }
 317
 318                 *fpos = blkoff + next * sizeof(union afs_dirent);
 319         }
 320
 321         _leave(" = 1 [more]");
 322         return 1;
 323 }
 324
 325 /*
 326  * iterate through the data blob that lists the contents of an AFS directory
 327  */
 328 static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie,
 329                            filldir_t filldir, struct key *key)
 330 {
 331         union afs_dir_block *dblock;
 332         struct afs_dir_page *dbuf;
 333         struct page *page;
 334         unsigned blkoff, limit;
 335         int ret;
 336
 337         _enter("{%lu},%u,,", dir->i_ino, *fpos);
 338
 339         if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {
 340                 _leave(" = -ESTALE");
 341                 return -ESTALE;
 342         }
 343
 344         /* round the file position up to the next entry boundary */
 345         *fpos += sizeof(union afs_dirent) - 1;
 346         *fpos &= ~(sizeof(union afs_dirent) - 1);
 347
 348         /* walk through the blocks in sequence */
 349         ret = 0;
 350         while (*fpos < dir->i_size) {
 351                 blkoff = *fpos & ~(sizeof(union afs_dir_block) - 1);
 352
 353                 /* fetch the appropriate page from the directory */
 354                 page = afs_dir_get_page(dir, blkoff / PAGE_SIZE, key);
 355                 if (IS_ERR(page)) {
 356                         ret = PTR_ERR(page);
 357                         break;
 358                 }
 359
 360                 limit = blkoff & ~(PAGE_SIZE - 1);
 361
 362                 dbuf = page_address(page);
 363
 364                 /* deal with the individual blocks stashed on this page */
 365                 do {
 366                         dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) /
 367                                                sizeof(union afs_dir_block)];
 368                         ret = afs_dir_iterate_block(fpos, dblock, blkoff,
 369                                                     cookie, filldir);
 370                         if (ret != 1) {
 371                                 afs_dir_put_page(page);
 372                                 goto out;
 373                         }
 374
 375                         blkoff += sizeof(union afs_dir_block);
 376
 377                 } while (*fpos < dir->i_size && blkoff < limit);
 378
 379                 afs_dir_put_page(page);
 380                 ret = 0;
 381         }
 382
 383 out:
 384         _leave(" = %d", ret);
 385         return ret;
 386 }
 387
 388 /*
 389  * read an AFS directory
 390  */
 391 static int afs_readdir(struct file *file, void *cookie, filldir_t filldir)
 392 {
 393         unsigned fpos;
 394         int ret;
 395
 396         _enter("{%Ld,{%lu}}",
 397                file->f_pos, file->f_path.dentry->d_inode->i_ino);
 398
 399         ASSERT(file->private_data != NULL);
 400
 401         fpos = file->f_pos;
 402         ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos,
 403                               cookie, filldir, file->private_data);
 404         file->f_pos = fpos;
 405
 406         _leave(" = %d", ret);
 407         return ret;
 408 }
 409
 410 /*
 411  * search the directory for a name
 412  * - if afs_dir_iterate_block() spots this function, it'll pass the FID
 413  *   uniquifier through dtype
 414  */
 415 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
 416                               loff_t fpos, u64 ino, unsigned dtype)
 417 {
 418         struct afs_lookup_cookie *cookie = _cookie;
 419
 420         _enter("{%s,%Zu},%s,%u,,%llu,%u",
 421                cookie->name, cookie->nlen, name, nlen,
 422                (unsigned long long) ino, dtype);
 423
 424         /* insanity checks first */
 425         BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
 426         BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
 427
 428         if (cookie->nlen != nlen || memcmp(cookie->name, name, nlen) != 0) {
 429                 _leave(" = 0 [no]");
 430                 return 0;
 431         }
 432
 433         cookie->fid.vnode = ino;
 434         cookie->fid.unique = dtype;
 435         cookie->found = 1;
 436
 437         _leave(" = -1 [found]");
 438         return -1;
 439 }
 440
 441 /*
 442  * do a lookup in a directory
 443  * - just returns the FID the dentry name maps to if found
 444  */
 445 static int afs_do_lookup(struct inode *dir, struct dentry *dentry,
 446                          struct afs_fid *fid, struct key *key)
 447 {
 448         struct afs_lookup_cookie cookie;
 449         struct afs_super_info *as;
 450         unsigned fpos;
 451         int ret;
 452
 453         _enter("{%lu},%p{%s},", dir->i_ino, dentry, dentry->d_name.name);
 454
 455         as = dir->i_sb->s_fs_info;
 456
 457         /* search the directory */
 458         cookie.name     = dentry->d_name.name;
 459         cookie.nlen     = dentry->d_name.len;
 460         cookie.fid.vid  = as->volume->vid;
 461         cookie.found    = 0;
 462
 463         fpos = 0;
 464         ret = afs_dir_iterate(dir, &fpos, &cookie, afs_lookup_filldir,
 465                               key);
 466         if (ret < 0) {
 467                 _leave(" = %d [iter]", ret);
 468                 return ret;
 469         }
 470
 471         ret = -ENOENT;
 472         if (!cookie.found) {
 473                 _leave(" = -ENOENT [not found]");
 474                 return -ENOENT;
 475         }
 476
 477         *fid = cookie.fid;
 478         _leave(" = 0 { vn=%u u=%u }", fid->vnode, fid->unique);
 479         return 0;
 480 }
 481
 482 /*
 483  * look up an entry in a directory
 484  */
 485 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
 486                                  struct nameidata *nd)
 487 {
 488         struct afs_vnode *vnode;
 489         struct afs_fid fid;
 490         struct inode *inode;
 491         struct key *key;
 492         int ret;
 493
 494         vnode = AFS_FS_I(dir);
 495
 496         _enter("{%x:%u},%p{%s},",
 497                vnode->fid.vid, vnode->fid.vnode, dentry, dentry->d_name.name);
 498
 499         ASSERTCMP(dentry->d_inode, ==, NULL);
 500
 501         if (dentry->d_name.len >= AFSNAMEMAX) {
 502                 _leave(" = -ENAMETOOLONG");
 503                 return ERR_PTR(-ENAMETOOLONG);
 504         }
 505
 506         if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
 507                 _leave(" = -ESTALE");
 508                 return ERR_PTR(-ESTALE);
 509         }
 510
 511         key = afs_request_key(vnode->volume->cell);
 512         if (IS_ERR(key)) {
 513                 _leave(" = %ld [key]", PTR_ERR(key));
 514                 return ERR_PTR(PTR_ERR(key));
 515         }
 516
 517         ret = afs_validate(vnode, key);
 518         if (ret < 0) {
 519                 key_put(key);
 520                 _leave(" = %d [val]", ret);
 521                 return ERR_PTR(ret);
 522         }
 523
 524         ret = afs_do_lookup(dir, dentry, &fid, key);
 525         if (ret < 0) {
 526                 key_put(key);
 527                 if (ret == -ENOENT) {
 528                         d_add(dentry, NULL);
 529                         _leave(" = NULL [negative]");
 530                         return NULL;
 531                 }
 532                 _leave(" = %d [do]", ret);
 533                 return ERR_PTR(ret);
 534         }
 535         dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version;
 536
 537         /* instantiate the dentry */
 538         inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL);
 539         key_put(key);
 540         if (IS_ERR(inode)) {
 541                 _leave(" = %ld", PTR_ERR(inode));
 542                 return ERR_PTR(PTR_ERR(inode));
 543         }
 544
 545         dentry->d_op = &afs_fs_dentry_operations;
 546
 547         d_add(dentry, inode);
 548         _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%lu }",
 549                fid.vnode,
 550                fid.unique,
 551                dentry->d_inode->i_ino,
 552                dentry->d_inode->i_version);
 553
 554         return NULL;
 555 }
 556
 557 /*
 558  * check that a dentry lookup hit has found a valid entry
 559  * - NOTE! the hit can be a negative hit too, so we can't assume we have an
 560  *   inode
 561  */
 562 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
 563 {
 564         struct afs_vnode *vnode, *dir;
 565         struct afs_fid fid;
 566         struct dentry *parent;
 567         struct key *key;
 568         void *dir_version;
 569         int ret;
 570
 571         vnode = AFS_FS_I(dentry->d_inode);
 572
 573         if (dentry->d_inode)
 574                 _enter("{v={%x:%u} n=%s fl=%lx},",
 575                        vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
 576                        vnode->flags);
 577         else
 578                 _enter("{neg n=%s}", dentry->d_name.name);
 579
 580         key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);
 581         if (IS_ERR(key))
 582                 key = NULL;
 583
 584         /* lock down the parent dentry so we can peer at it */
 585         parent = dget_parent(dentry);
 586         if (!parent->d_inode)
 587                 goto out_bad;
 588
 589         dir = AFS_FS_I(parent->d_inode);
 590
 591         /* validate the parent directory */
 592         if (test_bit(AFS_VNODE_MODIFIED, &dir->flags))
 593                 afs_validate(dir, key);
 594
 595         if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {
 596                 _debug("%s: parent dir deleted", dentry->d_name.name);
 597                 goto out_bad;
 598         }
 599
 600         dir_version = (void *) (unsigned long) dir->status.data_version;
 601         if (dentry->d_fsdata == dir_version)
 602                 goto out_valid; /* the dir contents are unchanged */
 603
 604         _debug("dir modified");
 605
 606         /* search the directory for this vnode */
 607         ret = afs_do_lookup(&dir->vfs_inode, dentry, &fid, key);
 608         switch (ret) {
 609         case 0:
 610                 /* the filename maps to something */
 611                 if (!dentry->d_inode)
 612                         goto out_bad;
 613                 if (is_bad_inode(dentry->d_inode)) {
 614                         printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n",
 615                                parent->d_name.name, dentry->d_name.name);
 616                         goto out_bad;
 617                 }
 618
 619                 /* if the vnode ID has changed, then the dirent points to a
 620                  * different file */
 621                 if (fid.vnode != vnode->fid.vnode) {
 622                         _debug("%s: dirent changed [%u != %u]",
 623                                dentry->d_name.name, fid.vnode,
 624                                vnode->fid.vnode);
 625                         goto not_found;
 626                 }
 627
 628                 /* if the vnode ID uniqifier has changed, then the file has
 629                  * been deleted and replaced, and the original vnode ID has
 630                  * been reused */
 631                 if (fid.unique != vnode->fid.unique) {
 632                         _debug("%s: file deleted (uq %u -> %u I:%lu)",
 633                                dentry->d_name.name, fid.unique,
 634                                vnode->fid.unique, dentry->d_inode->i_version);
 635                         spin_lock(&vnode->lock);
 636                         set_bit(AFS_VNODE_DELETED, &vnode->flags);
 637                         spin_unlock(&vnode->lock);
 638                         goto not_found;
 639                 }
 640                 goto out_valid;
 641
 642         case -ENOENT:
 643                 /* the filename is unknown */
 644                 _debug("%s: dirent not found", dentry->d_name.name);
 645                 if (dentry->d_inode)
 646                         goto not_found;
 647                 goto out_valid;
 648
 649         default:
 650                 _debug("failed to iterate dir %s: %d",
 651                        parent->d_name.name, ret);
 652                 goto out_bad;
 653         }
 654
 655 out_valid:
 656         dentry->d_fsdata = dir_version;
 657 out_skip:
 658         dput(parent);
 659         key_put(key);
 660         _leave(" = 1 [valid]");
 661         return 1;
 662
 663         /* the dirent, if it exists, now points to a different vnode */
 664 not_found:
 665         spin_lock(&dentry->d_lock);
 666         dentry->d_flags |= DCACHE_NFSFS_RENAMED;
 667         spin_unlock(&dentry->d_lock);
 668
 669 out_bad:
 670         if (dentry->d_inode) {
 671                 /* don't unhash if we have submounts */
 672                 if (have_submounts(dentry))
 673                         goto out_skip;
 674         }
 675
 676         _debug("dropping dentry %s/%s",
 677                parent->d_name.name, dentry->d_name.name);
 678         shrink_dcache_parent(dentry);
 679         d_drop(dentry);
 680         dput(parent);
 681         key_put(key);
 682
 683         _leave(" = 0 [bad]");
 684         return 0;
 685 }
 686
 687 /*
 688  * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
 689  * sleep)
 690  * - called from dput() when d_count is going to 0.
 691  * - return 1 to request dentry be unhashed, 0 otherwise
 692  */
 693 static int afs_d_delete(struct dentry *dentry)
 694 {
 695         _enter("%s", dentry->d_name.name);
 696
 697         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
 698                 goto zap;
 699
 700         if (dentry->d_inode &&
 701             test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dentry->d_inode)->flags))
 702                         goto zap;
 703
 704         _leave(" = 0 [keep]");
 705         return 0;
 706
 707 zap:
 708         _leave(" = 1 [zap]");
 709         return 1;
 710 }
 711
 712 /*
 713  * handle dentry release
 714  */
 715 static void afs_d_release(struct dentry *dentry)
 716 {
 717         _enter("%s", dentry->d_name.name);
 718 }
 719
 720 /*
 721  * create a directory on an AFS filesystem
 722  */
 723 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 724 {
 725         struct afs_file_status status;
 726         struct afs_callback cb;
 727         struct afs_server *server;
 728         struct afs_vnode *dvnode, *vnode;
 729         struct afs_fid fid;
 730         struct inode *inode;
 731         struct key *key;
 732         int ret;
 733
 734         dvnode = AFS_FS_I(dir);
 735
 736         _enter("{%x:%u},{%s},%o",
 737                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
 738
 739         ret = -ENAMETOOLONG;
 740         if (dentry->d_name.len >= AFSNAMEMAX)
 741                 goto error;
 742
 743         key = afs_request_key(dvnode->volume->cell);
 744         if (IS_ERR(key)) {
 745                 ret = PTR_ERR(key);
 746                 goto error;
 747         }
 748
 749         mode |= S_IFDIR;
 750         ret = afs_vnode_create(dvnode, key, dentry->d_name.name,
 751                                mode, &fid, &status, &cb, &server);
 752         if (ret < 0)
 753                 goto mkdir_error;
 754
 755         inode = afs_iget(dir->i_sb, key, &fid, &status, &cb);
 756         if (IS_ERR(inode)) {
 757                 /* ENOMEM at a really inconvenient time - just abandon the new
 758                  * directory on the server */
 759                 ret = PTR_ERR(inode);
 760                 goto iget_error;
 761         }
 762
 763         /* apply the status report we've got for the new vnode */
 764         vnode = AFS_FS_I(inode);
 765         spin_lock(&vnode->lock);
 766         vnode->update_cnt++;
 767         spin_unlock(&vnode->lock);
 768         afs_vnode_finalise_status_update(vnode, server);
 769         afs_put_server(server);
 770
 771         d_instantiate(dentry, inode);
 772         if (d_unhashed(dentry)) {
 773                 _debug("not hashed");
 774                 d_rehash(dentry);
 775         }
 776         key_put(key);
 777         _leave(" = 0");
 778         return 0;
 779
 780 iget_error:
 781         afs_put_server(server);
 782 mkdir_error:
 783         key_put(key);
 784 error:
 785         d_drop(dentry);
 786         _leave(" = %d", ret);
 787         return ret;
 788 }
 789
 790 /*
 791  * remove a directory from an AFS filesystem
 792  */
 793 static int afs_rmdir(struct inode *dir, struct dentry *dentry)
 794 {
 795         struct afs_vnode *dvnode, *vnode;
 796         struct key *key;
 797         int ret;
 798
 799         dvnode = AFS_FS_I(dir);
 800
 801         _enter("{%x:%u},{%s}",
 802                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
 803
 804         ret = -ENAMETOOLONG;
 805         if (dentry->d_name.len >= AFSNAMEMAX)
 806                 goto error;
 807
 808         key = afs_request_key(dvnode->volume->cell);
 809         if (IS_ERR(key)) {
 810                 ret = PTR_ERR(key);
 811                 goto error;
 812         }
 813
 814         ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, true);
 815         if (ret < 0)
 816                 goto rmdir_error;
 817
 818         if (dentry->d_inode) {
 819                 vnode = AFS_FS_I(dentry->d_inode);
 820                 clear_nlink(&vnode->vfs_inode);
 821                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
 822                 afs_discard_callback_on_delete(vnode);
 823         }
 824
 825         key_put(key);
 826         _leave(" = 0");
 827         return 0;
 828
 829 rmdir_error:
 830         key_put(key);
 831 error:
 832         _leave(" = %d", ret);
 833         return ret;
 834 }
 835
 836 /*
 837  * remove a file from an AFS filesystem
 838  */
 839 static int afs_unlink(struct inode *dir, struct dentry *dentry)
 840 {
 841         struct afs_vnode *dvnode, *vnode;
 842         struct key *key;
 843         int ret;
 844
 845         dvnode = AFS_FS_I(dir);
 846
 847         _enter("{%x:%u},{%s}",
 848                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
 849
 850         ret = -ENAMETOOLONG;
 851         if (dentry->d_name.len >= AFSNAMEMAX)
 852                 goto error;
 853
 854         key = afs_request_key(dvnode->volume->cell);
 855         if (IS_ERR(key)) {
 856                 ret = PTR_ERR(key);
 857                 goto error;
 858         }
 859
 860         if (dentry->d_inode) {
 861                 vnode = AFS_FS_I(dentry->d_inode);
 862
 863                 /* make sure we have a callback promise on the victim */
 864                 ret = afs_validate(vnode, key);
 865                 if (ret < 0)
 866                         goto error;
 867         }
 868
 869         ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, false);
 870         if (ret < 0)
 871                 goto remove_error;
 872
 873         if (dentry->d_inode) {
 874                 /* if the file wasn't deleted due to excess hard links, the
 875                  * fileserver will break the callback promise on the file - if
 876                  * it had one - before it returns to us, and if it was deleted,
 877                  * it won't
 878                  *
 879                  * however, if we didn't have a callback promise outstanding,
 880                  * or it was outstanding on a different server, then it won't
 881                  * break it either...
 882                  */
 883                 vnode = AFS_FS_I(dentry->d_inode);
 884                 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 885                         _debug("AFS_VNODE_DELETED");
 886                 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags))
 887                         _debug("AFS_VNODE_CB_BROKEN");
 888                 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
 889                 ret = afs_validate(vnode, key);
 890                 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, ret);
 891         }
 892
 893         key_put(key);
 894         _leave(" = 0");
 895         return 0;
 896
 897 remove_error:
 898         key_put(key);
 899 error:
 900         _leave(" = %d", ret);
 901         return ret;
 902 }
 903
 904 /*
 905  * create a regular file on an AFS filesystem
 906  */
 907 static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
 908                       struct nameidata *nd)
 909 {
 910         struct afs_file_status status;
 911         struct afs_callback cb;
 912         struct afs_server *server;
 913         struct afs_vnode *dvnode, *vnode;
 914         struct afs_fid fid;
 915         struct inode *inode;
 916         struct key *key;
 917         int ret;
 918
 919         dvnode = AFS_FS_I(dir);
 920
 921         _enter("{%x:%u},{%s},%o,",
 922                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
 923
 924         ret = -ENAMETOOLONG;
 925         if (dentry->d_name.len >= AFSNAMEMAX)
 926                 goto error;
 927
 928         key = afs_request_key(dvnode->volume->cell);
 929         if (IS_ERR(key)) {
 930                 ret = PTR_ERR(key);
 931                 goto error;
 932         }
 933
 934         mode |= S_IFREG;
 935         ret = afs_vnode_create(dvnode, key, dentry->d_name.name,
 936                                mode, &fid, &status, &cb, &server);
 937         if (ret < 0)
 938                 goto create_error;
 939
 940         inode = afs_iget(dir->i_sb, key, &fid, &status, &cb);
 941         if (IS_ERR(inode)) {
 942                 /* ENOMEM at a really inconvenient time - just abandon the new
 943                  * directory on the server */
 944                 ret = PTR_ERR(inode);
 945                 goto iget_error;
 946         }
 947
 948         /* apply the status report we've got for the new vnode */
 949         vnode = AFS_FS_I(inode);
 950         spin_lock(&vnode->lock);
 951         vnode->update_cnt++;
 952         spin_unlock(&vnode->lock);
 953         afs_vnode_finalise_status_update(vnode, server);
 954         afs_put_server(server);
 955
 956         d_instantiate(dentry, inode);
 957         if (d_unhashed(dentry)) {
 958                 _debug("not hashed");
 959                 d_rehash(dentry);
 960         }
 961         key_put(key);
 962         _leave(" = 0");
 963         return 0;
 964
 965 iget_error:
 966         afs_put_server(server);
 967 create_error:
 968         key_put(key);
 969 error:
 970         d_drop(dentry);
 971         _leave(" = %d", ret);
 972         return ret;
 973 }
 974
 975 /*
 976  * create a hard link between files in an AFS filesystem
 977  */
 978 static int afs_link(struct dentry *from, struct inode *dir,
 979                     struct dentry *dentry)
 980 {
 981         struct afs_vnode *dvnode, *vnode;
 982         struct key *key;
 983         int ret;
 984
 985         vnode = AFS_FS_I(from->d_inode);
 986         dvnode = AFS_FS_I(dir);
 987
 988         _enter("{%x:%u},{%x:%u},{%s}",
 989                vnode->fid.vid, vnode->fid.vnode,
 990                dvnode->fid.vid, dvnode->fid.vnode,
 991                dentry->d_name.name);
 992
 993         ret = -ENAMETOOLONG;
 994         if (dentry->d_name.len >= AFSNAMEMAX)
 995                 goto error;
 996
 997         key = afs_request_key(dvnode->volume->cell);
 998         if (IS_ERR(key)) {
 999                 ret = PTR_ERR(key);
1000                 goto error;
1001         }
1002
1003         ret = afs_vnode_link(dvnode, vnode, key, dentry->d_name.name);
1004         if (ret < 0)
1005                 goto link_error;
1006
1007         atomic_inc(&vnode->vfs_inode.i_count);
1008         d_instantiate(dentry, &vnode->vfs_inode);
1009         key_put(key);
1010         _leave(" = 0");
1011         return 0;
1012
1013 link_error:
1014         key_put(key);
1015 error:
1016         d_drop(dentry);
1017         _leave(" = %d", ret);
1018         return ret;
1019 }
1020
1021 /*
1022  * create a symlink in an AFS filesystem
1023  */
1024 static int afs_symlink(struct inode *dir, struct dentry *dentry,
1025                        const char *content)
1026 {
1027         struct afs_file_status status;
1028         struct afs_server *server;
1029         struct afs_vnode *dvnode, *vnode;
1030         struct afs_fid fid;
1031         struct inode *inode;
1032         struct key *key;
1033         int ret;
1034
1035         dvnode = AFS_FS_I(dir);
1036
1037         _enter("{%x:%u},{%s},%s",
1038                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name,
1039                content);
1040
1041         ret = -ENAMETOOLONG;
1042         if (dentry->d_name.len >= AFSNAMEMAX)
1043                 goto error;
1044
1045         ret = -EINVAL;
1046         if (strlen(content) >= AFSPATHMAX)
1047                 goto error;
1048
1049         key = afs_request_key(dvnode->volume->cell);
1050         if (IS_ERR(key)) {
1051                 ret = PTR_ERR(key);
1052                 goto error;
1053         }
1054
1055         ret = afs_vnode_symlink(dvnode, key, dentry->d_name.name, content,
1056                                 &fid, &status, &server);
1057         if (ret < 0)
1058                 goto create_error;
1059
1060         inode = afs_iget(dir->i_sb, key, &fid, &status, NULL);
1061         if (IS_ERR(inode)) {
1062                 /* ENOMEM at a really inconvenient time - just abandon the new
1063                  * directory on the server */
1064                 ret = PTR_ERR(inode);
1065                 goto iget_error;
1066         }
1067
1068         /* apply the status report we've got for the new vnode */
1069         vnode = AFS_FS_I(inode);
1070         spin_lock(&vnode->lock);
1071         vnode->update_cnt++;
1072         spin_unlock(&vnode->lock);
1073         afs_vnode_finalise_status_update(vnode, server);
1074         afs_put_server(server);
1075
1076         d_instantiate(dentry, inode);
1077         if (d_unhashed(dentry)) {
1078                 _debug("not hashed");
1079                 d_rehash(dentry);
1080         }
1081         key_put(key);
1082         _leave(" = 0");
1083         return 0;
1084
1085 iget_error:
1086         afs_put_server(server);
1087 create_error:
1088         key_put(key);
1089 error:
1090         d_drop(dentry);
1091         _leave(" = %d", ret);
1092         return ret;
1093 }
1094
1095 /*
1096  * rename a file in an AFS filesystem and/or move it between directories
1097  */
1098 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
1099                       struct inode *new_dir, struct dentry *new_dentry)
1100 {
1101         struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;
1102         struct key *key;
1103         int ret;
1104
1105         vnode = AFS_FS_I(old_dentry->d_inode);
1106         orig_dvnode = AFS_FS_I(old_dir);
1107         new_dvnode = AFS_FS_I(new_dir);
1108
1109         _enter("{%x:%u},{%x:%u},{%x:%u},{%s}",
1110                orig_dvnode->fid.vid, orig_dvnode->fid.vnode,
1111                vnode->fid.vid, vnode->fid.vnode,
1112                new_dvnode->fid.vid, new_dvnode->fid.vnode,
1113                new_dentry->d_name.name);
1114
1115         ret = -ENAMETOOLONG;
1116         if (new_dentry->d_name.len >= AFSNAMEMAX)
1117                 goto error;
1118
1119         key = afs_request_key(orig_dvnode->volume->cell);
1120         if (IS_ERR(key)) {
1121                 ret = PTR_ERR(key);
1122                 goto error;
1123         }
1124
1125         ret = afs_vnode_rename(orig_dvnode, new_dvnode, key,
1126                                old_dentry->d_name.name,
1127                                new_dentry->d_name.name);
1128         if (ret < 0)
1129                 goto rename_error;
1130         key_put(key);
1131         _leave(" = 0");
1132         return 0;
1133
1134 rename_error:
1135         key_put(key);
1136 error:
1137         d_drop(new_dentry);
1138         _leave(" = %d", ret);
1139         return ret;
1140 }