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