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 "internal.h"
  20
  21 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
  22                                  struct nameidata *nd);
  23 static int afs_dir_open(struct inode *inode, struct file *file);
  24 static int afs_readdir(struct file *file, void *dirent, filldir_t filldir);
  25 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
  26 static int afs_d_delete(struct dentry *dentry);
  27 static void afs_d_release(struct dentry *dentry);
  28 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
  29                                   loff_t fpos, u64 ino, unsigned dtype);
  30 static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
  31                       struct nameidata *nd);
  32 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
  33 static int afs_rmdir(struct inode *dir, struct dentry *dentry);
  34 static int afs_unlink(struct inode *dir, struct dentry *dentry);
  35 static int afs_link(struct dentry *from, struct inode *dir,
  36                     struct dentry *dentry);
  37 static int afs_symlink(struct inode *dir, struct dentry *dentry,
  38                        const char *content);
  39 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
  40                       struct inode *new_dir, struct dentry *new_dentry);
  41
  42 const struct file_operations afs_dir_file_operations = {
  43         .open           = afs_dir_open,
  44         .release        = afs_release,
  45         .readdir        = afs_readdir,
  46 };
  47
  48 const struct inode_operations afs_dir_inode_operations = {
  49         .create         = afs_create,
  50         .lookup         = afs_lookup,
  51         .link           = afs_link,
  52         .unlink         = afs_unlink,
  53         .symlink        = afs_symlink,
  54         .mkdir          = afs_mkdir,
  55         .rmdir          = afs_rmdir,
  56         .rename         = afs_rename,
  57         .permission     = afs_permission,
  58         .getattr        = afs_inode_getattr,
  59 };
  60
  61 static struct dentry_operations afs_fs_dentry_operations = {
  62         .d_revalidate   = afs_d_revalidate,
  63         .d_delete       = afs_d_delete,
  64         .d_release      = afs_d_release,
  65 };
  66
  67 #define AFS_DIR_HASHTBL_SIZE    128
  68 #define AFS_DIR_DIRENT_SIZE     32
  69 #define AFS_DIRENT_PER_BLOCK    64
  70
  71 union afs_dirent {
  72         struct {
  73                 uint8_t         valid;
  74                 uint8_t         unused[1];
  75                 __be16          hash_next;
  76                 __be32          vnode;
  77                 __be32          unique;
  78                 uint8_t         name[16];
  79                 uint8_t         overflow[4];    /* if any char of the name (inc
  80                                                  * NUL) reaches here, consume
  81                                                  * the next dirent too */
  82         } u;
  83         uint8_t extended_name[32];
  84 };
  85
  86 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */
  87 struct afs_dir_pagehdr {
  88         __be16          npages;
  89         __be16          magic;
  90 #define AFS_DIR_MAGIC htons(1234)
  91         uint8_t         nentries;
  92         uint8_t         bitmap[8];
  93         uint8_t         pad[19];
  94 };
  95
  96 /* directory block layout */
  97 union afs_dir_block {
  98
  99         struct afs_dir_pagehdr pagehdr;
 100
 101         struct {
 102                 struct afs_dir_pagehdr  pagehdr;
 103                 uint8_t                 alloc_ctrs[128];
 104                 /* dir hash table */
 105                 uint16_t                hashtable[AFS_DIR_HASHTBL_SIZE];
 106         } hdr;
 107
 108         union afs_dirent dirents[AFS_DIRENT_PER_BLOCK];
 109 };
 110
 111 /* layout on a linux VM page */
 112 struct afs_dir_page {
 113         union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];
 114 };
 115
 116 struct afs_lookup_cookie {
 117         struct afs_fid  fid;
 118         const char      *name;
 119         size_t          nlen;
 120         int             found;
 121 };
 122
 123 /*
 124  * check that a directory page is valid
 125  */
 126 static inline void afs_dir_check_page(struct inode *dir, struct page *page)
 127 {
 128         struct afs_dir_page *dbuf;
 129         loff_t latter;
 130         int tmp, qty;
 131
 132 #if 0
 133         /* check the page count */
 134         qty = desc.size / sizeof(dbuf->blocks[0]);
 135         if (qty == 0)
 136                 goto error;
 137
 138         if (page->index == 0 && qty != ntohs(dbuf->blocks[0].pagehdr.npages)) {
 139                 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n",
 140                        __FUNCTION__, dir->i_ino, qty,
 141                        ntohs(dbuf->blocks[0].pagehdr.npages));
 142                 goto error;
 143         }
 144 #endif
 145
 146         /* determine how many magic numbers there should be in this page */
 147         latter = dir->i_size - page_offset(page);
 148         if (latter >= PAGE_SIZE)
 149                 qty = PAGE_SIZE;
 150         else
 151                 qty = latter;
 152         qty /= sizeof(union afs_dir_block);
 153
 154         /* check them */
 155         dbuf = page_address(page);
 156         for (tmp = 0; tmp < qty; tmp++) {
 157                 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) {
 158                         printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
 159                                __FUNCTION__, dir->i_ino, tmp, qty,
 160                                ntohs(dbuf->blocks[tmp].pagehdr.magic));
 161                         goto error;
 162                 }
 163         }
 164
 165         SetPageChecked(page);
 166         return;
 167
 168 error:
 169         SetPageChecked(page);
 170         SetPageError(page);
 171 }
 172
 173 /*
 174  * discard a page cached in the pagecache
 175  */
 176 static inline void afs_dir_put_page(struct page *page)
 177 {
 178         kunmap(page);
 179         page_cache_release(page);
 180 }
 181
 182 /*
 183  * get a page into the pagecache
 184  */
 185 static struct page *afs_dir_get_page(struct inode *dir, unsigned long index,
 186                                      struct key *key)
 187 {
 188         struct page *page;
 189         struct file file = {
 190                 .private_data = key,
 191         };
 192
 193         _enter("{%lu},%lu", dir->i_ino, index);
 194
 195         page = read_mapping_page(dir->i_mapping, index, &file);
 196         if (!IS_ERR(page)) {
 197                 wait_on_page_locked(page);
 198                 kmap(page);
 199                 if (!PageUptodate(page))
 200                         goto fail;
 201                 if (!PageChecked(page))
 202                         afs_dir_check_page(dir, page);
 203                 if (PageError(page))
 204                         goto fail;
 205         }
 206         return page;
 207
 208 fail:
 209         afs_dir_put_page(page);
 210         _leave(" = -EIO");
 211         return ERR_PTR(-EIO);
 212 }
 213
 214 /*
 215  * open an AFS directory file
 216  */
 217 static int afs_dir_open(struct inode *inode, struct file *file)
 218 {
 219         _enter("{%lu}", inode->i_ino);
 220
 221         BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
 222         BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
 223
 224         if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))
 225                 return -ENOENT;
 226
 227         return afs_open(inode, file);
 228 }
 229
 230 /*
 231  * deal with one block in an AFS directory
 232  */
 233 static int afs_dir_iterate_block(unsigned *fpos,
 234                                  union afs_dir_block *block,
 235                                  unsigned blkoff,
 236                                  void *cookie,
 237                                  filldir_t filldir)
 238 {
 239         union afs_dirent *dire;
 240         unsigned offset, next, curr;
 241         size_t nlen;
 242         int tmp, ret;
 243
 244         _enter("%u,%x,%p,,",*fpos,blkoff,block);
 245
 246         curr = (*fpos - blkoff) / sizeof(union afs_dirent);
 247
 248         /* walk through the block, an entry at a time */
 249         for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries;
 250              offset < AFS_DIRENT_PER_BLOCK;
 251              offset = next
 252              ) {
 253                 next = offset + 1;
 254
 255                 /* skip entries marked unused in the bitmap */
 256                 if (!(block->pagehdr.bitmap[offset / 8] &
 257                       (1 << (offset % 8)))) {
 258                         _debug("ENT[%Zu.%u]: unused",
 259                                blkoff / sizeof(union afs_dir_block), offset);
 260                         if (offset >= curr)
 261                                 *fpos = blkoff +
 262                                         next * sizeof(union afs_dirent);
 263                         continue;
 264                 }
 265
 266                 /* got a valid entry */
 267                 dire = &block->dirents[offset];
 268                 nlen = strnlen(dire->u.name,
 269                                sizeof(*block) -
 270                                offset * sizeof(union afs_dirent));
 271
 272                 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"",
 273                        blkoff / sizeof(union afs_dir_block), offset,
 274                        (offset < curr ? "skip" : "fill"),
 275                        nlen, dire->u.name);
 276
 277                 /* work out where the next possible entry is */
 278                 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) {
 279                         if (next >= AFS_DIRENT_PER_BLOCK) {
 280                                 _debug("ENT[%Zu.%u]:"
 281                                        " %u travelled beyond end dir block"
 282                                        " (len %u/%Zu)",
 283                                        blkoff / sizeof(union afs_dir_block),
 284                                        offset, next, tmp, nlen);
 285                                 return -EIO;
 286                         }
 287                         if (!(block->pagehdr.bitmap[next / 8] &
 288                               (1 << (next % 8)))) {
 289                                 _debug("ENT[%Zu.%u]:"
 290                                        " %u unmarked extension (len %u/%Zu)",
 291                                        blkoff / sizeof(union afs_dir_block),
 292                                        offset, next, tmp, nlen);
 293                                 return -EIO;
 294                         }
 295
 296                         _debug("ENT[%Zu.%u]: ext %u/%Zu",
 297                                blkoff / sizeof(union afs_dir_block),
 298                                next, tmp, nlen);
 299                         next++;
 300                 }
 301
 302                 /* skip if starts before the current position */
 303                 if (offset < curr)
 304                         continue;
 305
 306                 /* found the next entry */
 307                 ret = filldir(cookie,
 308                               dire->u.name,
 309                               nlen,
 310                               blkoff + offset * sizeof(union afs_dirent),
 311                               ntohl(dire->u.vnode),
 312                               filldir == afs_lookup_filldir ?
 313                               ntohl(dire->u.unique) : DT_UNKNOWN);
 314                 if (ret < 0) {
 315                         _leave(" = 0 [full]");
 316                         return 0;
 317                 }
 318
 319                 *fpos = blkoff + next * sizeof(union afs_dirent);
 320         }
 321
 322         _leave(" = 1 [more]");
 323         return 1;
 324 }
 325
 326 /*
 327  * iterate through the data blob that lists the contents of an AFS directory
 328  */
 329 static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie,
 330                            filldir_t filldir, struct key *key)
 331 {
 332         union afs_dir_block *dblock;
 333         struct afs_dir_page *dbuf;
 334         struct page *page;
 335         unsigned blkoff, limit;
 336         int ret;
 337
 338         _enter("{%lu},%u,,", dir->i_ino, *fpos);
 339
 340         if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {
 341                 _leave(" = -ESTALE");
 342                 return -ESTALE;
 343         }
 344
 345         /* round the file position up to the next entry boundary */
 346         *fpos += sizeof(union afs_dirent) - 1;
 347         *fpos &= ~(sizeof(union afs_dirent) - 1);
 348
 349         /* walk through the blocks in sequence */
 350         ret = 0;
 351         while (*fpos < dir->i_size) {
 352                 blkoff = *fpos & ~(sizeof(union afs_dir_block) - 1);
 353
 354                 /* fetch the appropriate page from the directory */
 355                 page = afs_dir_get_page(dir, blkoff / PAGE_SIZE, key);
 356                 if (IS_ERR(page)) {
 357                         ret = PTR_ERR(page);
 358                         break;
 359                 }
 360
 361                 limit = blkoff & ~(PAGE_SIZE - 1);
 362
 363                 dbuf = page_address(page);
 364
 365                 /* deal with the individual blocks stashed on this page */
 366                 do {
 367                         dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) /
 368                                                sizeof(union afs_dir_block)];
 369                         ret = afs_dir_iterate_block(fpos, dblock, blkoff,
 370                                                     cookie, filldir);
 371                         if (ret != 1) {
 372                                 afs_dir_put_page(page);
 373                                 goto out;
 374                         }
 375
 376                         blkoff += sizeof(union afs_dir_block);
 377
 378                 } while (*fpos < dir->i_size && blkoff < limit);
 379
 380                 afs_dir_put_page(page);
 381                 ret = 0;
 382         }
 383
 384 out:
 385         _leave(" = %d", ret);
 386         return ret;
 387 }
 388
 389 /*
 390  * read an AFS directory
 391  */
 392 static int afs_readdir(struct file *file, void *cookie, filldir_t filldir)
 393 {
 394         unsigned fpos;
 395         int ret;
 396
 397         _enter("{%Ld,{%lu}}",
 398                file->f_pos, file->f_path.dentry->d_inode->i_ino);
 399
 400         ASSERT(file->private_data != NULL);
 401
 402         fpos = file->f_pos;
 403         ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos,
 404                               cookie, filldir, file->private_data);
 405         file->f_pos = fpos;
 406
 407         _leave(" = %d", ret);
 408         return ret;
 409 }
 410
 411 /*
 412  * search the directory for a name
 413  * - if afs_dir_iterate_block() spots this function, it'll pass the FID
 414  *   uniquifier through dtype
 415  */
 416 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
 417                               loff_t fpos, u64 ino, unsigned dtype)
 418 {
 419         struct afs_lookup_cookie *cookie = _cookie;
 420
 421         _enter("{%s,%Zu},%s,%u,,%llu,%u",
 422                cookie->name, cookie->nlen, name, nlen, 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:%d},%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 > 255) {
 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:%d},{%s},%o",
 737                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
 738
 739         ret = -ENAMETOOLONG;
 740         if (dentry->d_name.len > 255)
 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:%d},{%s}",
 802                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
 803
 804         ret = -ENAMETOOLONG;
 805         if (dentry->d_name.len > 255)
 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:%d},{%s}",
 848                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
 849
 850         ret = -ENAMETOOLONG;
 851         if (dentry->d_name.len > 255)
 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:%d},{%s},%o,",
 922                dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
 923
 924         ret = -ENAMETOOLONG;
 925         if (dentry->d_name.len > 255)
 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:%d},{%x:%d},{%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 > 255)
 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:%d},{%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 > 255)
1043                 goto error;
1044
1045         ret = -EINVAL;
1046         if (strlen(content) > 1023)
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:%d},{%x:%d},{%x:%d},{%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 > 255)
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 }