src/afs/LINUX/osi_export.c

   1 /*
   2  * vi:set cin noet sw=4 tw=70:
   3  * Copyright 2006, International Business Machines Corporation and others.
   4  * All Rights Reserved.
   5  *
   6  * This software has been released under the terms of the IBM Public
   7  * License.  For details, see the LICENSE file in the top-level source
   8  * directory or online at http://www.openafs.org/dl/license10.html
   9  */
  10
  11 /*
  12  * Filesystem export operations for Linux
  13  */
  14 #include <afsconfig.h>
  15 #include "afs/param.h"
  16
  17 RCSID
  18     ("$Header$");
  19
  20 #include <linux/module.h> /* early to avoid printf->printk mapping */
  21 #include <linux/fs.h>
  22 #ifdef EXPORTFS_H_EXISTS
  23 #include <linux/exportfs.h>
  24 #endif
  25 #include "afs/sysincludes.h"
  26 #include "afsincludes.h"
  27 #include "afs/afs_dynroot.h"
  28 #include "h/smp_lock.h"
  29
  30 /* #define OSI_EXPORT_DEBUG */
  31
  32 extern struct dentry_operations afs_dentry_operations;
  33
  34 struct get_name_data {
  35     char *name;
  36     struct VenusFid fid;
  37     int found;
  38 };
  39
  40 /*
  41  * Linux reserved the following filehandle types:
  42  * - 0 is always the filesystem root; NFS deals with this for us
  43  * - 1,2 are reserved by Linux for inode-number-based filehandles
  44  * - 0xff is reserved by linux
  45  *
  46  * We encode filehandles for AFS files using the types defined below.
  47  * Internally, our "object ID" is a VenusFid; if we get a filehandle
  48  * with a more-stable cell ID, we'll turn it into a cell number in
  49  * the decode_fh wrapper.
  50  */
  51
  52 #define AFSFH_VENUSFID      0xa0 /* cell, volume, vnode, uniq           */
  53 #define AFSFH_CELLFID       0xa1 /* cellhandle, volume, vnode, uniq     */
  54 #define AFSFH_NET_VENUSFID  0xa2 /* net cell, volume, vnode, uniq       */
  55 #define AFSFH_NET_CELLFID   0xa3 /* net cellhandle, volume, vnode, uniq */
  56 #define AFSFH_DYN_RO_CELL   0xd0 /* cellhandle for RO root.cell mount   */
  57 #define AFSFH_DYN_RW_CELL   0xd1 /* cellhandle for RW root.cell mount   */
  58 #define AFSFH_DYN_RO_LINK   0xd2 /* cellhandle for RO root.cell symlink */
  59 #define AFSFH_DYN_RW_LINK   0xd3 /* cellhandle for RW root.cell symlink */
  60 #define AFSFH_DYN_MOUNT     0xd4 /* cellhandle, volume for mount point  */
  61 #define AFSFH_DYN_SYMLINK   0xd5 /* hash of dynroot symlink target */
  62
  63 static int afs_encode_fh(struct dentry *de, __u32 *fh, int *max_len,
  64                          int connectable)
  65 {
  66     struct vcache *tvc;
  67     struct cell *tc;
  68     int vntype;
  69
  70     if (!de->d_inode) /* encode a negative dentry?! */
  71         return 255;
  72     if (*max_len < 4)  /* not enough space */
  73         return 255;
  74
  75     tvc = VTOAFS(de->d_inode);
  76
  77 #ifdef OSI_EXPORT_DEBUG
  78     printk("afs: encode_fh(0x%08x/%d/%d.%d)\n",
  79            tvc->fid.Cell,      tvc->fid.Fid.Volume,
  80            tvc->fid.Fid.Vnode, tvc->fid.Fid.Unique);
  81 #endif
  82     if (afs_IsDynrootAnyFid(&tvc->fid)) {
  83         vntype = VNUM_TO_VNTYPE(tvc->fid.Fid.Vnode);
  84         switch (vntype) {
  85             case 0:
  86                 /* encode as a normal filehandle */
  87                 break;
  88
  89             case VN_TYPE_MOUNT:
  90                 if (*max_len < 5) {
  91                     return 255;
  92                 }
  93                 /* fall through */
  94
  95             case VN_TYPE_CELL:
  96             case VN_TYPE_ALIAS:
  97                 AFS_GLOCK();
  98                 tc = afs_GetCellByIndex(VNUM_TO_CIDX(tvc->fid.Fid.Vnode),
  99                                         READ_LOCK);
 100                 if (!tc) {
 101                     AFS_GUNLOCK();
 102                     return 255;
 103                 }
 104                 memcpy((void *)fh, tc->cellHandle, 16);
 105                 afs_PutCell(tc, READ_LOCK);
 106                 AFS_GUNLOCK();
 107                 if (vntype == VN_TYPE_MOUNT) {
 108                     fh[4] = htonl(tvc->fid.Fid.Unique);
 109                     *max_len = 5;
 110                     return AFSFH_DYN_MOUNT;
 111                 }
 112                 *max_len = 4;
 113                 if (vntype == VN_TYPE_CELL) {
 114                     return AFSFH_DYN_RO_CELL | VNUM_TO_RW(tvc->fid.Fid.Vnode);
 115                 } else {
 116                     return AFSFH_DYN_RO_LINK | VNUM_TO_RW(tvc->fid.Fid.Vnode);
 117                 }
 118
 119             case VN_TYPE_SYMLINK:
 120                 /* XXX fill in filehandle for dynroot symlink */
 121                 /* XXX return AFSFH_DYN_SYMLINK; */
 122
 123             default:
 124                 return 255;
 125         }
 126     }
 127
 128     if (*max_len < 7) {
 129         /* not big enough for a migratable filehandle */
 130         /* always encode in network order */
 131         fh[0] = htonl(tvc->fid.Cell);
 132         fh[1] = htonl(tvc->fid.Fid.Volume);
 133         fh[2] = htonl(tvc->fid.Fid.Vnode);
 134         fh[3] = htonl(tvc->fid.Fid.Unique);
 135         *max_len = 4;
 136         return AFSFH_NET_VENUSFID;
 137     }
 138
 139     AFS_GLOCK();
 140     tc = afs_GetCell(tvc->fid.Cell, READ_LOCK);
 141     if (!tc) {
 142         AFS_GUNLOCK();
 143         return 255;
 144     }
 145     memcpy((void *)fh, tc->cellHandle, 16);
 146     afs_PutCell(tc, READ_LOCK);
 147     AFS_GUNLOCK();
 148     /* always encode in network order */
 149     fh[4] = htonl(tvc->fid.Fid.Volume);
 150     fh[5] = htonl(tvc->fid.Fid.Vnode);
 151     fh[6] = htonl(tvc->fid.Fid.Unique);
 152
 153     *max_len = 7;
 154     return AFSFH_NET_CELLFID;
 155 }
 156
 157 static struct dentry *afs_decode_fh(struct super_block *sb, __u32 *fh,
 158                                     int fh_len, int fh_type,
 159                                     int (*acceptable)(void *, struct dentry *),
 160                                     void *context)
 161 {
 162     struct VenusFid fid;
 163     struct cell *tc;
 164     struct dentry *result;
 165
 166     switch (fh_type) {
 167         case AFSFH_VENUSFID:
 168             if (fh_len != 4)
 169                 return NULL;
 170             fid.Cell       = fh[0];
 171             fid.Fid.Volume = fh[1];
 172             fid.Fid.Vnode  = fh[2];
 173             fid.Fid.Unique = fh[3];
 174             break;
 175
 176         case AFSFH_CELLFID:
 177             if (fh_len != 7)
 178                 return NULL;
 179             AFS_GLOCK();
 180             tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
 181             if (!tc) {
 182                 AFS_GUNLOCK();
 183                 return NULL;
 184             }
 185             fid.Cell       = tc->cellNum;
 186             fid.Fid.Volume = fh[4];
 187             fid.Fid.Vnode  = fh[5];
 188             fid.Fid.Unique = fh[6];
 189             afs_PutCell(tc, READ_LOCK);
 190             AFS_GUNLOCK();
 191             break;
 192
 193         case AFSFH_NET_VENUSFID:
 194             if (fh_len != 4)
 195                 return NULL;
 196             fid.Cell       = ntohl(fh[0]);
 197             fid.Fid.Volume = ntohl(fh[1]);
 198             fid.Fid.Vnode  = ntohl(fh[2]);
 199             fid.Fid.Unique = ntohl(fh[3]);
 200             break;
 201
 202         case AFSFH_NET_CELLFID:
 203             if (fh_len != 7)
 204                 return NULL;
 205             AFS_GLOCK();
 206             tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
 207             if (!tc) {
 208                 AFS_GUNLOCK();
 209                 return NULL;
 210             }
 211             fid.Cell       = tc->cellNum;
 212             fid.Fid.Volume = ntohl(fh[4]);
 213             fid.Fid.Vnode  = ntohl(fh[5]);
 214             fid.Fid.Unique = ntohl(fh[6]);
 215             afs_PutCell(tc, READ_LOCK);
 216             AFS_GUNLOCK();
 217             break;
 218
 219         case AFSFH_DYN_RO_CELL:
 220         case AFSFH_DYN_RW_CELL:
 221             if (fh_len != 4)
 222                 return NULL;
 223             AFS_GLOCK();
 224             tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
 225             if (!tc) {
 226                 AFS_GUNLOCK();
 227                 return NULL;
 228             }
 229             afs_GetDynrootFid(&fid);
 230             fid.Fid.Vnode  = VNUM_FROM_CIDX_RW(tc->cellIndex, fh_type & 1);
 231             fid.Fid.Unique = 1;
 232             afs_PutCell(tc, READ_LOCK);
 233             AFS_GUNLOCK();
 234             break;
 235
 236         case AFSFH_DYN_RO_LINK:
 237         case AFSFH_DYN_RW_LINK:
 238             if (fh_len != 4)
 239                 return NULL;
 240             AFS_GLOCK();
 241             tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
 242             if (!tc) {
 243                 AFS_GUNLOCK();
 244                 return NULL;
 245             }
 246             afs_GetDynrootFid(&fid);
 247             fid.Fid.Vnode  = VNUM_FROM_CAIDX_RW(tc->cellIndex, fh_type & 1);
 248             fid.Fid.Unique = 1;
 249             afs_PutCell(tc, READ_LOCK);
 250             AFS_GUNLOCK();
 251             break;
 252
 253         case AFSFH_DYN_MOUNT:
 254             if (fh_len != 5)
 255                 return NULL;
 256             AFS_GLOCK();
 257             tc = afs_GetCellByHandle((void *)fh, READ_LOCK);
 258             if (!tc) {
 259                 AFS_GUNLOCK();
 260                 return NULL;
 261             }
 262             afs_GetDynrootFid(&fid);
 263             fid.Fid.Vnode  = VNUM_FROM_TYPEID(VN_TYPE_MOUNT,
 264                                               tc->cellIndex << 2);
 265             fid.Fid.Unique = ntohl(fh[4]);
 266             afs_PutCell(tc, READ_LOCK);
 267             AFS_GUNLOCK();
 268             break;
 269
 270         case AFSFH_DYN_SYMLINK:
 271             /* XXX parse dynroot symlink filehandle */
 272             /* break; */
 273
 274         default:
 275             return NULL;
 276     }
 277
 278     result = sb->s_export_op->find_exported_dentry(sb, &fid, 0,
 279                                                    acceptable, context);
 280 #ifdef OSI_EXPORT_DEBUG
 281     if (!result) {
 282         printk("afs: decode_fh(0x%08x/%d/%d.%d): no dentry\n",
 283                fid.Cell,      fid.Fid.Volume,
 284                fid.Fid.Vnode, fid.Fid.Unique);
 285     } else if (IS_ERR(result)) {
 286         printk("afs: decode_fh(0x%08x/%d/%d.%d): error %ld\n",
 287                fid.Cell,      fid.Fid.Volume,
 288                fid.Fid.Vnode, fid.Fid.Unique, PTR_ERR(result));
 289     }
 290 #endif
 291     return result;
 292 }
 293
 294 static int update_dir_parent(struct vrequest *areq, struct vcache *adp)
 295 {
 296     struct VenusFid tfid;
 297     struct dcache *tdc;
 298     afs_size_t dirOffset, dirLen;
 299     int code;
 300
 301 redo:
 302     if (!(adp->states & CStatd)) {
 303         if ((code = afs_VerifyVCache2(adp, areq))) {
 304 #ifdef OSI_EXPORT_DEBUG
 305             printk("afs: update_dir_parent(0x%08x/%d/%d.%d): VerifyVCache2: %d\n",
 306                    adp->fid.Cell,      adp->fid.Fid.Volume,
 307                    adp->fid.Fid.Vnode, adp->fid.Fid.Unique, code);
 308 #endif
 309             return code;
 310         }
 311     }
 312
 313     tdc = afs_GetDCache(adp, (afs_size_t) 0, areq, &dirOffset, &dirLen, 1);
 314     if (!tdc) {
 315 #ifdef OSI_EXPORT_DEBUG
 316         printk("afs: update_dir_parent(0x%08x/%d/%d.%d): no dcache\n",
 317                adp->fid.Cell,      adp->fid.Fid.Volume,
 318                adp->fid.Fid.Vnode, adp->fid.Fid.Unique);
 319 #endif
 320         return EIO;
 321     }
 322
 323     /* now we will just call dir package with appropriate inode.
 324      * Dirs are always fetched in their entirety for now */
 325     ObtainSharedLock(&adp->lock, 801);
 326     ObtainReadLock(&tdc->lock);
 327
 328     /*
 329      * Make sure that the data in the cache is current. There are two
 330      * cases we need to worry about:
 331      * 1. The cache data is being fetched by another process.
 332      * 2. The cache data is no longer valid
 333      */
 334     while ((adp->states & CStatd)
 335            && (tdc->dflags & DFFetching)
 336            && hsame(adp->m.DataVersion, tdc->f.versionNo)) {
 337         ReleaseReadLock(&tdc->lock);
 338         ReleaseSharedLock(&adp->lock);
 339         afs_osi_Sleep(&tdc->validPos);
 340         ObtainSharedLock(&adp->lock, 802);
 341         ObtainReadLock(&tdc->lock);
 342     }
 343     if (!(adp->states & CStatd)
 344         || !hsame(adp->m.DataVersion, tdc->f.versionNo)) {
 345         ReleaseReadLock(&tdc->lock);
 346         ReleaseSharedLock(&adp->lock);
 347         afs_PutDCache(tdc);
 348 #ifdef OSI_EXPORT_DEBUG
 349         printk("afs: update_dir_parent(0x%08x/%d/%d.%d): dir changed; retrying\n",
 350                adp->fid.Cell,      adp->fid.Fid.Volume,
 351                adp->fid.Fid.Vnode, adp->fid.Fid.Unique);
 352 #endif
 353         goto redo;
 354     }
 355
 356     /* lookup the name in the appropriate dir, and return a cache entry
 357      * on the resulting fid */
 358     code = afs_dir_Lookup(tdc, "..", &tfid.Fid);
 359
 360     ReleaseReadLock(&tdc->lock);
 361     afs_PutDCache(tdc);
 362
 363     if (!code) {
 364         UpgradeSToWLock(&adp->lock, 803);
 365         adp->parentVnode  = tfid.Fid.Vnode;
 366         adp->parentUnique = tfid.Fid.Unique;
 367     }
 368 #ifdef OSI_EXPORT_DEBUG
 369     if (code) {
 370         printk("afs: update_dir_parent(0x%08x/%d/%d.%d): afs_dir_Lookup: %d\n",
 371                adp->fid.Cell,      adp->fid.Fid.Volume,
 372                adp->fid.Fid.Vnode, adp->fid.Fid.Unique, code);
 373     } else {
 374         printk("afs: update_dir_parent(0x%08x/%d/%d.%d) => %d.%d\n",
 375                adp->fid.Cell,      adp->fid.Fid.Volume,
 376                adp->fid.Fid.Vnode, adp->fid.Fid.Unique,
 377                adp->parentVnode,   adp->parentUnique);
 378     }
 379 #endif
 380     ReleaseSharedLock(&adp->lock);
 381     return code;
 382 }
 383
 384
 385 static int UnEvalFakeStat(struct vrequest *areq, struct vcache **vcpp)
 386 {
 387     struct VenusFid tfid;
 388     struct volume *tvp;
 389     struct vcache *tvc;
 390     int code;
 391
 392     if (!afs_fakestat_enable)
 393         return 0;
 394
 395     if (*vcpp == afs_globalVp || vType(*vcpp) != VDIR || (*vcpp)->mvstat != 2)
 396         return 0;
 397
 398     /* Figure out what FID to look for */
 399     tvp = afs_GetVolume(&(*vcpp)->fid, 0, READ_LOCK);
 400     if (!tvp) {
 401 #ifdef OSI_EXPORT_DEBUG
 402         printk("afs: UnEvalFakeStat(0x%08x/%d/%d.%d): no volume\n",
 403                (*vcpp)->fid.Cell,      (*vcpp)->fid.Fid.Volume,
 404                (*vcpp)->fid.Fid.Vnode, (*vcpp)->fid.Fid.Unique);
 405 #endif
 406         return ENOENT;
 407     }
 408     tfid = tvp->mtpoint;
 409     afs_PutVolume(tvp, READ_LOCK);
 410
 411     tvc = afs_GetVCache(&tfid, areq, NULL, NULL);
 412     if (!tvc) {
 413 #ifdef OSI_EXPORT_DEBUG
 414         printk("afs: UnEvalFakeStat(0x%08x/%d/%d.%d): GetVCache(0x%08x/%d/%d.%d) failed\n",
 415                (*vcpp)->fid.Cell,      (*vcpp)->fid.Fid.Volume,
 416                (*vcpp)->fid.Fid.Vnode, (*vcpp)->fid.Fid.Unique,
 417                tfid.Cell,          tfid.Fid.Volume,
 418                tfid.Fid.Vnode,     tfid.Fid.Unique);
 419 #endif
 420         return ENOENT;
 421     }
 422
 423     if (afs_fakestat_enable == 2) {
 424         ObtainWriteLock(&tvc->lock, 806);
 425         code = afs_HandleLink(tvc, areq);
 426         if (code) {
 427             ReleaseWriteLock(&tvc->lock);
 428             afs_PutVCache(tvc);
 429             return code;
 430         }
 431         if (!strchr(tvc->linkData, ':')) {
 432             ReleaseWriteLock(&tvc->lock);
 433             afs_PutVCache(tvc);
 434             return 0;
 435         }
 436         ReleaseWriteLock(&tvc->lock);
 437     }
 438
 439     afs_PutVCache(*vcpp);
 440     *vcpp = tvc;
 441     return 0;
 442 }
 443
 444
 445 /*
 446  * Given a FID, obtain or construct a dentry, or return an error.
 447  * This should be called with the BKL and AFS_GLOCK held.
 448  */
 449 static struct dentry *get_dentry_from_fid(cred_t *credp, struct VenusFid *afid)
 450 {
 451     struct vrequest treq;
 452     struct vcache *vcp;
 453     struct vattr vattr;
 454     struct inode *ip;
 455     struct dentry *dp;
 456     afs_int32 code;
 457
 458     code = afs_InitReq(&treq, credp);
 459     if (code) {
 460 #ifdef OSI_EXPORT_DEBUG
 461         printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): afs_InitReq: %d\n",
 462                afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique,
 463                code);
 464 #endif
 465         return ERR_PTR(-afs_CheckCode(code, &treq, 101));
 466     }
 467     vcp = afs_GetVCache(afid, &treq, NULL, NULL);
 468     if (vcp == NULL) {
 469 #ifdef OSI_EXPORT_DEBUG
 470         printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): no vcache\n",
 471                afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique);
 472 #endif
 473         return NULL;
 474     }
 475
 476     /*
 477      * Now, it might be that we just caused a directory vnode to
 478      * spring into existence, in which case its parent FID is unset.
 479      * We need to do something about that, but only because we care
 480      * in our own get_parent(), below -- the common code never looks
 481      * at parentVnode on directories, except for VIOCGETVCXSTATUS.
 482      * So, if this fails, we don't really care very much.
 483      */
 484     if (vType(vcp) == VDIR && vcp->mvstat != 2 && !vcp->parentVnode)
 485         update_dir_parent(&treq, vcp);
 486
 487     /*
 488      * If this is a volume root directory and fakestat is enabled,
 489      * we might need to replace the directory by a mount point.
 490      */
 491     code = UnEvalFakeStat(&treq, &vcp);
 492     if (code) {
 493 #ifdef OSI_EXPORT_DEBUG
 494         printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): UnEvalFakeStat: %d\n",
 495                afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique,
 496                code);
 497 #endif
 498         afs_PutVCache(vcp);
 499         return ERR_PTR(-afs_CheckCode(code, &treq, 101));
 500     }
 501
 502     ip = AFSTOV(vcp);
 503     afs_getattr(vcp, &vattr, credp);
 504     afs_fill_inode(ip, &vattr);
 505
 506     /* d_alloc_anon might block, so we shouldn't hold the glock */
 507     AFS_GUNLOCK();
 508     dp = d_alloc_anon(ip);
 509     AFS_GLOCK();
 510
 511     if (!dp) {
 512         iput(ip);
 513 #ifdef OSI_EXPORT_DEBUG
 514         printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): out of memory\n",
 515                afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique);
 516 #endif
 517         return ERR_PTR(-ENOMEM);
 518     }
 519
 520     dp->d_op = &afs_dentry_operations;
 521     return dp;
 522 }
 523
 524 static struct dentry *afs_export_get_dentry(struct super_block *sb,
 525                                             void *inump)
 526 {
 527     struct dentry *dp;
 528     cred_t *credp;
 529
 530     credp = crref();
 531     lock_kernel();
 532     AFS_GLOCK();
 533
 534     dp = get_dentry_from_fid(credp, inump);
 535
 536     AFS_GUNLOCK();
 537     unlock_kernel();
 538     crfree(credp);
 539
 540     return dp;
 541 }
 542
 543
 544 static int get_name_hook(void *hdata, char *name,
 545                          afs_int32 vnode, afs_int32 unique)
 546 {
 547     struct get_name_data *data = (struct get_name_data *)hdata;
 548     int len;
 549
 550     if (vnode == data->fid.Fid.Vnode && unique == data->fid.Fid.Unique) {
 551         len = strlen(name);
 552         if (len > NAME_MAX) len = NAME_MAX;
 553         memcpy(data->name, name, len);
 554         data->name[len] = '\0';
 555         data->found = 1;
 556     }
 557     return 0;
 558 }
 559
 560 static int afs_export_get_name(struct dentry *parent, char *name,
 561                                struct dentry *child)
 562 {
 563     struct afs_fakestat_state fakestate;
 564     struct get_name_data data;
 565     struct vrequest treq;
 566     struct volume *tvp;
 567     struct vcache *vcp;
 568     struct dcache *tdc;
 569     cred_t *credp;
 570     afs_size_t dirOffset, dirLen;
 571     afs_int32 code = 0;
 572
 573     if (!parent->d_inode) {
 574 #ifdef OSI_EXPORT_DEBUG
 575         /* can't lookup name in a negative dentry */
 576         printk("afs: get_name(%s, %s): no parent inode\n",
 577                parent->d_name.name ? (char *)parent->d_name.name : "?",
 578                child->d_name.name  ? (char *)child->d_name.name  : "?");
 579 #endif
 580         return -EIO;
 581     }
 582     if (!child->d_inode) {
 583 #ifdef OSI_EXPORT_DEBUG
 584         /* can't find the FID of negative dentry */
 585         printk("afs: get_name(%s, %s): no child inode\n",
 586                parent->d_name.name ? (char *)parent->d_name.name : "?",
 587                child->d_name.name  ? (char *)child->d_name.name  : "?");
 588 #endif
 589         return -ENOENT;
 590     }
 591
 592     afs_InitFakeStat(&fakestate);
 593
 594     credp = crref();
 595     lock_kernel();
 596     AFS_GLOCK();
 597
 598     vcp = VTOAFS(child->d_inode);
 599
 600     /* special case dynamic mount directory */
 601     if (afs_IsDynrootMount(vcp)) {
 602 #ifdef OSI_EXPORT_DEBUG
 603         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): this is the dynmount dir\n",
 604                parent->d_name.name ? (char *)parent->d_name.name : "?",
 605                vcp->fid.Cell,      vcp->fid.Fid.Volume,
 606                vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique);
 607 #endif
 608         data.fid = vcp->fid;
 609         if (VTOAFS(parent->d_inode) == afs_globalVp)
 610             strcpy(name, AFS_DYNROOT_MOUNTNAME);
 611         else
 612             code = -ENOENT;
 613         goto done;
 614     }
 615
 616     /* Figure out what FID to look for */
 617     if (vcp->mvstat == 2) { /* volume root */
 618         tvp = afs_GetVolume(&vcp->fid, 0, READ_LOCK);
 619         if (!tvp) {
 620 #ifdef OSI_EXPORT_DEBUG
 621             printk("afs: get_name(%s, 0x%08x/%d/%d.%d): no volume for root\n",
 622                    parent->d_name.name ? (char *)parent->d_name.name : "?",
 623                    vcp->fid.Cell,      vcp->fid.Fid.Volume,
 624                    vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique);
 625 #endif
 626             code = ENOENT;
 627             goto done;
 628         }
 629         data.fid = tvp->mtpoint;
 630         afs_PutVolume(tvp, READ_LOCK);
 631     } else {
 632         data.fid = vcp->fid;
 633     }
 634
 635     vcp = VTOAFS(parent->d_inode);
 636 #ifdef OSI_EXPORT_DEBUG
 637     printk("afs: get_name(%s, 0x%08x/%d/%d.%d): parent is 0x%08x/%d/%d.%d\n",
 638            parent->d_name.name ? (char *)parent->d_name.name : "?",
 639            data.fid.Cell,      data.fid.Fid.Volume,
 640            data.fid.Fid.Vnode, data.fid.Fid.Unique,
 641            vcp->fid.Cell,      vcp->fid.Fid.Volume,
 642            vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique);
 643 #endif
 644
 645     code = afs_InitReq(&treq, credp);
 646     if (code) {
 647 #ifdef OSI_EXPORT_DEBUG
 648         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): afs_InitReq: %d\n",
 649                parent->d_name.name ? (char *)parent->d_name.name : "?",
 650                data.fid.Cell,      data.fid.Fid.Volume,
 651                data.fid.Fid.Vnode, data.fid.Fid.Unique, code);
 652 #endif
 653         goto done;
 654     }
 655
 656     /* a dynamic mount point in the dynamic mount directory */
 657     if (afs_IsDynrootMount(vcp) && afs_IsDynrootAnyFid(&data.fid)
 658         && VNUM_TO_VNTYPE(data.fid.Fid.Vnode) == VN_TYPE_MOUNT) {
 659 #ifdef OSI_EXPORT_DEBUG
 660         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): dynamic mount point\n",
 661                parent->d_name.name ? (char *)parent->d_name.name : "?",
 662                data.fid.Cell,      data.fid.Fid.Volume,
 663                data.fid.Fid.Vnode, data.fid.Fid.Unique);
 664 #endif
 665         vcp = afs_GetVCache(&data.fid, &treq, NULL, NULL);
 666         if (vcp) {
 667             ObtainReadLock(&vcp->lock);
 668             if (strlen(vcp->linkData + 1) <= NAME_MAX)
 669                 strcpy(name, vcp->linkData + 1);
 670             else
 671                 code = ENOENT;
 672             ReleaseReadLock(&vcp->lock);
 673             afs_PutVCache(vcp);
 674         } else {
 675 #ifdef OSI_EXPORT_DEBUG
 676             printk("afs: get_name(%s, 0x%08x/%d/%d.%d): no vcache\n",
 677                    parent->d_name.name ? (char *)parent->d_name.name : "?",
 678                    data.fid.Cell,      data.fid.Fid.Volume,
 679                    data.fid.Fid.Vnode, data.fid.Fid.Unique);
 680 #endif
 681             code = ENOENT;
 682         }
 683         goto done;
 684     }
 685
 686     code = afs_EvalFakeStat(&vcp, &fakestate, &treq);
 687     if (code)
 688         goto done;
 689
 690     if (vcp->fid.Cell != data.fid.Cell ||
 691         vcp->fid.Fid.Volume != data.fid.Fid.Volume) {
 692         /* parent is not the expected cell and volume; thus it
 693          * cannot possibly contain the fid we are looking for */
 694 #ifdef OSI_EXPORT_DEBUG
 695         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): wrong parent 0x%08x/%d\n",
 696                parent->d_name.name ? (char *)parent->d_name.name : "?",
 697                data.fid.Cell,      data.fid.Fid.Volume,
 698                data.fid.Fid.Vnode, data.fid.Fid.Unique,
 699                vcp->fid.Cell,      vcp->fid.Fid.Volume);
 700 #endif
 701         code = ENOENT;
 702         goto done;
 703     }
 704
 705
 706 redo:
 707     if (!(vcp->states & CStatd)) {
 708         if ((code = afs_VerifyVCache2(vcp, &treq))) {
 709 #ifdef OSI_EXPORT_DEBUG
 710             printk("afs: get_name(%s, 0x%08x/%d/%d.%d): VerifyVCache2(0x%08x/%d/%d.%d): %d\n",
 711                    parent->d_name.name ? (char *)parent->d_name.name : "?",
 712                    data.fid.Cell,      data.fid.Fid.Volume,
 713                    data.fid.Fid.Vnode, data.fid.Fid.Unique,
 714                    vcp->fid.Cell,      vcp->fid.Fid.Volume,
 715                    vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique, code);
 716 #endif
 717             goto done;
 718         }
 719     }
 720
 721     tdc = afs_GetDCache(vcp, (afs_size_t) 0, &treq, &dirOffset, &dirLen, 1);
 722     if (!tdc) {
 723 #ifdef OSI_EXPORT_DEBUG
 724         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): GetDCache(0x%08x/%d/%d.%d): %d\n",
 725                parent->d_name.name ? (char *)parent->d_name.name : "?",
 726                data.fid.Cell,      data.fid.Fid.Volume,
 727                data.fid.Fid.Vnode, data.fid.Fid.Unique,
 728                vcp->fid.Cell,      vcp->fid.Fid.Volume,
 729                vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique, code);
 730 #endif
 731         code = EIO;
 732         goto done;
 733     }
 734
 735     ObtainReadLock(&vcp->lock);
 736     ObtainReadLock(&tdc->lock);
 737
 738     /*
 739      * Make sure that the data in the cache is current. There are two
 740      * cases we need to worry about:
 741      * 1. The cache data is being fetched by another process.
 742      * 2. The cache data is no longer valid
 743      */
 744     while ((vcp->states & CStatd)
 745            && (tdc->dflags & DFFetching)
 746            && hsame(vcp->m.DataVersion, tdc->f.versionNo)) {
 747         ReleaseReadLock(&tdc->lock);
 748         ReleaseReadLock(&vcp->lock);
 749         afs_osi_Sleep(&tdc->validPos);
 750         ObtainReadLock(&vcp->lock);
 751         ObtainReadLock(&tdc->lock);
 752     }
 753     if (!(vcp->states & CStatd)
 754         || !hsame(vcp->m.DataVersion, tdc->f.versionNo)) {
 755         ReleaseReadLock(&tdc->lock);
 756         ReleaseReadLock(&vcp->lock);
 757         afs_PutDCache(tdc);
 758 #ifdef OSI_EXPORT_DEBUG
 759         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): dir (0x%08x/%d/%d.%d) changed; retrying\n",
 760                parent->d_name.name ? (char *)parent->d_name.name : "?",
 761                data.fid.Cell,      data.fid.Fid.Volume,
 762                data.fid.Fid.Vnode, data.fid.Fid.Unique,
 763                vcp->fid.Cell,      vcp->fid.Fid.Volume,
 764                vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique);
 765 #endif
 766         goto redo;
 767     }
 768
 769     data.name  = name;
 770     data.found = 0;
 771     code = afs_dir_EnumerateDir(tdc, get_name_hook, &data);
 772     if (!code && !data.found) {
 773 #ifdef OSI_EXPORT_DEBUG
 774         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): not found\n",
 775                parent->d_name.name ? (char *)parent->d_name.name : "?",
 776                data.fid.Cell,      data.fid.Fid.Volume,
 777                data.fid.Fid.Vnode, data.fid.Fid.Unique);
 778 #endif
 779         code = ENOENT;
 780     } else if (code) {
 781 #ifdef OSI_EXPORT_DEBUG
 782         printk("afs: get_name(%s, 0x%08x/%d/%d.%d): Enumeratedir(0x%08x/%d/%d.%d): %d\n",
 783                parent->d_name.name ? (char *)parent->d_name.name : "?",
 784                data.fid.Cell,      data.fid.Fid.Volume,
 785                data.fid.Fid.Vnode, data.fid.Fid.Unique,
 786                vcp->fid.Cell,      vcp->fid.Fid.Volume,
 787                vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique, code);
 788 #endif
 789     }
 790
 791     ReleaseReadLock(&tdc->lock);
 792     ReleaseReadLock(&vcp->lock);
 793     afs_PutDCache(tdc);
 794
 795 done:
 796     if (!code) {
 797         printk("afs: get_name(%s, 0x%08x/%d/%d.%d) => %s\n",
 798                parent->d_name.name ? (char *)parent->d_name.name : "?",
 799                data.fid.Cell,      data.fid.Fid.Volume,
 800                data.fid.Fid.Vnode, data.fid.Fid.Unique, name);
 801     }
 802     afs_PutFakeStat(&fakestate);
 803     AFS_GUNLOCK();
 804     unlock_kernel();
 805     crfree(credp);
 806     code = afs_CheckCode(code, &treq, 102);
 807     return -code;
 808 }
 809
 810
 811 static struct dentry *afs_export_get_parent(struct dentry *child)
 812 {
 813     struct VenusFid tfid;
 814     struct vrequest treq;
 815     struct cell *tcell;
 816     struct vcache *vcp;
 817     struct dentry *dp = NULL;
 818     cred_t *credp;
 819     afs_uint32 cellidx;
 820     int code;
 821
 822     if (!child->d_inode) {
 823         /* can't find the parent of a negative dentry */
 824 #ifdef OSI_EXPORT_DEBUG
 825         printk("afs: get_parent(%s): no inode\n",
 826                child->d_name.name ? (char *)child->d_name.name : "?");
 827 #endif
 828         return ERR_PTR(-EIO);
 829     }
 830
 831     credp = crref();
 832     lock_kernel();
 833     AFS_GLOCK();
 834
 835     vcp = VTOAFS(child->d_inode);
 836
 837     if (afs_IsDynrootMount(vcp)) {
 838         /* the dynmount directory; parent is always the AFS root */
 839         tfid = afs_globalVp->fid;
 840
 841     } else if (afs_IsDynrootAny(vcp) &&
 842                VNUM_TO_VNTYPE(vcp->fid.Fid.Vnode) == VN_TYPE_MOUNT) {
 843         /* a mount point in the dynmount directory */
 844         afs_GetDynrootMountFid(&tfid);
 845
 846     } else if (vcp->mvstat == 2) {
 847         /* volume root */
 848         ObtainReadLock(&vcp->lock);
 849         if (vcp->mvid && vcp->mvid->Fid.Volume) {
 850             tfid = *vcp->mvid;
 851             ReleaseReadLock(&vcp->lock);
 852         } else {
 853             ReleaseReadLock(&vcp->lock);
 854             tcell = afs_GetCell(vcp->fid.Cell, READ_LOCK);
 855             if (!tcell) {
 856 #ifdef OSI_EXPORT_DEBUG
 857                 printk("afs: get_parent(0x%08x/%d/%d.%d): no cell\n",
 858                        vcp->fid.Cell, vcp->fid.Fid.Volume,
 859                        vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique);
 860 #endif
 861                 dp = ERR_PTR(-ENOENT);
 862                 goto done;
 863             }
 864
 865             cellidx = tcell->cellIndex;
 866             afs_PutCell(tcell, READ_LOCK);
 867
 868             afs_GetDynrootMountFid(&tfid);
 869             tfid.Fid.Vnode = VNUM_FROM_TYPEID(VN_TYPE_MOUNT, cellidx << 2);
 870             tfid.Fid.Unique = vcp->fid.Fid.Volume;
 871         }
 872
 873     } else {
 874         /* any other vnode */
 875         if (vType(vcp) == VDIR && !vcp->parentVnode && vcp->mvstat != 1) {
 876             code = afs_InitReq(&treq, credp);
 877             if (code) {
 878 #ifdef OSI_EXPORT_DEBUG
 879                 printk("afs: get_parent(0x%08x/%d/%d.%d): InitReq: %d\n",
 880                        vcp->fid.Cell, vcp->fid.Fid.Volume,
 881                        vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique, code);
 882 #endif
 883                 dp = ERR_PTR(-ENOENT);
 884                 goto done;
 885             } else {
 886                 code = update_dir_parent(&treq, vcp);
 887                 if (code) {
 888 #ifdef OSI_EXPORT_DEBUG
 889                     printk("afs: get_parent(0x%08x/%d/%d.%d): update_dir_parent: %d\n",
 890                            vcp->fid.Cell, vcp->fid.Fid.Volume,
 891                            vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique, code);
 892 #endif
 893                     dp = ERR_PTR(-ENOENT);
 894                     goto done;
 895                 }
 896             }
 897         }
 898
 899         tfid.Cell       = vcp->fid.Cell;
 900         tfid.Fid.Volume = vcp->fid.Fid.Volume;
 901         tfid.Fid.Vnode  = vcp->parentVnode;
 902         tfid.Fid.Unique = vcp->parentUnique;
 903     }
 904
 905 #ifdef OSI_EXPORT_DEBUG
 906     printk("afs: get_parent(0x%08x/%d/%d.%d): => 0x%08x/%d/%d.%d\n",
 907            vcp->fid.Cell, vcp->fid.Fid.Volume,
 908            vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique,
 909            tfid.Cell, tfid.Fid.Volume, tfid.Fid.Vnode, tfid.Fid.Unique);
 910 #endif
 911
 912     dp = get_dentry_from_fid(credp, &tfid);
 913     if (!dp) {
 914 #ifdef OSI_EXPORT_DEBUG
 915         printk("afs: get_parent(0x%08x/%d/%d.%d): no dentry\n",
 916                vcp->fid.Cell, vcp->fid.Fid.Volume,
 917                vcp->fid.Fid.Vnode, vcp->fid.Fid.Unique);
 918 #endif
 919         dp = ERR_PTR(-ENOENT);
 920     }
 921
 922 done:
 923     AFS_GUNLOCK();
 924     unlock_kernel();
 925     crfree(credp);
 926
 927     return dp;
 928 }
 929
 930
 931 struct export_operations afs_export_ops = {
 932     .encode_fh  = afs_encode_fh,
 933     .decode_fh  = afs_decode_fh,
 934     .get_dentry = afs_export_get_dentry,
 935     .get_name   = afs_export_get_name,
 936     .get_parent = afs_export_get_parent,
 937 };