src/afs/afs_disconnected.c

   1 /*
   2  * This software has been released under the terms of the IBM Public
   3  * License.  For details, see the LICENSE file in the top-level source
   4  * directory or online at http://www.openafs.org/dl/license10.html
   5  */
   6
   7 #include <afsconfig.h>
   8 #include "afs/param.h"
   9
  10 RCSID("$Header$");
  11
  12 #include "afs/sysincludes.h"
  13 #include "afsincludes.h"
  14 #include "afs/afs_stats.h"      /* statistics */
  15 #include "afs/lock.h"
  16 #include "afs/afs_cbqueue.h"
  17
  18 #ifdef AFS_DISCON_ENV
  19
  20 #define dv_match(vc, fstat)                              \
  21         ((vc->m.DataVersion.low == fstat.DataVersion) && \
  22         (vc->m.DataVersion.high == fstat.dataVersionHigh))
  23
  24 /*! Global list of dirty vcaches. */
  25 /*! Last added element. */
  26 struct vcache *afs_DDirtyVCList = NULL;
  27 /*! Head of list. */
  28 struct vcache *afs_DDirtyVCListStart = NULL;
  29 /*! Previous element in the list. */
  30 struct vcache *afs_DDirtyVCListPrev = NULL;
  31
  32 /*! Locks list of dirty vcaches. */
  33 afs_rwlock_t afs_DDirtyVCListLock;
  34
  35 extern afs_int32 *afs_dvhashTbl;        /*Data cache hash table */
  36 extern afs_int32 *afs_dchashTbl;        /*Data cache hash table */
  37 extern afs_int32 *afs_dvnextTbl;        /*Dcache hash table links */
  38 extern afs_int32 *afs_dcnextTbl;        /*Dcache hash table links */
  39 extern struct dcache **afs_indexTable;  /*Pointers to dcache entries */
  40
  41 /*! Vnode number. On file creation, use the current
  42  *  value and increment it.
  43  */
  44 afs_uint32 afs_DisconVnode = 2;
  45
  46 /*! Conflict policy. */
  47 enum {
  48         CLIENT_WINS = 0,
  49         SERVER_WINS,
  50         LAST_CLOSER_WINS,
  51         ASK
  52 };
  53
  54 afs_int32 afs_ConflictPolicy = SERVER_WINS;
  55
  56 /*!
  57  * Find the first dcache of a file that has the specified fid.
  58  * Similar to afs_FindDCache, only that it takes a fid instead
  59  * of a vcache and it can get the first dcache.
  60  *
  61  * \param afid
  62  *
  63  * \return The found dcache or NULL.
  64  */
  65 struct dcache *afs_FindDCacheByFid(register struct VenusFid *afid)
  66 {
  67     register afs_int32 i, index;
  68     register struct dcache *tdc = NULL;
  69
  70     i = DVHash(afid);
  71     ObtainWriteLock(&afs_xdcache, 758);
  72     for (index = afs_dvhashTbl[i]; index != NULLIDX;) {
  73         if (afs_indexUnique[index] == afid->Fid.Unique) {
  74             tdc = afs_GetDSlot(index, NULL);
  75             ReleaseReadLock(&tdc->tlock);
  76             if (!FidCmp(&tdc->f.fid, afid)) {
  77                 break;          /* leaving refCount high for caller */
  78             }
  79             afs_PutDCache(tdc);
  80         }
  81         index = afs_dvnextTbl[index];
  82     }
  83     ReleaseWriteLock(&afs_xdcache);
  84
  85     if (index == NULLIDX)
  86         tdc = NULL;
  87     return tdc;
  88 }
  89
  90 /*!
  91  * Generate a store status from a dirty vcache entry.
  92  *
  93  * \param avc Dirty vcache entry.
  94  * \param astat
  95  *
  96  * \note The vnode must be share locked. It is called only on resync,
  97  * where the vnode is write locked locally and and the server.
  98  *
  99  * \return Mask of operations.
 100  */
 101 int afs_GenStoreStatus(struct vcache *avc, struct AFSStoreStatus *astat)
 102 {
 103     if (!avc || !astat || !avc->ddirty_flags)
 104         return 0;
 105
 106     /* Clean up store stat. */
 107     memset(astat, 0, sizeof(struct AFSStoreStatus));
 108
 109     if (avc->ddirty_flags & VDisconSetTime) {
 110         /* Update timestamp. */
 111         astat->ClientModTime = avc->m.Date;
 112         astat->Mask |= AFS_SETMODTIME;
 113     }
 114
 115     if (avc->ddirty_flags & VDisconSetMode) {
 116         /* Copy the mode bits. */
 117         astat->UnixModeBits = avc->m.Mode;
 118         astat->Mask |= AFS_SETMODE;
 119    }
 120
 121    /* XXX: more to come... ?*/
 122
 123    return astat->Mask;
 124 }
 125
 126 /*!
 127  * Hook for filtering the local dir fid by searching the "." entry.
 128  *
 129  * \param hdata The fid to be filled.
 130  */
 131 int get_parent_dir_fid_hook(void *hdata,
 132                                 char *aname,
 133                                 afs_int32 vnode,
 134                                 afs_int32 unique)
 135 {
 136     struct VenusFid *tfid = (struct VenusFid *) hdata;
 137
 138     if ((aname[0] == '.') && (aname[1] == '.') && !aname[2]) {
 139         tfid->Fid.Vnode = vnode;
 140         tfid->Fid.Unique = unique;
 141         return 1;
 142     }
 143
 144     return 0;
 145 }
 146
 147 /*!
 148  * Get a the dir's fid by looking in the vcache for simple files and
 149  * in the ".." entry for directories.
 150  *
 151  * \param avc The file's vhash entry.
 152  * \param afid Put the fid here.
 153  */
 154 int afs_GetParentDirFid(struct vcache *avc, struct VenusFid *afid)
 155 {
 156     struct dcache *tdc;
 157
 158     afid->Cell = avc->fid.Cell;
 159     afid->Fid.Volume = avc->fid.Fid.Volume;
 160
 161     if (vType(avc) == VREG) {
 162         /* Normal files have the dir fid embedded in the vcache. */
 163         afid->Fid.Vnode = avc->parentVnode;
 164         afid->Fid.Unique = avc->parentUnique;
 165
 166     } else if (vType(avc) == VDIR) {
 167         /* If dir or parent dir created locally*/
 168         tdc = afs_FindDCacheByFid(&avc->fid);
 169         if (tdc) {
 170             /* Lookup each entry for the fid. It should be the first. */
 171             afs_dir_EnumerateDir(tdc, &get_parent_dir_fid_hook, afid);
 172             afs_PutDCache(tdc);
 173         }
 174     }
 175
 176     return 0;
 177 }
 178
 179 struct NameAndFid {
 180     struct VenusFid *fid;
 181     char *name;
 182     int name_len;
 183 };
 184
 185 /*!
 186  * Hook that searches a certain fid's name.
 187  *
 188  * \param hdata NameAndFid structure containin a pointer to a fid
 189  * and an allocate name. The name will be filled when hit.
 190  */
 191 int get_vnode_name_hook(void *hdata,
 192                                 char *aname,
 193                                 afs_int32 vnode,
 194                                 afs_int32 unique)
 195 {
 196     struct NameAndFid *nf = (struct NameAndFid *) hdata;
 197
 198     if ((nf->fid->Fid.Vnode == vnode) &&
 199         (nf->fid->Fid.Unique == unique)) {
 200         nf->name_len = strlen(aname);
 201         memcpy(nf->name, aname, nf->name_len);
 202         nf->name[nf->name_len] = 0;
 203
 204         return 1;
 205     }
 206
 207     return 0;
 208 }
 209
 210 /*!
 211  * Try to get a vnode's name by comparing all parent dir's entries
 212  * to the given fid. It can also return the dir's dcache.
 213  *
 214  * \param avc The file's vcache.
 215  * \param afid The parent dir's fid.
 216  * \param aname A preallocated string for the name.
 217  * \param deleted Has this file been deleted? If yes, use the shadow
 218  * dir for looking up the name.
 219  */
 220 int afs_GetVnodeName(struct vcache *avc,
 221                         struct VenusFid *afid,
 222                         char *aname,
 223                         int deleted)
 224 {
 225     int code = 0;
 226     struct dcache *tdc;
 227     struct vcache *parent_vc;
 228     struct NameAndFid tnf;
 229     struct VenusFid parent_fid;
 230     struct VenusFid shadow_fid;
 231
 232     /* List dir contents and get it's tdc. */
 233     if (deleted) {
 234         /* For deleted files, get the shadow dir's tdc: */
 235
 236         /* Get the parent dir's vcache that contains the shadow fid. */
 237         parent_fid.Cell = avc->fid.Cell;
 238         parent_fid.Fid.Volume = avc->fid.Fid.Volume;
 239         if (avc->ddirty_flags & VDisconRename) {
 240             /* For renames the old dir fid is needed. */
 241             parent_fid.Fid.Vnode = avc->oldVnode;
 242             parent_fid.Fid.Unique = avc->oldUnique;
 243         } else {
 244             parent_fid.Fid.Vnode = afid->Fid.Vnode;
 245             parent_fid.Fid.Unique = afid->Fid.Unique;
 246         }
 247
 248         /* Get the parent dir's vcache that contains the shadow fid. */
 249         ObtainSharedLock(&afs_xvcache, 755);
 250         parent_vc = afs_FindVCache(&parent_fid, 0, 1);
 251         ReleaseSharedLock(&afs_xvcache);
 252         if (!parent_vc) {
 253             return ENOENT;
 254         }
 255
 256         shadow_fid.Cell = parent_vc->fid.Cell;
 257         shadow_fid.Fid.Volume = parent_vc->fid.Fid.Volume;
 258         shadow_fid.Fid.Vnode = parent_vc->shVnode;
 259         shadow_fid.Fid.Unique = parent_vc->shUnique;
 260
 261         afs_PutVCache(parent_vc);
 262
 263         /* Get shadow dir's dcache. */
 264         tdc = afs_FindDCacheByFid(&shadow_fid);
 265
 266     } else {
 267
 268         /* For normal files, look into the current dir's entry. */
 269         tdc = afs_FindDCacheByFid(afid);
 270     }                   /* if (deleted) */
 271
 272     if (tdc) {
 273         tnf.fid = &avc->fid;
 274         tnf.name_len = 0;
 275         tnf.name = aname;
 276         afs_dir_EnumerateDir(tdc, &get_vnode_name_hook, &tnf);
 277         afs_PutDCache(tdc);
 278     } else {
 279         code = ENOENT;
 280     }
 281
 282     return code;
 283 }
 284
 285 struct DirtyChildrenCount {
 286     struct vcache *vc;
 287     afs_uint32 count;
 288 };
 289
 290 /*!
 291  * Lookup dirty deleted vnodes in this dir.
 292  */
 293 int chk_del_children_hook(void *hdata,
 294                                 char *aname,
 295                                 afs_int32 vnode,
 296                                 afs_int32 unique)
 297 {
 298     struct VenusFid tfid;
 299     struct DirtyChildrenCount *v = (struct DirtyChildrenCount *) hdata;
 300     struct vcache *tvc;
 301
 302     if ((aname[0] == '.') && !aname[1])
 303         /* Skip processing this dir again.
 304          * It would result in an endless loop.
 305          */
 306         return 0;
 307
 308     if ((aname[0] == '.') && (aname[1] == '.') && !aname[2])
 309         /* Don't process parent dir. */
 310         return 0;
 311
 312     /* Get this file's vcache. */
 313     tfid.Cell = v->vc->fid.Cell;
 314     tfid.Fid.Volume = v->vc->fid.Fid.Volume;
 315     tfid.Fid.Vnode = vnode;
 316     tfid.Fid.Unique = unique;
 317
 318     ObtainSharedLock(&afs_xvcache, 757);
 319     tvc = afs_FindVCache(&tfid, 0, 1);
 320     ReleaseSharedLock(&afs_xvcache);
 321
 322     /* Count unfinished dirty children. VDisconShadowed can still be set,
 323      * because we need it to remove the shadow dir.
 324      */
 325     if (tvc) {
 326         if (tvc->ddirty_flags)
 327             v->count++;
 328
 329         afs_PutVCache(tvc);
 330     }
 331
 332     return 0;
 333 }
 334
 335 /*!
 336  * Check if entries have been deleted in a vnode's shadow
 337  * dir.
 338  *
 339  * \return Returns the number of dirty children.
 340  *
 341  * \note afs_DDirtyVCListLock must be write locked.
 342  */
 343 int afs_CheckDeletedChildren(struct vcache *avc)
 344 {
 345     struct dcache *tdc;
 346     struct DirtyChildrenCount dcc;
 347     struct VenusFid shadow_fid;
 348
 349     if (!(avc->ddirty_flags & VDisconShadowed))
 350         /* Empty dir. */
 351         return 0;
 352
 353     shadow_fid.Cell = avc->fid.Cell;
 354     shadow_fid.Fid.Volume = avc->fid.Fid.Volume;
 355     shadow_fid.Fid.Vnode = avc->shVnode;
 356     shadow_fid.Fid.Unique = avc->shUnique;
 357
 358     dcc.count = 0;
 359
 360     /* Get shadow dir's dcache. */
 361     tdc = afs_FindDCacheByFid(&shadow_fid);
 362     if (tdc) {
 363         dcc.vc = avc;
 364         afs_dir_EnumerateDir(tdc, &chk_del_children_hook, &dcc);
 365         afs_PutDCache(tdc);
 366     }
 367
 368     return dcc.count;
 369 }
 370
 371 /*!
 372  * Changes a file's parent fid references.
 373  */
 374 int fix_children_fids_hook(void *hdata,
 375                                 char *aname,
 376                                 afs_int32 vnode,
 377                                 afs_int32 unique)
 378 {
 379     struct VenusFid tfid;
 380     struct VenusFid *afid = (struct VenusFid *) hdata;
 381     struct vcache *tvc;
 382     struct dcache *tdc = NULL;
 383
 384     if ((aname[0] == '.') && !aname[1])
 385         return 0;
 386
 387     if ((aname[0] == '.') && (aname[1] == '.') && !aname[2])
 388         return 0;
 389
 390     tfid.Cell = afid->Cell;
 391     tfid.Fid.Volume = afid->Fid.Volume;
 392     tfid.Fid.Vnode = vnode;
 393     tfid.Fid.Unique = unique;
 394
 395     if (!(vnode % 2)) {
 396         /* vnode's parity indicates that it's a file. */
 397
 398         /* Get the vcache. */
 399         ObtainSharedLock(&afs_xvcache, 759);
 400         tvc = afs_FindVCache(&tfid, 0, 1);
 401         ReleaseSharedLock(&afs_xvcache);
 402
 403         /* Change the fields. */
 404         if (tvc) {
 405             tvc->parentVnode = afid->Fid.Vnode;
 406             tvc->parentUnique = afid->Fid.Unique;
 407
 408             afs_PutVCache(tvc);
 409         }
 410     } else {
 411         /* It's a dir. Fix this dir's .. entry to contain the new fid. */
 412         /* Seek the dir's dcache. */
 413         tdc = afs_FindDCacheByFid(&tfid);
 414         if (tdc) {
 415             /* Change the .. entry fid. */
 416             afs_dir_ChangeFid(tdc, "..", NULL, &afid->Fid.Vnode);
 417             afs_PutDCache(tdc);
 418         }
 419     }                   /* if (!(vnode % 2))*/
 420
 421     return 0;
 422 }
 423
 424 /*!
 425  * Fixes the parentVnode and parentUnique fields of all
 426  * files (not dirs) contained in the directory pointed by
 427  * old_fid. This is useful on resync, when a locally created dir
 428  * get's a new fid and all the children references must be updated
 429  * to reflect the new fid.
 430  *
 431  * \note The dir's fid hasn't been changed yet, it is still referenced
 432  * with the old fid.
 433  *
 434  * \param old_fid The current dir's fid.
 435  * \param new_fid The new dir's fid.
 436  */
 437 void afs_FixChildrenFids(struct VenusFid *old_fid, struct VenusFid *new_fid)
 438 {
 439     struct dcache *tdc;
 440
 441     /* Get shadow dir's dcache. */
 442     tdc = afs_FindDCacheByFid(old_fid);
 443     /* Change the fids. */
 444     if (tdc) {
 445         afs_dir_EnumerateDir(tdc, &fix_children_fids_hook, new_fid);
 446         afs_PutDCache(tdc);
 447     }
 448 }
 449
 450 int list_dir_hook(void *hdata, char *aname, afs_int32 vnode, afs_int32 unique)
 451 {
 452     printf("list_dir_hook: %s v:%u u:%u\n", aname, vnode, unique);
 453     return 0;
 454 }
 455
 456 void afs_DbgListDirEntries(struct VenusFid *afid)
 457 {
 458     struct dcache *tdc;
 459
 460     /* Get shadow dir's dcache. */
 461     tdc = afs_FindDCacheByFid(afid);
 462     if (tdc) {
 463         afs_dir_EnumerateDir(tdc, &list_dir_hook, NULL);
 464         afs_PutDCache(tdc);
 465     }
 466 }
 467
 468 /*!
 469  * Handles file renaming on reconnection:
 470  * - Get the old name from the old dir's shadow dir.
 471  * - Get the new name from the current dir.
 472  * - Old dir fid and new dir fid are collected along the way.
 473  * */
 474 int afs_ProcessOpRename(struct vcache *avc, struct vrequest *areq)
 475 {
 476     struct VenusFid old_pdir_fid, new_pdir_fid;
 477     char *old_name, *new_name;
 478     struct AFSFetchStatus OutOldDirStatus, OutNewDirStatus;
 479     struct AFSVolSync tsync;
 480     struct conn *tc;
 481     afs_uint32 code = 0;
 482     XSTATS_DECLS;
 483
 484     /* Get old dir vcache. */
 485     old_pdir_fid.Cell = avc->fid.Cell;
 486     old_pdir_fid.Fid.Volume = avc->fid.Fid.Volume;
 487     old_pdir_fid.Fid.Vnode = avc->oldVnode;
 488     old_pdir_fid.Fid.Unique = avc->oldUnique;
 489
 490     /* Get old name. */
 491     old_name = (char *) afs_osi_Alloc(AFSNAMEMAX);
 492     if (!old_name) {
 493         printf("afs_ProcessOpRename: Couldn't alloc space for old name.\n");
 494         return ENOMEM;
 495     }
 496     code = afs_GetVnodeName(avc, &old_pdir_fid, old_name, 1);
 497     if (code) {
 498         printf("afs_ProcessOpRename: Couldn't find old name.\n");
 499         code = ENOENT;
 500         goto end2;
 501     }
 502
 503     /* Alloc data first. */
 504     new_name = (char *) afs_osi_Alloc(AFSNAMEMAX);
 505     if (!new_name) {
 506         printf("afs_ProcessOpRename: Couldn't alloc space for new name.\n");
 507         code = ENOMEM;
 508         goto end2;
 509     }
 510
 511     if (avc->ddirty_flags & VDisconRenameSameDir) {
 512         /* If we're in the same dir, don't do the lookups all over again,
 513          * just copy fid and vcache from the old dir.
 514          */
 515         memcpy(&new_pdir_fid, &old_pdir_fid, sizeof(struct VenusFid));
 516     } else {
 517         /* Get parent dir's FID.*/
 518         new_pdir_fid.Fid.Unique = 0;
 519         afs_GetParentDirFid(avc, &new_pdir_fid);
 520         if (!new_pdir_fid.Fid.Unique) {
 521             printf("afs_ProcessOpRename: Couldn't find new parent dir FID.\n");
 522             code = ENOENT;
 523             goto end1;
 524         }
 525     }
 526
 527     /* And finally get the new name. */
 528     code = afs_GetVnodeName(avc, &new_pdir_fid, new_name, 0);
 529     if (code) {
 530         printf("afs_ProcessOpRename: Couldn't find new name.\n");
 531         code = ENOENT;
 532         goto end1;
 533     }
 534
 535     /* Send to data to server. */
 536     do {
 537         tc = afs_Conn(&old_pdir_fid, areq, SHARED_LOCK);
 538         if (tc) {
 539             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RENAME);
 540             RX_AFS_GUNLOCK();
 541             code = RXAFS_Rename(tc->id,
 542                 (struct AFSFid *)&old_pdir_fid.Fid,
 543                 old_name,
 544                 (struct AFSFid *)&new_pdir_fid.Fid,
 545                 new_name,
 546                 &OutOldDirStatus,
 547                 &OutNewDirStatus,
 548                 &tsync);
 549             RX_AFS_GLOCK();
 550             XSTATS_END_TIME;
 551         } else
 552             code = -1;
 553
 554     } while (afs_Analyze(tc,
 555                 code,
 556                 &new_pdir_fid,
 557                 areq,
 558                 AFS_STATS_FS_RPCIDX_RENAME,
 559                 SHARED_LOCK,
 560                 NULL));
 561
 562     if (code)
 563         printf("afs_ProcessOpRename: server code=%u\n", code);
 564 end1:
 565     afs_osi_Free(new_name, AFSNAMEMAX);
 566 end2:
 567     afs_osi_Free(old_name, AFSNAMEMAX);
 568     return code;
 569 }
 570
 571 /*!
 572  * Handles all the reconnection details:
 573  * - Get all the details about the vnode: name, fid, and parent dir fid.
 574  * - Send data to server.
 575  * - Handle errors.
 576  * - Reorder vhash and dcaches in their hashes, using the newly acquired fid.
 577  */
 578 int afs_ProcessOpCreate(struct vcache *avc,
 579                                 struct vrequest *areq,
 580                                 struct AFS_UCRED *acred)
 581 {
 582     char *tname = NULL;
 583     struct AFSStoreStatus InStatus;
 584     struct AFSFetchStatus OutFidStatus, OutDirStatus;
 585     struct VenusFid pdir_fid, newFid;
 586     struct server *hostp = NULL;
 587     struct AFSCallBack CallBack;
 588     struct AFSVolSync tsync;
 589     struct vcache *tdp = NULL, *tvc = NULL;
 590     struct dcache *tdc = NULL;
 591     struct conn *tc;
 592     afs_int32 now, hash, new_hash, index;
 593     int code = 0;
 594     XSTATS_DECLS;
 595
 596     /* Get parent dir's FID. */
 597     pdir_fid.Fid.Unique = 0;
 598     afs_GetParentDirFid(avc, &pdir_fid);
 599     if (!pdir_fid.Fid.Unique) {
 600         printf("afs_ProcessOpCreate: Couldn't find parent dir'sFID.\n");
 601         return ENOENT;
 602     }
 603
 604     tname = afs_osi_Alloc(AFSNAMEMAX);
 605     if (!tname) {
 606         printf("afs_ProcessOpCreate: Couldn't find file name\n");
 607         return ENOMEM;
 608     }
 609
 610     /* Get vnode's name. */
 611     code = afs_GetVnodeName(avc, &pdir_fid, tname, 0);
 612     if (code) {
 613         printf("afs_ProcessOpCreate: Couldn't find file name\n");
 614         code = ENOENT;
 615         goto end;
 616     }
 617
 618     /* Get parent dir vcache. */
 619     ObtainSharedLock(&afs_xvcache, 760);
 620     tdp = afs_FindVCache(&pdir_fid, 0, 1);
 621     ReleaseSharedLock(&afs_xvcache);
 622     if (!tdp) {
 623         printf("afs_ProcessOpCreate: Couldn't find parent dir's vcache\n");
 624         code = ENOENT;
 625         goto end;
 626     }
 627
 628     if (tdp->ddirty_flags & VDisconCreate) {
 629         /* If the parent dir has been created locally, defer
 630          * this vnode for later by moving it to the end.
 631          */
 632         afs_DDirtyVCList->ddirty_next = avc;
 633         afs_DDirtyVCList = avc;
 634         printf("afs_ProcessOpRemove: deferring this vcache\n");
 635         code = ENOTEMPTY;
 636         goto end;
 637     }
 638
 639     /* Set status. */
 640     InStatus.Mask = AFS_SETMODTIME | AFS_SETMODE | AFS_SETGROUP;
 641     InStatus.ClientModTime = avc->m.Date;
 642     InStatus.Owner = avc->m.Owner;
 643     InStatus.Group = (afs_int32) acred->cr_gid;
 644     /* Only care about protection bits. */
 645     InStatus.UnixModeBits = avc->m.Mode & 0xffff;
 646
 647     /* Connect to server. */
 648     if (vType(avc) == VREG) {
 649         /* Make file on server. */
 650         do {
 651             tc = afs_Conn(&tdp->fid, areq, SHARED_LOCK);
 652             if (tc) {
 653                 /* Remember for callback processing. */
 654                 hostp = tc->srvr->server;
 655                 now = osi_Time();
 656                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_CREATEFILE);
 657                 RX_AFS_GUNLOCK();
 658                 code = RXAFS_CreateFile(tc->id,
 659                                 (struct AFSFid *)&tdp->fid.Fid,
 660                                 tname,
 661                                 &InStatus,
 662                                 (struct AFSFid *) &newFid.Fid,
 663                                 &OutFidStatus,
 664                                 &OutDirStatus,
 665                                 &CallBack,
 666                                 &tsync);
 667                 RX_AFS_GLOCK();
 668                 XSTATS_END_TIME;
 669                 CallBack.ExpirationTime += now;
 670             } else
 671                 code = -1;
 672         } while (afs_Analyze(tc,
 673                         code,
 674                         &tdp->fid,
 675                         areq,
 676                         AFS_STATS_FS_RPCIDX_CREATEFILE,
 677                         SHARED_LOCK,
 678                         NULL));
 679
 680     } else if (vType(avc) == VDIR) {
 681         /* Make dir on server. */
 682         do {
 683             tc = afs_Conn(&tdp->fid, areq, SHARED_LOCK);
 684             if (tc) {
 685                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_MAKEDIR);
 686                 now = osi_Time();
 687                 RX_AFS_GUNLOCK();
 688                 code = RXAFS_MakeDir(tc->id,
 689                                 (struct AFSFid *) &tdp->fid.Fid,
 690                                 tname,
 691                                 &InStatus,
 692                                 (struct AFSFid *) &newFid.Fid,
 693                                 &OutFidStatus,
 694                                 &OutDirStatus,
 695                                 &CallBack,
 696                                 &tsync);
 697                 RX_AFS_GLOCK();
 698                 XSTATS_END_TIME;
 699                 CallBack.ExpirationTime += now;
 700                 /* DON'T forget to set the callback at some point. */
 701             } else
 702                code = -1;
 703          } while (afs_Analyze(tc,
 704                         code,
 705                         &tdp->fid,
 706                         areq,
 707                         AFS_STATS_FS_RPCIDX_MAKEDIR,
 708                         SHARED_LOCK,
 709                         NULL));
 710     }                                   /* Do server changes. */
 711
 712     /* TODO: Handle errors. */
 713     if (code) {
 714         printf("afs_ProcessOpCreate: error while creating vnode on server, code=%d .\n", code);
 715         code = EIO;
 716         goto end;
 717     }
 718
 719     /* The rpc doesn't set the cell number. */
 720     newFid.Cell = avc->fid.Cell;
 721
 722     /*
 723      * Change the fid in the dir entry.
 724      */
 725
 726     /* Seek the dir's dcache. */
 727     tdc = afs_FindDCacheByFid(&tdp->fid);
 728     if (tdc) {
 729         /* And now change the fid in the parent dir entry. */
 730         afs_dir_ChangeFid(tdc, tname, &avc->fid.Fid.Vnode, &newFid.Fid.Vnode);
 731         afs_PutDCache(tdc);
 732     }
 733
 734     if (vType(avc) == VDIR) {
 735         /* Change fid in the dir for the "." entry. ".." has alredy been
 736          * handled by afs_FixChildrenFids when processing the parent dir.
 737          */
 738         tdc = afs_FindDCacheByFid(&avc->fid);
 739         if (tdc) {
 740             afs_dir_ChangeFid(tdc, ".", &avc->fid.Fid.Vnode, &newFid.Fid.Vnode);
 741
 742             if (avc->m.LinkCount >= 2)
 743                 /* For non empty dirs, fix children's parentVnode and parentUnique
 744                  * reference.
 745                  */
 746                 afs_FixChildrenFids(&avc->fid, &newFid);
 747
 748             afs_PutDCache(tdc);
 749         }
 750     }
 751
 752     /* Recompute hash chain positions for vnode and dcaches.
 753      * Then change to the new FID.
 754      */
 755
 756     /* The vcache goes first. */
 757     ObtainWriteLock(&afs_xvcache, 735);
 758
 759     /* Old fid hash. */
 760     hash = VCHash(&avc->fid);
 761     /* New fid hash. */
 762     new_hash = VCHash(&newFid);
 763
 764     /* Remove hash from old position. */
 765     /* XXX: not checking array element contents. It shouldn't be empty.
 766      * If it oopses, then something else might be wrong.
 767      */
 768     if (afs_vhashT[hash] == avc) {
 769         /* First in hash chain (might be the only one). */
 770         afs_vhashT[hash] = avc->hnext;
 771     } else {
 772         /* More elements in hash chain. */
 773         //for (tvc = afs_vhashT[hash]; tdp; tdp = tdp->hnext) {
 774         for (tvc = afs_vhashT[hash]; tvc; tvc = tvc->hnext) {
 775             if (tvc->hnext == avc) {
 776                 tvc->hnext = avc->hnext;
 777                 break;
 778             }
 779         }
 780     }                           /* if (!afs_vhashT[i]->hnext) */
 781     QRemove(&afs_vhashTV[hash]);
 782
 783     /* Insert hash in new position. */
 784     avc->hnext = afs_vhashT[new_hash];
 785     afs_vhashT[new_hash] = avc;
 786     QAdd(&afs_vhashTV[new_hash], &avc->vhashq);
 787
 788     ReleaseWriteLock(&afs_xvcache);
 789
 790     /* Do the same thing for all dcaches. */
 791     hash = DVHash(&avc->fid);
 792     ObtainWriteLock(&afs_xdcache, 743);
 793     for (index = afs_dvhashTbl[hash]; index != NULLIDX; index = hash) {
 794         hash = afs_dvnextTbl[index];
 795         tdc = afs_GetDSlot(index, NULL);
 796         ReleaseReadLock(&tdc->tlock);
 797         if (afs_indexUnique[index] == avc->fid.Fid.Unique) {
 798             if (!FidCmp(&tdc->f.fid, &avc->fid)) {
 799
 800                 /* Safer but slower. */
 801                 afs_HashOutDCache(tdc, 0);
 802
 803                 /* Put dcache in new positions in the dchash and dvhash. */
 804                 new_hash = DCHash(&newFid, tdc->f.chunk);
 805                 afs_dcnextTbl[tdc->index] = afs_dchashTbl[new_hash];
 806                 afs_dchashTbl[new_hash] = tdc->index;
 807
 808                 new_hash = DVHash(&newFid);
 809                 afs_dvnextTbl[tdc->index] = afs_dvhashTbl[new_hash];
 810                 afs_dvhashTbl[new_hash] = tdc->index;
 811
 812                 afs_indexUnique[tdc->index] = newFid.Fid.Unique;
 813                 memcpy(&tdc->f.fid, &newFid, sizeof(struct VenusFid));
 814                 //afs_MaybeWakeupTruncateDaemon();
 815            }                   /* if fid match */
 816         }                       /* if uniquifier match */
 817         if (tdc)
 818             afs_PutDCache(tdc);
 819     }                           /* for all dcaches in this hash bucket */
 820     ReleaseWriteLock(&afs_xdcache);
 821
 822     /* Now we can set the new fid. */
 823     memcpy(&avc->fid, &newFid, sizeof(struct VenusFid));
 824
 825     if (tdp) {
 826         /* Unset parent dir CStat flag, so it will get refreshed on next
 827          * online stat.
 828          */
 829         ObtainWriteLock(&tdp->lock, 745);
 830         tdp->states &= ~CStatd;
 831         ReleaseWriteLock(&tdp->lock);
 832     }
 833 end:
 834     if (tdp)
 835         afs_PutVCache(tdp);
 836     afs_osi_Free(tname, AFSNAMEMAX);
 837     return code;
 838 }
 839
 840 /*!
 841  * Remove a vnode on the server, be it file or directory.
 842  * Not much to do here only get the parent dir's fid and call the
 843  * removel rpc.
 844  *
 845  * \param avc The deleted vcache
 846  * \param areq
 847  *
 848  * \note The vcache refcount should be dropped because it points to
 849  * a deleted vnode and has served it's purpouse, but we drop refcount
 850  * on shadow dir deletio (we still need it for that).
 851  *
 852  * \note avc must be write locked.
 853  */
 854 int afs_ProcessOpRemove(struct vcache *avc, struct vrequest *areq)
 855 {
 856     char *tname = NULL;
 857     struct AFSFetchStatus OutDirStatus;
 858     struct VenusFid pdir_fid;
 859     struct AFSVolSync tsync;
 860     struct conn *tc;
 861     struct vcache *tdp = NULL;
 862     int code = 0;
 863     XSTATS_DECLS;
 864
 865     /* Get parent dir's FID. */
 866     pdir_fid.Fid.Unique = 0;
 867     afs_GetParentDirFid(avc, &pdir_fid);
 868     if (!pdir_fid.Fid.Unique) {
 869         printf("afs_ProcessOpRemove: Couldn't find parent dir's FID.\n");
 870         return ENOENT;
 871     }
 872
 873     tname = afs_osi_Alloc(AFSNAMEMAX);
 874     if (!tname) {
 875         printf("afs_ProcessOpRemove: Couldn't find file name\n");
 876         return ENOMEM;
 877     }
 878
 879     /* Get file name. */
 880     code = afs_GetVnodeName(avc, &pdir_fid, tname, 1);
 881     if (code) {
 882         printf("afs_ProcessOpRemove: Couldn't find file name\n");
 883         code = ENOENT;
 884         goto end;
 885     }
 886
 887     if ((vType(avc) == VDIR) && (afs_CheckDeletedChildren(avc))) {
 888         /* Deleted children of this dir remain unsynchronized.
 889          * Defer this vcache.
 890          */
 891         afs_DDirtyVCList->ddirty_next = avc;
 892         afs_DDirtyVCList = avc;
 893         code = ENOTEMPTY;
 894         goto end;
 895     }
 896
 897     if (vType(avc) == VREG) {
 898         /* Remove file on server. */
 899         do {
 900             tc = afs_Conn(&pdir_fid, areq, SHARED_LOCK);
 901             if (tc) {
 902                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEFILE);
 903                 RX_AFS_GUNLOCK();
 904                 code = RXAFS_RemoveFile(tc->id,
 905                                 &pdir_fid.Fid,
 906                                 tname,
 907                                 &OutDirStatus,
 908                                 &tsync);
 909
 910                 RX_AFS_GLOCK();
 911                 XSTATS_END_TIME;
 912             } else
 913                 code = -1;
 914         } while (afs_Analyze(tc,
 915                         code,
 916                         &pdir_fid,
 917                         areq,
 918                         AFS_STATS_FS_RPCIDX_REMOVEFILE,
 919                         SHARED_LOCK,
 920                         NULL));
 921
 922     } else if (vType(avc) == VDIR) {
 923         /* Remove dir on server. */
 924         do {
 925             tc = afs_Conn(&pdir_fid, areq, SHARED_LOCK);
 926             if (tc) {
 927                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEDIR);
 928                 RX_AFS_GUNLOCK();
 929                 code = RXAFS_RemoveDir(tc->id,
 930                                 &pdir_fid.Fid,
 931                                 tname,
 932                                 &OutDirStatus,
 933                                 &tsync);
 934                 RX_AFS_GLOCK();
 935                 XSTATS_END_TIME;
 936            } else
 937                 code = -1;
 938         } while (afs_Analyze(tc,
 939                         code,
 940                         &pdir_fid,
 941                         areq,
 942                         AFS_STATS_FS_RPCIDX_REMOVEDIR,
 943                         SHARED_LOCK,
 944                         NULL));
 945
 946     }                           /* if (vType(avc) == VREG) */
 947
 948     if (code)
 949         printf("afs_ProcessOpRemove: server returned code=%u\n", code);
 950
 951     /* Remove the statd flag from parent dir's vcache. */
 952     ObtainSharedLock(&afs_xvcache, 761);
 953     tdp = afs_FindVCache(&pdir_fid, 0, 1);
 954     ReleaseSharedLock(&afs_xvcache);
 955     if (tdp) {
 956         ObtainWriteLock(&tdp->lock, 746);
 957         tdp->states &= ~CStatd;
 958         ReleaseWriteLock(&tdp->lock);
 959         afs_PutVCache(tdp);
 960     }
 961 end:
 962     afs_osi_Free(tname, AFSNAMEMAX);
 963     return code;
 964 }
 965
 966 /*!
 967  * Send disconnected file changes to the server.
 968  *
 969  * \note Call with vnode locked both locally and on the server.
 970  *
 971  * \param avc Vnode that gets synchronized to the server.
 972  * \param areq Used for obtaining a conn struct.
 973  *
 974  * \return 0 for success. On failure, other error codes.
 975  */
 976 int afs_SendChanges(struct vcache *avc, struct vrequest *areq)
 977 {
 978     struct conn *tc;
 979     struct AFSStoreStatus sstat;
 980     struct AFSFetchStatus fstat;
 981     struct AFSVolSync tsync;
 982     int code = 0;
 983     int flags = 0;
 984     XSTATS_DECLS;
 985
 986     /* Start multiplexing dirty operations from ddirty_flags field: */
 987     if (avc->ddirty_flags & VDisconSetAttrMask) {
 988         /* Setattr OPS: */
 989         /* Turn dirty vc data into a new store status... */
 990         if (afs_GenStoreStatus(avc, &sstat) > 0) {
 991             do {
 992                 tc = afs_Conn(&avc->fid, areq, SHARED_LOCK);
 993                 if (tc) {
 994                     /* ... and send it. */
 995                     XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STORESTATUS);
 996                     RX_AFS_GUNLOCK();
 997                     code = RXAFS_StoreStatus(tc->id,
 998                                 (struct AFSFid *) &avc->fid.Fid,
 999                                 &sstat,
1000                                 &fstat,
1001                                 &tsync);
1002
1003                     RX_AFS_GLOCK();
1004                     XSTATS_END_TIME;
1005                 } else
1006                     code = -1;
1007
1008         } while (afs_Analyze(tc,
1009                         code,
1010                         &avc->fid,
1011                         areq,
1012                         AFS_STATS_FS_RPCIDX_STORESTATUS,
1013                         SHARED_LOCK,
1014                         NULL));
1015
1016         }               /* if (afs_GenStoreStatus() > 0)*/
1017     }                   /* disconnected SETATTR */
1018
1019     if (code)
1020         return code;
1021
1022     if (avc->ddirty_flags &
1023         (VDisconTrunc
1024         | VDisconWriteClose
1025         | VDisconWriteFlush
1026         | VDisconWriteOsiFlush)) {
1027
1028         /* Truncate OP: */
1029         do {
1030             tc = afs_Conn(&avc->fid, areq, SHARED_LOCK);
1031             if (tc) {
1032                 /* Set storing flags. XXX: A tad inefficient ... */
1033                 if (avc->ddirty_flags & VDisconWriteClose)
1034                     flags |= AFS_LASTSTORE;
1035                 if (avc->ddirty_flags & VDisconWriteOsiFlush)
1036                     flags |= (AFS_SYNC | AFS_LASTSTORE);
1037                 if (avc->ddirty_flags & VDisconWriteFlush)
1038                     flags |= AFS_SYNC;
1039
1040                 /* Try to send store to server. */
1041                 /* XXX: AFS_LASTSTORE for writes? Or just AFS_SYNC for all? */
1042                 code = afs_StoreAllSegments(avc, areq, flags);
1043             } else
1044                 code = -1;
1045
1046         } while (afs_Analyze(tc,
1047                         code,
1048                         &avc->fid,
1049                         areq,
1050                         AFS_STATS_FS_RPCIDX_STOREDATA,
1051                         SHARED_LOCK,
1052                         NULL));
1053
1054     }                   /* disconnected TRUNC | WRITE */
1055
1056     return code;
1057 }
1058
1059 /*!
1060  * All files that have been dirty before disconnection are going to
1061  * be replayed back to the server.
1062  *
1063  * \param areq Request from the user.
1064  * \param acred User credentials.
1065  *
1066  * \return If all files synchronized succesfully, return 0, otherwise
1067  * return 1.
1068  *
1069  * \note For now, it's the request from the PDiscon pioctl.
1070  *
1071  */
1072 int afs_ResyncDisconFiles(struct vrequest *areq, struct AFS_UCRED *acred)
1073 {
1074     struct conn *tc;
1075     struct vcache *tvc, *tmp;
1076     struct AFSFetchStatus fstat;
1077     struct AFSCallBack callback;
1078     struct AFSVolSync tsync;
1079     struct vcache *shList, *shListStart;
1080     int code;
1081     int sync_failed = 0;
1082     int ret_code = 0;
1083     int defered = 0;
1084     afs_int32 start = 0;
1085     XSTATS_DECLS;
1086     //AFS_STATCNT(afs_ResyncDisconFiles);
1087
1088     shList = shListStart = NULL;
1089
1090     ObtainReadLock(&afs_DDirtyVCListLock);
1091
1092     tvc = afs_DDirtyVCListStart;
1093     while (tvc) {
1094
1095         /* Get local write lock. */
1096         ObtainWriteLock(&tvc->lock, 704);
1097         sync_failed = 0;
1098
1099         if ((tvc->ddirty_flags & VDisconRemove) &&
1100             (tvc->ddirty_flags & VDisconCreate)) {
1101            /* Data created and deleted locally. The server doesn't
1102             * need to know about this, so we'll just skip this file
1103             * from the dirty list.
1104             */
1105             goto skip_file;
1106
1107         } else if (tvc->ddirty_flags & VDisconRemove) {
1108             /* Delete the file on the server and just move on
1109              * to the next file. After all, it has been deleted
1110              * we can't replay any other operation it.
1111              */
1112             code = afs_ProcessOpRemove(tvc, areq);
1113             if (code == ENOTEMPTY)
1114                 defered = 1;
1115             goto skip_file;
1116
1117         } else if (tvc->ddirty_flags & VDisconCreate) {
1118             /* For newly created files, we don't need a server lock. */
1119             code = afs_ProcessOpCreate(tvc, areq, acred);
1120             if (code == ENOTEMPTY)
1121                 defered = 1;
1122             if (code)
1123                 goto skip_file;
1124         }
1125
1126         /* Get server write lock. */
1127         do {
1128             tc = afs_Conn(&tvc->fid, areq, SHARED_LOCK);
1129             if (tc) {
1130                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SETLOCK);
1131                 RX_AFS_GUNLOCK();
1132                 code = RXAFS_SetLock(tc->id,
1133                                         (struct AFSFid *)&tvc->fid.Fid,
1134                                         LockWrite,
1135                                         &tsync);
1136                 RX_AFS_GLOCK();
1137                 XSTATS_END_TIME;
1138            } else
1139                 code = -1;
1140
1141         } while (afs_Analyze(tc,
1142                         code,
1143                         &tvc->fid,
1144                         areq,
1145                         AFS_STATS_FS_RPCIDX_SETLOCK,
1146                         SHARED_LOCK,
1147                         NULL));
1148
1149         if (code) {
1150             sync_failed = 1;
1151             goto skip_file;
1152         }
1153
1154         if ((tvc->ddirty_flags & VDisconRename) &&
1155                 !(tvc->ddirty_flags & VDisconCreate)) {
1156             /* Rename file only if it hasn't been created locally. */
1157             code = afs_ProcessOpRename(tvc, areq);
1158             if (code)
1159                 goto skip_file;
1160         }
1161
1162         /* Issue a FetchStatus to get info about DV and callbacks. */
1163         do {
1164             tc = afs_Conn(&tvc->fid, areq, SHARED_LOCK);
1165             if (tc) {
1166                 tvc->callback = tc->srvr->server;
1167                 start = osi_Time();
1168                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHSTATUS);
1169                 RX_AFS_GUNLOCK();
1170                 code = RXAFS_FetchStatus(tc->id,
1171                                 (struct AFSFid *)&tvc->fid.Fid,
1172                                 &fstat,
1173                                 &callback,
1174                                 &tsync);
1175                 RX_AFS_GLOCK();
1176                 XSTATS_END_TIME;
1177             } else
1178                 code = -1;
1179
1180         } while (afs_Analyze(tc,
1181                         code,
1182                         &tvc->fid,
1183                         areq,
1184                         AFS_STATS_FS_RPCIDX_FETCHSTATUS,
1185                         SHARED_LOCK,
1186                         NULL));
1187
1188         if (code) {
1189             sync_failed = 1;
1190             goto unlock_srv_file;
1191         }
1192
1193         if ((dv_match(tvc, fstat) && (tvc->m.Date == fstat.ServerModTime)) ||
1194                 (afs_ConflictPolicy == CLIENT_WINS) ||
1195                 (tvc->ddirty_flags & VDisconCreate)) {
1196             /*
1197              * Send changes to the server if there's data version match, or
1198              * client wins policy has been selected or file has been created
1199              * but doesn't have it's the contents on to the server yet.
1200              */
1201            /*
1202             * XXX: Checking server attr changes by timestamp might not the
1203             * most elegant solution, but it's the most viable one that we could find.
1204             */
1205             afs_UpdateStatus(tvc, &tvc->fid, areq, &fstat, &callback, start);
1206             code = afs_SendChanges(tvc, areq);
1207
1208         } else if (afs_ConflictPolicy == SERVER_WINS) {
1209             /* DV mismatch, apply collision resolution policy. */
1210             /* Dequeue whatever callback is on top (XXX: propably none). */
1211             ObtainWriteLock(&afs_xcbhash, 706);
1212             afs_DequeueCallback(tvc);
1213             tvc->callback = NULL;
1214             tvc->states &= ~(CStatd | CDirty | CUnique);
1215             ReleaseWriteLock(&afs_xcbhash);
1216
1217             /* Save metadata. File length gets updated as well because we
1218              * just removed CDirty from the avc.
1219              */
1220             //afs_ProcessFS(tvc, &fstat, areq);
1221
1222             /* Discard this files chunks and remove from current dir. */
1223             afs_TryToSmush(tvc, acred, 1);
1224             osi_dnlc_purgedp(tvc);
1225             if (tvc->linkData && !(tvc->states & CCore)) {
1226                 /* Take care of symlinks. */
1227                 afs_osi_Free(tvc->linkData, strlen(tvc->linkData) + 1);
1228                 tvc->linkData = NULL;
1229             }
1230
1231             /* Otherwise file content's won't be synchronized. */
1232             tvc->truncPos = AFS_NOTRUNC;
1233
1234         } else {
1235             printf("afs_ResyncDisconFiles: no resolution policy selected.\n");
1236         }               /* if DV match or client wins policy */
1237
1238         if (code) {
1239             sync_failed = 1;
1240             printf("Sync FAILED.\n");
1241         }
1242
1243 unlock_srv_file:
1244         /* Release server write lock. */
1245         do {
1246             tc = afs_Conn(&tvc->fid, areq, SHARED_LOCK);
1247             if (tc) {
1248                 XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RELEASELOCK);
1249                 RX_AFS_GUNLOCK();
1250                 code = RXAFS_ReleaseLock(tc->id,
1251                                 (struct AFSFid *) &tvc->fid.Fid,
1252                                 &tsync);
1253                 RX_AFS_GLOCK();
1254                 XSTATS_END_TIME;
1255             } else
1256                 code = -1;
1257         } while (afs_Analyze(tc,
1258                         code,
1259                         &tvc->fid,
1260                         areq,
1261                         AFS_STATS_FS_RPCIDX_RELEASELOCK,
1262                         SHARED_LOCK,
1263                         NULL));
1264
1265 skip_file:
1266         /* Pop this dirty vc out. */
1267         tmp = tvc;
1268         tvc = tvc->ddirty_next;
1269
1270         if (!defered) {
1271             /* Vnode not deferred. Clean it up. */
1272             if (!sync_failed) {
1273                 if (tmp->ddirty_flags == VDisconShadowed) {
1274                     /* Dirs that have only the shadow flag set might still
1275                      * be used so keep them in a different list, that gets
1276                      * deleted after resync is done.
1277                      */
1278                     if (!shListStart)
1279                         shListStart = shList = tmp;
1280                     else {
1281                         shList->ddirty_next = tmp;
1282                         shList = tmp;
1283                     }
1284                 } else if (tmp->ddirty_flags & VDisconShadowed)
1285                     /* We can discard the shadow dir now. */
1286                     afs_DeleteShadowDir(tmp);
1287
1288                 /* Drop the refcount on this vnode because it's not in the
1289                  * list anymore.
1290                  */
1291                  afs_PutVCache(tmp);
1292
1293                 /* Only if sync was successfull,
1294                  * clear flags and dirty references.
1295                  */
1296                 tmp->ddirty_next = NULL;
1297                 tmp->ddirty_flags = 0;
1298             } else
1299                 ret_code = 1;
1300         } else {
1301             tmp->ddirty_next = NULL;
1302             defered = 0;
1303         }                       /* if (!defered) */
1304
1305         /* Release local write lock. */
1306         ReleaseWriteLock(&tmp->lock);
1307     }                   /* while (tvc) */
1308
1309     /* Delete the rest of shadow dirs. */
1310     tvc = shListStart;
1311     while (tvc) {
1312         ObtainWriteLock(&tvc->lock, 764);
1313
1314         afs_DeleteShadowDir(tvc);
1315         tvc->shVnode = 0;
1316         tvc->shUnique = 0;
1317
1318         tmp = tvc;
1319         tvc = tvc->ddirty_next;
1320         tmp->ddirty_next = NULL;
1321
1322         ReleaseWriteLock(&tmp->lock);
1323     }                           /* while (tvc) */
1324
1325     if (ret_code == 0) {
1326         /* NULLIFY dirty list only if resync complete. */
1327         afs_DDirtyVCListStart = NULL;
1328         afs_DDirtyVCList = NULL;
1329     }
1330     ReleaseReadLock(&afs_DDirtyVCListLock);
1331
1332     return ret_code;
1333 }
1334
1335 /*!
1336  * Print list of disconnected files.
1337  *
1338  * \note Call with afs_DDirtyVCListLock read locked.
1339  */
1340 void afs_DbgDisconFiles()
1341 {
1342     struct vcache *tvc;
1343     int i = 0;
1344
1345     tvc = afs_DDirtyVCListStart;
1346     printf("List of dirty files: \n");
1347     while (tvc) {
1348         printf("Cell=%u Volume=%u VNode=%u Unique=%u\n",
1349                 tvc->fid.Cell,
1350                 tvc->fid.Fid.Volume,
1351                 tvc->fid.Fid.Vnode,
1352                 tvc->fid.Fid.Unique);
1353         tvc = tvc->ddirty_next;
1354         i++;
1355         if (i >= 30)
1356             osi_Panic("afs_DbgDisconFiles: loop in dirty list\n");
1357     }
1358 }
1359
1360 /*!
1361  * Generate a fake fid for a disconnected shadow dir.
1362  * Similar to afs_GenFakeFid, only that it uses the dhash
1363  * to search for a uniquifier because a shadow dir lives only
1364  * in the dcache.
1365  *
1366  * \param afid
1367  *
1368  * \note Don't forget to fill in afid with Cell and Volume.
1369  */
1370 void afs_GenShadowFid(struct VenusFid *afid)
1371 {
1372     afs_uint32 i, index, max_unique = 1;
1373     struct vcache *tvc = NULL;
1374
1375     /* Try generating a fid that isn't used in the vhash. */
1376     do {
1377         afid->Fid.Vnode = afs_DisconVnode + 1;
1378
1379         i = DVHash(afid);
1380         ObtainWriteLock(&afs_xdcache, 737);
1381         for (index = afs_dvhashTbl[i]; index != NULLIDX; index = i) {
1382             i = afs_dvnextTbl[index];
1383             if (afs_indexUnique[index] > max_unique)
1384                 max_unique = afs_indexUnique[index];
1385         }
1386
1387         ReleaseWriteLock(&afs_xdcache);
1388         afid->Fid.Unique = max_unique + 1;
1389         afs_DisconVnode += 2;
1390         if (!afs_DisconVnode)
1391             afs_DisconVnode = 2;
1392
1393         /* Is this a used vnode? */
1394         ObtainSharedLock(&afs_xvcache, 762);
1395         tvc = afs_FindVCache(afid, 0, 1);
1396         ReleaseSharedLock(&afs_xvcache);
1397         if (tvc)
1398             afs_PutVCache(tvc);
1399     } while (tvc);
1400 }
1401
1402 /*!
1403  * Generate a fake fid (vnode and uniquifier) for a vcache
1404  * (either dir or normal file). The vnode is generated via
1405  * afs_DisconVNode and the uniquifier by getting the highest
1406  * uniquifier on a hash chain and incrementing it by one.
1407  *
1408  * \param avc afid The fid structre that will be filled.
1409  * \param avtype Vnode type: VDIR/VREG.
1410  *
1411  * \note The cell number must be completed somewhere else.
1412  */
1413 void afs_GenFakeFid(struct VenusFid *afid, afs_uint32 avtype)
1414 {
1415     struct vcache *tvc;
1416     afs_uint32 max_unique = 1, i;
1417
1418     if (avtype == VDIR)
1419         afid->Fid.Vnode = afs_DisconVnode + 1;
1420     else if (avtype == VREG)
1421         afid->Fid.Vnode = afs_DisconVnode;
1422
1423     ObtainWriteLock(&afs_xvcache, 736);
1424     i = VCHash(afid);
1425     for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
1426         if (tvc->fid.Fid.Unique > max_unique)
1427             max_unique = tvc->fid.Fid.Unique;
1428     }
1429     ReleaseWriteLock(&afs_xvcache);
1430
1431     afid->Fid.Unique = max_unique + 1;
1432     afs_DisconVnode += 2;
1433     if (!afs_DisconVnode)
1434         afs_DisconVnode = 2;
1435 }
1436
1437 /*!
1438  * Fill in stats for a newly created file/directory.
1439  *
1440  * \param adp The parent dir's vcache.
1441  * \param avc The created vnode.
1442  * \param afid The new fid.
1443  * \param attrs
1444  * \param areq
1445  * \param file_type Specify if file or directory.
1446  *
1447  * \note Call with avc write locked.
1448  */
1449 void afs_GenDisconStatus(
1450         struct vcache *adp,
1451         struct vcache *avc,
1452         struct VenusFid *afid,
1453         struct vattr *attrs,
1454         struct vrequest *areq,
1455         int file_type)
1456 {
1457     memcpy(&avc->fid, afid, sizeof(struct VenusFid));
1458     avc->m.Mode = attrs->va_mode;
1459     /* Used to do this:
1460      * avc->m.Owner = attrs->va_uid;
1461      * But now we use the parent dir's ownership,
1462      * there's no other way to get a server owner id.
1463      * XXX: Does it really matter?
1464      */
1465     avc->m.Group = adp->m.Group;
1466     avc->m.Owner = adp->m.Owner;
1467     hset64(avc->m.DataVersion, 0, 0);
1468     avc->m.Length = attrs->va_size;
1469     avc->m.Date = osi_Time();
1470     if (file_type == VREG) {
1471         vSetType(avc, VREG);
1472         avc->m.Mode |= S_IFREG;
1473         avc->m.LinkCount = 1;
1474     } else if (file_type == VDIR) {
1475         vSetType(avc, VDIR);
1476         avc->m.Mode |= S_IFDIR;
1477         avc->m.LinkCount = 2;
1478     }
1479
1480     avc->anyAccess = adp->anyAccess;
1481     afs_AddAxs(avc->Access, areq->uid, adp->Access->axess);
1482
1483     avc->callback = NULL;
1484     avc->states |= CStatd;
1485     avc->states &= ~CBulkFetching;
1486 }
1487 #endif