37b697f453694097bf2938266624a1d10e7a7dc1
[openafs.git] / src / vol / vnode.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  *
9  * Portions Copyright (c) 2005-2008 Sine Nomine Associates
10  */
11
12 /*
13         System:         VICE-TWO
14         Module:         vnode.c
15         Institution:    The Information Technology Center, Carnegie-Mellon University
16
17  */
18 #include <afsconfig.h>
19 #include <afs/param.h>
20
21 #include <roken.h>
22
23 #include <limits.h>
24
25 #ifdef HAVE_SYS_FILE_H
26 #include <sys/file.h>
27 #endif
28
29 #include <rx/xdr.h>
30 #include "rx/rx_queue.h"
31 #include <afs/afsint.h>
32 #include "nfs.h"
33 #include <afs/errors.h>
34 #include "lock.h"
35 #include "lwp.h"
36 #include <afs/afssyscalls.h>
37 #include "ihandle.h"
38 #include "vnode.h"
39 #include "volume.h"
40 #include "volume_inline.h"
41 #include "vnode_inline.h"
42 #include "partition.h"
43 #include "salvsync.h"
44 #include "common.h"
45 #ifdef AFS_NT40_ENV
46 #include "ntops.h"
47 #endif
48
49 struct VnodeClassInfo VnodeClassInfo[nVNODECLASSES];
50
51 void VNLog(afs_int32 aop, afs_int32 anparms, ... );
52
53 extern int LogLevel;
54
55
56
57
58 #define BAD_IGET        -1000
59
60 /* There are two separate vnode queue types defined here:
61  * Each hash conflict chain -- is singly linked, with a single head
62  * pointer. New entries are added at the beginning. Old
63  * entries are removed by linear search, which generally
64  * only occurs after a disk read).
65  * LRU chain -- is doubly linked, single head pointer.
66  * Entries are added at the head, reclaimed from the tail,
67  * or removed from anywhere in the queue.
68  */
69
70
71 /* Vnode hash table.  Find hash chain by taking lower bits of
72  * (volume_hash_offset + vnode).
73  * This distributes the root inodes of the volumes over the
74  * hash table entries and also distributes the vnodes of
75  * volumes reasonably fairly.  The volume_hash_offset field
76  * for each volume is established as the volume comes on line
77  * by using the VOLUME_HASH_OFFSET macro.  This distributes the
78  * volumes fairly among the cache entries, both when servicing
79  * a small number of volumes and when servicing a large number.
80  */
81
82 /* logging stuff for finding bugs */
83 #define THELOGSIZE      5120
84 static afs_int32 theLog[THELOGSIZE];
85 static afs_int32 vnLogPtr = 0;
86 void
87 VNLog(afs_int32 aop, afs_int32 anparms, ... )
88 {
89     afs_int32 temp;
90     va_list ap;
91
92     va_start(ap, anparms);
93
94     if (anparms > 4)
95         anparms = 4;            /* do bounds checking */
96
97     temp = (aop << 16) | anparms;
98     theLog[vnLogPtr++] = temp;
99     if (vnLogPtr >= THELOGSIZE)
100         vnLogPtr = 0;
101     for (temp = 0; temp < anparms; temp++) {
102         theLog[vnLogPtr++] = va_arg(ap, afs_int32);
103         if (vnLogPtr >= THELOGSIZE)
104             vnLogPtr = 0;
105     }
106     va_end(ap);
107 }
108
109 /* VolumeHashOffset -- returns a new value to be stored in the
110  * volumeHashOffset of a Volume structure.  Called when a
111  * volume is initialized.  Sets the volumeHashOffset so that
112  * vnode cache entries are distributed reasonably between
113  * volumes (the root vnodes of the volumes will hash to
114  * different values, and spacing is maintained between volumes
115  * when there are not many volumes represented), and spread
116  * equally amongst vnodes within a single volume.
117  */
118 int
119 VolumeHashOffset_r(void)
120 {
121     static int nextVolumeHashOffset = 0;
122     /* hashindex Must be power of two in size */
123 #   define hashShift 3
124 #   define hashMask ((1<<hashShift)-1)
125     static byte hashindex[1 << hashShift] =
126         { 0, 128, 64, 192, 32, 160, 96, 224 };
127     int offset;
128     offset = hashindex[nextVolumeHashOffset & hashMask]
129         + (nextVolumeHashOffset >> hashShift);
130     nextVolumeHashOffset++;
131     return offset;
132 }
133
134 /* Change hashindex (above) if you change this constant */
135 #define VNODE_HASH_TABLE_SIZE 256
136 private Vnode *VnodeHashTable[VNODE_HASH_TABLE_SIZE];
137 #define VNODE_HASH(volumeptr,vnodenumber)\
138     ((volumeptr->vnodeHashOffset + vnodenumber)&(VNODE_HASH_TABLE_SIZE-1))
139
140
141 /**
142  * add a vnode to the volume's vnode list.
143  *
144  * @param[in] vp   volume object pointer
145  * @param[in] vnp  vnode object pointer
146  *
147  * @note for DAFS, it may seem like we should be acquiring a lightweight ref
148  *       on vp, but this would actually break things.  Right now, this is ok
149  *       because we destroy all vnode cache contents during during volume
150  *       detach.
151  *
152  * @pre VOL_LOCK held
153  *
154  * @internal volume package internal use only
155  */
156 void
157 AddToVVnList(Volume * vp, Vnode * vnp)
158 {
159     if (queue_IsOnQueue(vnp))
160         return;
161
162     Vn_volume(vnp) = vp;
163     Vn_cacheCheck(vnp) = vp->cacheCheck;
164     queue_Append(&vp->vnode_list, vnp);
165     Vn_stateFlags(vnp) |= VN_ON_VVN;
166 }
167
168 /**
169  * delete a vnode from the volume's vnode list.
170  *
171  * @pre VOL_LOCK held
172  *
173  * @internal volume package internal use only
174  */
175 void
176 DeleteFromVVnList(Vnode * vnp)
177 {
178     Vn_volume(vnp) = NULL;
179
180     if (!queue_IsOnQueue(vnp))
181         return;
182
183     queue_Remove(vnp);
184     Vn_stateFlags(vnp) &= ~(VN_ON_VVN);
185 }
186
187 /**
188  * add a vnode to the end of the lru.
189  *
190  * @param[in] vcp  vnode class info object pointer
191  * @param[in] vnp  vnode object pointer
192  *
193  * @internal vnode package internal use only
194  */
195 void
196 AddToVnLRU(struct VnodeClassInfo * vcp, Vnode * vnp)
197 {
198     if (Vn_stateFlags(vnp) & VN_ON_LRU) {
199         return;
200     }
201
202     /* Add it to the circular LRU list */
203     if (vcp->lruHead == NULL)
204         Abort("VPutVnode: vcp->lruHead==NULL");
205     else {
206         vnp->lruNext = vcp->lruHead;
207         vnp->lruPrev = vcp->lruHead->lruPrev;
208         vcp->lruHead->lruPrev = vnp;
209         vnp->lruPrev->lruNext = vnp;
210         vcp->lruHead = vnp;
211     }
212
213     /* If the vnode was just deleted, put it at the end of the chain so it
214      * will be reused immediately */
215     if (vnp->delete)
216         vcp->lruHead = vnp->lruNext;
217
218     Vn_stateFlags(vnp) |= VN_ON_LRU;
219 }
220
221 /**
222  * delete a vnode from the lru.
223  *
224  * @param[in] vcp  vnode class info object pointer
225  * @param[in] vnp  vnode object pointer
226  *
227  * @internal vnode package internal use only
228  */
229 void
230 DeleteFromVnLRU(struct VnodeClassInfo * vcp, Vnode * vnp)
231 {
232     if (!(Vn_stateFlags(vnp) & VN_ON_LRU)) {
233         return;
234     }
235
236     if (vnp == vcp->lruHead)
237         vcp->lruHead = vcp->lruHead->lruNext;
238
239     if ((vnp == vcp->lruHead) ||
240         (vcp->lruHead == NULL))
241         Abort("DeleteFromVnLRU: lru chain addled!\n");
242
243     vnp->lruPrev->lruNext = vnp->lruNext;
244     vnp->lruNext->lruPrev = vnp->lruPrev;
245
246     Vn_stateFlags(vnp) &= ~(VN_ON_LRU);
247 }
248
249 /**
250  * add a vnode to the vnode hash table.
251  *
252  * @param[in] vnp  vnode object pointer
253  *
254  * @pre VOL_LOCK held
255  *
256  * @post vnode on hash
257  *
258  * @internal vnode package internal use only
259  */
260 void
261 AddToVnHash(Vnode * vnp)
262 {
263     unsigned int newHash;
264
265     if (!(Vn_stateFlags(vnp) & VN_ON_HASH)) {
266         newHash = VNODE_HASH(Vn_volume(vnp), Vn_id(vnp));
267         vnp->hashNext = VnodeHashTable[newHash];
268         VnodeHashTable[newHash] = vnp;
269         vnp->hashIndex = newHash;
270
271         Vn_stateFlags(vnp) |= VN_ON_HASH;
272     }
273 }
274
275 /**
276  * delete a vnode from the vnode hash table.
277  *
278  * @param[in] vnp
279  * @param[in] hash
280  *
281  * @pre VOL_LOCK held
282  *
283  * @post vnode removed from hash
284  *
285  * @internal vnode package internal use only
286  */
287 void
288 DeleteFromVnHash(Vnode * vnp)
289 {
290     Vnode * tvnp;
291
292     if (Vn_stateFlags(vnp) & VN_ON_HASH) {
293         tvnp = VnodeHashTable[vnp->hashIndex];
294         if (tvnp == vnp)
295             VnodeHashTable[vnp->hashIndex] = vnp->hashNext;
296         else {
297             while (tvnp && tvnp->hashNext != vnp)
298                 tvnp = tvnp->hashNext;
299             if (tvnp)
300                 tvnp->hashNext = vnp->hashNext;
301         }
302
303         vnp->hashNext = NULL;
304         vnp->hashIndex = 0;
305         Vn_stateFlags(vnp) &= ~(VN_ON_HASH);
306     }
307 }
308
309
310 /**
311  * invalidate a vnode cache entry.
312  *
313  * @param[in] avnode   vnode object pointer
314  *
315  * @pre VOL_LOCK held
316  *
317  * @post vnode metadata invalidated.
318  *       vnode removed from hash table.
319  *       DAFS: vnode state set to VN_STATE_INVALID.
320  *
321  * @internal vnode package internal use only
322  */
323 void
324 VInvalidateVnode_r(struct Vnode *avnode)
325 {
326     avnode->changed_newTime = 0;        /* don't let it get flushed out again */
327     avnode->changed_oldTime = 0;
328     avnode->delete = 0;         /* it isn't deleted, really */
329     avnode->cacheCheck = 0;     /* invalid: prevents future vnode searches from working */
330     DeleteFromVnHash(avnode);
331 #ifdef AFS_DEMAND_ATTACH_FS
332     VnChangeState_r(avnode, VN_STATE_INVALID);
333 #endif
334 }
335
336
337 /**
338  * initialize vnode cache for a given vnode class.
339  *
340  * @param[in] class    vnode class
341  * @param[in] nVnodes  size of cache
342  *
343  * @post vnode cache allocated and initialized
344  *
345  * @internal volume package internal use only
346  *
347  * @note generally called by VInitVolumePackage_r
348  *
349  * @see VInitVolumePackage_r
350  */
351 int
352 VInitVnodes(VnodeClass class, int nVnodes)
353 {
354     byte *va;
355     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
356
357     vcp->allocs = vcp->gets = vcp->reads = vcp->writes = 0;
358     vcp->cacheSize = nVnodes;
359     switch (class) {
360     case vSmall:
361         osi_Assert(CHECKSIZE_SMALLVNODE);
362         vcp->lruHead = NULL;
363         vcp->residentSize = SIZEOF_SMALLVNODE;
364         vcp->diskSize = SIZEOF_SMALLDISKVNODE;
365         vcp->magic = SMALLVNODEMAGIC;
366         break;
367     case vLarge:
368         vcp->lruHead = NULL;
369         vcp->residentSize = SIZEOF_LARGEVNODE;
370         vcp->diskSize = SIZEOF_LARGEDISKVNODE;
371         vcp->magic = LARGEVNODEMAGIC;
372         break;
373     }
374     {
375         int s = vcp->diskSize - 1;
376         int n = 0;
377         while (s)
378             s >>= 1, n++;
379         vcp->logSize = n;
380     }
381
382     if (nVnodes == 0)
383         return 0;
384
385     va = (byte *) calloc(nVnodes, vcp->residentSize);
386     osi_Assert(va != NULL);
387     while (nVnodes--) {
388         Vnode *vnp = (Vnode *) va;
389         Vn_refcount(vnp) = 0;   /* no context switches */
390         Vn_stateFlags(vnp) |= VN_ON_LRU;
391 #ifdef AFS_DEMAND_ATTACH_FS
392         CV_INIT(&Vn_stateCV(vnp), "vnode state", CV_DEFAULT, 0);
393         Vn_state(vnp) = VN_STATE_INVALID;
394         Vn_readers(vnp) = 0;
395 #else /* !AFS_DEMAND_ATTACH_FS */
396         Lock_Init(&vnp->lock);
397 #endif /* !AFS_DEMAND_ATTACH_FS */
398         vnp->changed_oldTime = 0;
399         vnp->changed_newTime = 0;
400         Vn_volume(vnp) = NULL;
401         Vn_cacheCheck(vnp) = 0;
402         vnp->delete = Vn_id(vnp) = 0;
403 #ifdef AFS_PTHREAD_ENV
404         vnp->writer = (pthread_t) 0;
405 #else /* AFS_PTHREAD_ENV */
406         vnp->writer = (PROCESS) 0;
407 #endif /* AFS_PTHREAD_ENV */
408         vnp->hashIndex = 0;
409         vnp->handle = NULL;
410         Vn_class(vnp) = vcp;
411         if (vcp->lruHead == NULL)
412             vcp->lruHead = vnp->lruNext = vnp->lruPrev = vnp;
413         else {
414             vnp->lruNext = vcp->lruHead;
415             vnp->lruPrev = vcp->lruHead->lruPrev;
416             vcp->lruHead->lruPrev = vnp;
417             vnp->lruPrev->lruNext = vnp;
418             vcp->lruHead = vnp;
419         }
420         va += vcp->residentSize;
421     }
422     return 0;
423 }
424
425
426 /**
427  * allocate an unused vnode from the lru chain.
428  *
429  * @param[in] vcp  vnode class info object pointer
430  * @param[in] vp   volume pointer
431  * @param[in] vnodeNumber new vnode number that the vnode will be used for
432  *
433  * @pre VOL_LOCK is held
434  *
435  * @post vnode object is removed from lru
436  *       vnode is disassociated with its old volume, and associated with its
437  *         new volume
438  *       vnode is removed from its old vnode hash table, and for DAFS, it is
439  *         added to its new hash table
440  *       state is set to VN_STATE_INVALID.
441  *       inode handle is released.
442  *       a reservation is held on the vnode object
443  *
444  * @note we traverse backwards along the lru circlist.  It shouldn't
445  *       be necessary to specify that nUsers == 0 since if it is in the list,
446  *       nUsers should be 0.  Things shouldn't be in lruq unless no one is
447  *       using them.
448  *
449  * @warning DAFS: VOL_LOCK is dropped while doing inode handle release
450  *
451  * @warning for non-DAFS, the vnode is _not_ hashed on the vnode hash table;
452  *          non-DAFS must hash the vnode itself after loading data
453  *
454  * @return vnode object pointer
455  */
456 Vnode *
457 VGetFreeVnode_r(struct VnodeClassInfo * vcp, struct Volume *vp,
458                 VnodeId vnodeNumber)
459 {
460     Vnode *vnp;
461
462     vnp = vcp->lruHead->lruPrev;
463 #ifdef AFS_DEMAND_ATTACH_FS
464     if (Vn_refcount(vnp) != 0 || VnIsExclusiveState(Vn_state(vnp)) ||
465         Vn_readers(vnp) != 0)
466         Abort("VGetFreeVnode_r: in-use vnode in lruq");
467 #else
468     if (Vn_refcount(vnp) != 0 || CheckLock(&vnp->lock))
469         Abort("VGetFreeVnode_r: locked vnode in lruq");
470 #endif
471     VNLog(1, 2, Vn_id(vnp), (intptr_t)vnp, 0, 0);
472
473     /*
474      * it's going to be overwritten soon enough.
475      * remove from LRU, delete hash entry, and
476      * disassociate from old parent volume before
477      * we have a chance to drop the vol glock
478      */
479     DeleteFromVnLRU(vcp, vnp);
480     DeleteFromVnHash(vnp);
481     if (Vn_volume(vnp)) {
482         DeleteFromVVnList(vnp);
483     }
484
485     /* we must re-hash the vnp _before_ we drop the glock again; otherwise,
486      * someone else might try to grab the same vnode id, and we'll both alloc
487      * a vnode object for the same vn id, bypassing vnode locking */
488     Vn_id(vnp) = vnodeNumber;
489     VnCreateReservation_r(vnp);
490     AddToVVnList(vp, vnp);
491 #ifdef AFS_DEMAND_ATTACH_FS
492     AddToVnHash(vnp);
493 #endif
494
495     /* drop the file descriptor */
496     if (vnp->handle) {
497 #ifdef AFS_DEMAND_ATTACH_FS
498         VnChangeState_r(vnp, VN_STATE_RELEASING);
499         VOL_UNLOCK;
500 #endif
501         /* release is, potentially, a highly latent operation due to a couple
502          * factors:
503          *   - ihandle package lock contention
504          *   - closing file descriptor(s) associated with ih
505          *
506          * Hance, we perform outside of the volume package lock in order to
507          * reduce the probability of contention.
508          */
509         IH_RELEASE(vnp->handle);
510 #ifdef AFS_DEMAND_ATTACH_FS
511         VOL_LOCK;
512 #endif
513     }
514
515 #ifdef AFS_DEMAND_ATTACH_FS
516     VnChangeState_r(vnp, VN_STATE_INVALID);
517 #endif
518
519     return vnp;
520 }
521
522
523 /**
524  * lookup a vnode in the vnode cache hash table.
525  *
526  * @param[in] vp       pointer to volume object
527  * @param[in] vnodeId  vnode id
528  *
529  * @pre VOL_LOCK held
530  *
531  * @post matching vnode object or NULL is returned
532  *
533  * @return vnode object pointer
534  *   @retval NULL   no matching vnode object was found in the cache
535  *
536  * @internal vnode package internal use only
537  *
538  * @note this symbol is exported strictly for fssync debug protocol use
539  */
540 Vnode *
541 VLookupVnode(Volume * vp, VnodeId vnodeId)
542 {
543     Vnode * vnp;
544     unsigned int newHash;
545
546     newHash = VNODE_HASH(vp, vnodeId);
547     for (vnp = VnodeHashTable[newHash];
548          (vnp &&
549           ((Vn_id(vnp) != vnodeId) ||
550            (Vn_volume(vnp) != vp) ||
551            (vp->cacheCheck != Vn_cacheCheck(vnp))));
552          vnp = vnp->hashNext);
553
554     return vnp;
555 }
556
557
558 Vnode *
559 VAllocVnode(Error * ec, Volume * vp, VnodeType type)
560 {
561     Vnode *retVal;
562     VOL_LOCK;
563     retVal = VAllocVnode_r(ec, vp, type);
564     VOL_UNLOCK;
565     return retVal;
566 }
567
568 /**
569  * allocate a new vnode.
570  *
571  * @param[out] ec    error code return
572  * @param[in]  vp    volume object pointer
573  * @param[in]  type  desired vnode type
574  *
575  * @return vnode object pointer
576  *
577  * @pre VOL_LOCK held;
578  *      heavyweight ref held on vp
579  *
580  * @post vnode allocated and returned
581  */
582 Vnode *
583 VAllocVnode_r(Error * ec, Volume * vp, VnodeType type)
584 {
585     Vnode *vnp;
586     VnodeId vnodeNumber;
587     int bitNumber;
588     struct VnodeClassInfo *vcp;
589     VnodeClass class;
590     Unique unique;
591 #ifdef AFS_DEMAND_ATTACH_FS
592     VolState vol_state_save;
593 #endif
594
595     *ec = 0;
596
597 #ifdef AFS_DEMAND_ATTACH_FS
598     /*
599      * once a volume has entered an error state, don't permit
600      * further operations to proceed
601      *  -- tkeiser 11/21/2007
602      */
603     VWaitExclusiveState_r(vp);
604     if (VIsErrorState(V_attachState(vp))) {
605         /* XXX is VSALVAGING acceptable here? */
606         *ec = DAFS_VSALVAGE;
607         return NULL;
608     }
609 #endif
610
611     if (programType == fileServer && !V_inUse(vp)) {
612         if (vp->specialStatus) {
613             *ec = vp->specialStatus;
614         } else {
615             *ec = VOFFLINE;
616         }
617         return NULL;
618     }
619     class = vnodeTypeToClass(type);
620     vcp = &VnodeClassInfo[class];
621
622     if (!VolumeWriteable(vp)) {
623         *ec = (bit32) VREADONLY;
624         return NULL;
625     }
626
627     unique = vp->nextVnodeUnique++;
628     if (!unique)
629         unique = vp->nextVnodeUnique++;
630
631     if (vp->nextVnodeUnique > V_uniquifier(vp)) {
632         VUpdateVolume_r(ec, vp, 0);
633         if (*ec)
634             return NULL;
635     }
636
637     if (programType == fileServer) {
638         VAddToVolumeUpdateList_r(ec, vp);
639         if (*ec)
640             return NULL;
641     }
642
643     /* Find a slot in the bit map */
644     bitNumber = VAllocBitmapEntry_r(ec, vp, &vp->vnodeIndex[class],
645                                     VOL_ALLOC_BITMAP_WAIT);
646     if (*ec)
647         return NULL;
648     vnodeNumber = bitNumberToVnodeNumber(bitNumber, class);
649
650     /*
651      * DAFS:
652      * at this point we should be assured that V_attachState(vp) is non-exclusive
653      */
654
655  vnrehash:
656     VNLog(2, 1, vnodeNumber, 0, 0, 0);
657     /* Prepare to move it to the new hash chain */
658     vnp = VLookupVnode(vp, vnodeNumber);
659     if (vnp) {
660         /* slot already exists.  May even not be in lruq (consider store file locking a file being deleted)
661          * so we may have to wait for it below */
662         VNLog(3, 2, vnodeNumber, (intptr_t)vnp, 0, 0);
663
664         VnCreateReservation_r(vnp);
665         if (Vn_refcount(vnp) == 1) {
666             /* we're the only user */
667             /* This won't block */
668             VnLock(vnp, WRITE_LOCK, VOL_LOCK_HELD, WILL_NOT_DEADLOCK);
669         } else {
670 #ifdef AFS_DEMAND_ATTACH_FS
671             /*
672              * DAFS:
673              * vnode was cached, wait for any existing exclusive ops to finish.
674              * once we have reacquired the lock, re-verify volume state.
675              *
676              * note: any vnode error state is related to the old vnode; disregard.
677              */
678             VnWaitQuiescent_r(vnp);
679             if (VIsErrorState(V_attachState(vp))) {
680                 VnUnlock(vnp, WRITE_LOCK);
681                 VnCancelReservation_r(vnp);
682                 *ec = DAFS_VSALVAGE;
683                 return NULL;
684             }
685 #endif
686
687             /* other users present; follow locking hierarchy */
688             VnLock(vnp, WRITE_LOCK, VOL_LOCK_HELD, MIGHT_DEADLOCK);
689
690             /*
691              * verify state of the world hasn't changed
692              *
693              * (technically, this should never happen because cachecheck
694              *  is only updated during a volume attach, which should not
695              *  happen when refs are held)
696              */
697             if (Vn_volume(vnp)->cacheCheck != Vn_cacheCheck(vnp)) {
698                 VnUnlock(vnp, WRITE_LOCK);
699                 VnCancelReservation_r(vnp);
700                 goto vnrehash;
701             }
702         }
703
704         /* sanity check: vnode should be blank if it was deleted. If it's
705          * not blank, it is still in use somewhere; but the bitmap told us
706          * this vnode number was free, so something is wrong. */
707         if (vnp->disk.type != vNull) {
708             Error tmp;
709             Log("VAllocVnode:  addled bitmap or vnode object! (vol %ld, "
710                 "vnode %p, number %ld, type %ld)\n", (long)vp->hashid, vnp,
711                 (long)Vn_id(vnp), (long)vnp->disk.type);
712             *ec = EIO;
713             VFreeBitMapEntry_r(&tmp, vp, &vp->vnodeIndex[class], bitNumber,
714                                VOL_FREE_BITMAP_WAIT);
715             VInvalidateVnode_r(vnp);
716             VnUnlock(vnp, WRITE_LOCK);
717             VnCancelReservation_r(vnp);
718 #ifdef AFS_DEMAND_ATTACH_FS
719             VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, 0);
720 #else
721             VForceOffline_r(vp, 0);
722 #endif
723             return NULL;
724         }
725
726     } else {
727         /* no such vnode in the cache */
728
729         vnp = VGetFreeVnode_r(vcp, vp, vnodeNumber);
730
731         /* This will never block (guaranteed by check in VGetFreeVnode_r() */
732         VnLock(vnp, WRITE_LOCK, VOL_LOCK_HELD, WILL_NOT_DEADLOCK);
733
734 #ifdef AFS_DEMAND_ATTACH_FS
735         VnChangeState_r(vnp, VN_STATE_ALLOC);
736 #endif
737
738         /* Sanity check:  is this vnode really not in use? */
739         {
740             afs_sfsize_t size;
741             IHandle_t *ihP = vp->vnodeIndex[class].handle;
742             FdHandle_t *fdP;
743             afs_foff_t off = vnodeIndexOffset(vcp, vnodeNumber);
744             Error tmp;
745
746             /* XXX we have a potential race here if two threads
747              * allocate new vnodes at the same time, and they
748              * both decide it's time to extend the index
749              * file size...
750              */
751 #ifdef AFS_DEMAND_ATTACH_FS
752             /*
753              * this race has been eliminated for the DAFS case
754              * using exclusive state VOL_STATE_VNODE_ALLOC
755              *
756              * if this becomes a bottleneck, there are ways to
757              * improve parallelism for this code path
758              *   -- tkeiser 11/28/2007
759              */
760             VCreateReservation_r(vp);
761             VWaitExclusiveState_r(vp);
762             vol_state_save = VChangeState_r(vp, VOL_STATE_VNODE_ALLOC);
763 #endif
764
765             VOL_UNLOCK;
766             fdP = IH_OPEN(ihP);
767             if (fdP == NULL) {
768                 Log("VAllocVnode: can't open index file!\n");
769                 *ec = ENOENT;
770                 goto error_encountered;
771             }
772             if ((size = FDH_SIZE(fdP)) < 0) {
773                 Log("VAllocVnode: can't stat index file!\n");
774                 *ec = EIO;
775                 goto error_encountered;
776             }
777             if (off + vcp->diskSize <= size) {
778               if (FDH_PREAD(fdP, &vnp->disk, vcp->diskSize, off) != vcp->diskSize) {
779                     Log("VAllocVnode: can't read index file!\n");
780                     *ec = EIO;
781                     goto error_encountered;
782                 }
783                 if (vnp->disk.type != vNull) {
784                     Log("VAllocVnode:  addled bitmap or index!\n");
785                     *ec = EIO;
786                     goto error_encountered;
787                 }
788             } else {
789                 /* growing file - grow in a reasonable increment */
790                 char *buf = (char *)malloc(16 * 1024);
791                 if (!buf) {
792                     Log("VAllocVnode: can't grow vnode index: out of memory\n");
793                     *ec = ENOMEM;
794                     goto error_encountered;
795                 }
796                 memset(buf, 0, 16 * 1024);
797                 if ((FDH_PWRITE(fdP, buf, 16 * 1024, off)) != 16 * 1024) {
798                     Log("VAllocVnode: can't grow vnode index: write failed\n");
799                     *ec = EIO;
800                     free(buf);
801                     goto error_encountered;
802                 }
803                 free(buf);
804             }
805             FDH_CLOSE(fdP);
806             VOL_LOCK;
807
808 #ifdef AFS_DEMAND_ATTACH_FS
809             VChangeState_r(vp, vol_state_save);
810             VCancelReservation_r(vp);
811 #endif
812             goto sane;
813
814
815         error_encountered:
816             /*
817              * close the file handle
818              * acquire VOL_LOCK
819              * invalidate the vnode
820              * free up the bitmap entry (although salvager should take care of it)
821              * salvage the volume
822              * drop vnode lock and refs
823              */
824             if (fdP)
825                 FDH_CLOSE(fdP);
826             VOL_LOCK;
827             VFreeBitMapEntry_r(&tmp, vp, &vp->vnodeIndex[class], bitNumber, 0 /*flags*/);
828             VInvalidateVnode_r(vnp);
829             VnUnlock(vnp, WRITE_LOCK);
830             VnCancelReservation_r(vnp);
831 #ifdef AFS_DEMAND_ATTACH_FS
832             VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, 0);
833             VCancelReservation_r(vp);
834 #else
835             VForceOffline_r(vp, 0);
836 #endif
837             return NULL;
838         }
839     sane:
840         VNLog(4, 2, vnodeNumber, (intptr_t)vnp, 0, 0);
841 #ifndef AFS_DEMAND_ATTACH_FS
842         AddToVnHash(vnp);
843 #endif
844     }
845
846     VNLog(5, 1, (intptr_t)vnp, 0, 0, 0);
847     memset(&vnp->disk, 0, sizeof(vnp->disk));
848     vnp->changed_newTime = 0;   /* set this bit when vnode is updated */
849     vnp->changed_oldTime = 0;   /* set this on CopyOnWrite. */
850     vnp->delete = 0;
851     vnp->disk.vnodeMagic = vcp->magic;
852     vnp->disk.type = type;
853     vnp->disk.uniquifier = unique;
854     vnp->handle = NULL;
855     vcp->allocs++;
856     vp->header->diskstuff.filecount++;
857 #ifdef AFS_DEMAND_ATTACH_FS
858     VnChangeState_r(vnp, VN_STATE_EXCLUSIVE);
859 #endif
860     return vnp;
861 }
862
863 /**
864  * load a vnode from disk.
865  *
866  * @param[out] ec     client error code return
867  * @param[in]  vp     volume object pointer
868  * @param[in]  vnp    vnode object pointer
869  * @param[in]  vcp    vnode class info object pointer
870  * @param[in]  class  vnode class enumeration
871  *
872  * @pre vnode is registered in appropriate data structures;
873  *      caller holds a ref on vnode; VOL_LOCK is held
874  *
875  * @post vnode data is loaded from disk.
876  *       vnode state is set to VN_STATE_ONLINE.
877  *       on failure, vnode is invalidated.
878  *
879  * @internal vnode package internal use only
880  */
881 static void
882 VnLoad(Error * ec, Volume * vp, Vnode * vnp,
883        struct VnodeClassInfo * vcp, VnodeClass class)
884 {
885     /* vnode not cached */
886     Error error;
887     int dosalv = 1;
888     ssize_t nBytes;
889     IHandle_t *ihP = vp->vnodeIndex[class].handle;
890     FdHandle_t *fdP;
891     afs_ino_str_t stmp;
892
893     *ec = 0;
894     vcp->reads++;
895
896 #ifdef AFS_DEMAND_ATTACH_FS
897     VnChangeState_r(vnp, VN_STATE_LOAD);
898 #endif
899
900     /* This will never block */
901     VnLock(vnp, WRITE_LOCK, VOL_LOCK_HELD, WILL_NOT_DEADLOCK);
902
903     VOL_UNLOCK;
904     fdP = IH_OPEN(ihP);
905     if (fdP == NULL) {
906         Log("VnLoad: can't open index dev=%u, i=%s\n", vp->device,
907             PrintInode(stmp, vp->vnodeIndex[class].handle->ih_ino));
908         *ec = VIO;
909         goto error_encountered_nolock;
910     } else if ((nBytes = FDH_PREAD(fdP, (char *)&vnp->disk, vcp->diskSize, vnodeIndexOffset(vcp, Vn_id(vnp))))
911                != vcp->diskSize) {
912         /* Don't take volume off line if the inumber is out of range
913          * or the inode table is full. */
914         if (nBytes == BAD_IGET) {
915             Log("VnLoad: bad inumber %s\n",
916                 PrintInode(stmp, vp->vnodeIndex[class].handle->ih_ino));
917             *ec = VIO;
918             dosalv = 0;
919         } else if (nBytes == -1 && errno == EIO) {
920             /* disk error; salvage */
921             Log("VnLoad: Couldn't read vnode %u, volume %u (%s); volume needs salvage\n", Vn_id(vnp), V_id(vp), V_name(vp));
922         } else {
923             /* vnode is not allocated */
924             if (LogLevel >= 5)
925                 Log("VnLoad: Couldn't read vnode %u, volume %u (%s); read %d bytes, errno %d\n",
926                     Vn_id(vnp), V_id(vp), V_name(vp), (int)nBytes, errno);
927             *ec = VIO;
928             dosalv = 0;
929         }
930         goto error_encountered_nolock;
931     }
932     FDH_CLOSE(fdP);
933     VOL_LOCK;
934
935     /* Quick check to see that the data is reasonable */
936     if (vnp->disk.vnodeMagic != vcp->magic || vnp->disk.type == vNull) {
937         if (vnp->disk.type == vNull) {
938             *ec = VNOVNODE;
939             dosalv = 0;
940         } else {
941             struct vnodeIndex *index = &vp->vnodeIndex[class];
942             unsigned int bitNumber = vnodeIdToBitNumber(Vn_id(vnp));
943             unsigned int offset = bitNumber >> 3;
944
945 #ifdef AFS_DEMAND_ATTACH_FS
946             /* Make sure the volume bitmap isn't getting updated while we are
947              * checking it */
948             VWaitExclusiveState_r(vp);
949 #endif
950
951             /* Test to see if vnode number is valid. */
952             if ((offset >= index->bitmapSize)
953                 || ((*(index->bitmap + offset) & (1 << (bitNumber & 0x7)))
954                     == 0)) {
955                 Log("VnLoad: Request for unallocated vnode %u, volume %u (%s) denied.\n", Vn_id(vnp), V_id(vp), V_name(vp));
956                 *ec = VNOVNODE;
957                 dosalv = 0;
958             } else {
959                 Log("VnLoad: Bad magic number, vnode %u, volume %u (%s); volume needs salvage\n", Vn_id(vnp), V_id(vp), V_name(vp));
960             }
961         }
962         goto error_encountered;
963     }
964
965     IH_INIT(vnp->handle, V_device(vp), V_parentId(vp), VN_GET_INO(vnp));
966     VnUnlock(vnp, WRITE_LOCK);
967 #ifdef AFS_DEMAND_ATTACH_FS
968     VnChangeState_r(vnp, VN_STATE_ONLINE);
969 #endif
970     return;
971
972
973  error_encountered_nolock:
974     if (fdP) {
975         FDH_REALLYCLOSE(fdP);
976     }
977     VOL_LOCK;
978
979  error_encountered:
980     if (dosalv) {
981 #ifdef AFS_DEMAND_ATTACH_FS
982         VRequestSalvage_r(&error, vp, SALVSYNC_ERROR, 0);
983 #else
984         VForceOffline_r(vp, 0);
985         error = VSALVAGE;
986 #endif
987         if (!*ec)
988             *ec = error;
989     }
990
991     VInvalidateVnode_r(vnp);
992     VnUnlock(vnp, WRITE_LOCK);
993 }
994
995 /**
996  * store a vnode to disk.
997  *
998  * @param[out] ec     error code output
999  * @param[in]  vp     volume object pointer
1000  * @param[in]  vnp    vnode object pointer
1001  * @param[in]  vcp    vnode class info object pointer
1002  * @param[in]  class  vnode class enumeration
1003  *
1004  * @pre VOL_LOCK held.
1005  *      caller holds refs to volume and vnode.
1006  *      DAFS: caller is responsible for performing state sanity checks.
1007  *
1008  * @post vnode state is stored to disk.
1009  *
1010  * @internal vnode package internal use only
1011  */
1012 static void
1013 VnStore(Error * ec, Volume * vp, Vnode * vnp,
1014         struct VnodeClassInfo * vcp, VnodeClass class)
1015 {
1016     ssize_t nBytes;
1017     afs_foff_t offset;
1018     IHandle_t *ihP = vp->vnodeIndex[class].handle;
1019     FdHandle_t *fdP;
1020     afs_ino_str_t stmp;
1021 #ifdef AFS_DEMAND_ATTACH_FS
1022     VnState vn_state_save;
1023 #endif
1024
1025     *ec = 0;
1026
1027 #ifdef AFS_DEMAND_ATTACH_FS
1028     vn_state_save = VnChangeState_r(vnp, VN_STATE_STORE);
1029 #endif
1030
1031     offset = vnodeIndexOffset(vcp, Vn_id(vnp));
1032     VOL_UNLOCK;
1033     fdP = IH_OPEN(ihP);
1034     if (fdP == NULL) {
1035         Log("VnStore: can't open index file!\n");
1036         goto error_encountered;
1037     }
1038     nBytes = FDH_PWRITE(fdP, &vnp->disk, vcp->diskSize, offset);
1039     if (nBytes != vcp->diskSize) {
1040         /* Don't force volume offline if the inumber is out of
1041          * range or the inode table is full.
1042          */
1043         FDH_REALLYCLOSE(fdP);
1044         if (nBytes == BAD_IGET) {
1045             Log("VnStore: bad inumber %s\n",
1046                 PrintInode(stmp,
1047                            vp->vnodeIndex[class].handle->ih_ino));
1048             *ec = VIO;
1049             VOL_LOCK;
1050 #ifdef AFS_DEMAND_ATTACH_FS
1051             VnChangeState_r(vnp, VN_STATE_ERROR);
1052 #endif
1053         } else {
1054             Log("VnStore: Couldn't write vnode %u, volume %u (%s) (error %d)\n", Vn_id(vnp), V_id(Vn_volume(vnp)), V_name(Vn_volume(vnp)), (int)nBytes);
1055 #ifdef AFS_DEMAND_ATTACH_FS
1056             goto error_encountered;
1057 #else
1058             VOL_LOCK;
1059             VForceOffline_r(vp, 0);
1060             *ec = VSALVAGE;
1061 #endif
1062         }
1063         return;
1064     } else {
1065         FDH_CLOSE(fdP);
1066     }
1067
1068     VOL_LOCK;
1069 #ifdef AFS_DEMAND_ATTACH_FS
1070     VnChangeState_r(vnp, vn_state_save);
1071 #endif
1072     return;
1073
1074  error_encountered:
1075 #ifdef AFS_DEMAND_ATTACH_FS
1076     /* XXX instead of dumping core, let's try to request a salvage
1077      * and just fail the putvnode */
1078     if (fdP)
1079         FDH_CLOSE(fdP);
1080     VOL_LOCK;
1081     VnChangeState_r(vnp, VN_STATE_ERROR);
1082     VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, 0);
1083 #else
1084     osi_Assert(1 == 2);
1085 #endif
1086 }
1087
1088 /**
1089  * get a handle to a vnode object.
1090  *
1091  * @param[out] ec           error code
1092  * @param[in]  vp           volume object
1093  * @param[in]  vnodeNumber  vnode id
1094  * @param[in]  locktype     type of lock to acquire
1095  *
1096  * @return vnode object pointer
1097  *
1098  * @see VGetVnode_r
1099  */
1100 Vnode *
1101 VGetVnode(Error * ec, Volume * vp, VnodeId vnodeNumber, int locktype)
1102 {                               /* READ_LOCK or WRITE_LOCK, as defined in lock.h */
1103     Vnode *retVal;
1104     VOL_LOCK;
1105     retVal = VGetVnode_r(ec, vp, vnodeNumber, locktype);
1106     VOL_UNLOCK;
1107     return retVal;
1108 }
1109
1110 /**
1111  * get a handle to a vnode object.
1112  *
1113  * @param[out] ec           error code
1114  * @param[in]  vp           volume object
1115  * @param[in]  vnodeNumber  vnode id
1116  * @param[in]  locktype     type of lock to acquire
1117  *
1118  * @return vnode object pointer
1119  *
1120  * @internal vnode package internal use only
1121  *
1122  * @pre VOL_LOCK held.
1123  *      heavyweight ref held on volume object.
1124  */
1125 Vnode *
1126 VGetVnode_r(Error * ec, Volume * vp, VnodeId vnodeNumber, int locktype)
1127 {                               /* READ_LOCK or WRITE_LOCK, as defined in lock.h */
1128     Vnode *vnp;
1129     VnodeClass class;
1130     struct VnodeClassInfo *vcp;
1131
1132     *ec = 0;
1133
1134     if (vnodeNumber == 0) {
1135         *ec = VNOVNODE;
1136         return NULL;
1137     }
1138
1139     VNLog(100, 1, vnodeNumber, 0, 0, 0);
1140
1141 #ifdef AFS_DEMAND_ATTACH_FS
1142     /*
1143      * once a volume has entered an error state, don't permit
1144      * further operations to proceed
1145      *  -- tkeiser 11/21/2007
1146      */
1147     VWaitExclusiveState_r(vp);
1148     if (VIsErrorState(V_attachState(vp))) {
1149         /* XXX is VSALVAGING acceptable here? */
1150         *ec = VSALVAGING;
1151         return NULL;
1152     }
1153 #endif
1154
1155     if (programType == fileServer && !V_inUse(vp)) {
1156         *ec = (vp->specialStatus ? vp->specialStatus : VOFFLINE);
1157
1158         /* If the volume is VBUSY (being cloned or dumped) and this is
1159          * a READ operation, then don't fail.
1160          */
1161         if ((*ec != VBUSY) || (locktype != READ_LOCK)) {
1162             return NULL;
1163         }
1164         *ec = 0;
1165     }
1166     class = vnodeIdToClass(vnodeNumber);
1167     vcp = &VnodeClassInfo[class];
1168     if (locktype == WRITE_LOCK && !VolumeWriteable(vp)) {
1169         *ec = (bit32) VREADONLY;
1170         return NULL;
1171     }
1172
1173     if (locktype == WRITE_LOCK && programType == fileServer) {
1174         VAddToVolumeUpdateList_r(ec, vp);
1175         if (*ec) {
1176             return NULL;
1177         }
1178     }
1179
1180     vcp->gets++;
1181
1182     /* See whether the vnode is in the cache. */
1183     vnp = VLookupVnode(vp, vnodeNumber);
1184     if (vnp) {
1185         /* vnode is in cache */
1186
1187         VNLog(101, 2, vnodeNumber, (intptr_t)vnp, 0, 0);
1188         VnCreateReservation_r(vnp);
1189
1190 #ifdef AFS_DEMAND_ATTACH_FS
1191         /*
1192          * this is the one DAFS case where we may run into contention.
1193          * here's the basic control flow:
1194          *
1195          * if locktype is READ_LOCK:
1196          *   wait until vnode is not exclusive
1197          *   set to VN_STATE_READ
1198          *   increment read count
1199          *   done
1200          * else
1201          *   wait until vnode is quiescent
1202          *   set to VN_STATE_EXCLUSIVE
1203          *   done
1204          */
1205         if (locktype == READ_LOCK) {
1206             VnWaitExclusiveState_r(vnp);
1207         } else {
1208             VnWaitQuiescent_r(vnp);
1209         }
1210
1211         if (VnIsErrorState(Vn_state(vnp))) {
1212             VnCancelReservation_r(vnp);
1213             *ec = VSALVAGE;
1214             return NULL;
1215         }
1216 #endif /* AFS_DEMAND_ATTACH_FS */
1217     } else {
1218         /* vnode not cached */
1219
1220         /* Not in cache; tentatively grab most distantly used one from the LRU
1221          * chain */
1222         vcp->reads++;
1223         vnp = VGetFreeVnode_r(vcp, vp, vnodeNumber);
1224
1225         /* Initialize */
1226         vnp->changed_newTime = vnp->changed_oldTime = 0;
1227         vnp->delete = 0;
1228
1229         /*
1230          * XXX for non-DAFS, there is a serious
1231          * race condition here:
1232          *
1233          * two threads can race to load a vnode.  the net
1234          * result is two struct Vnodes can be allocated
1235          * and hashed, which point to the same underlying
1236          * disk data store.  conflicting vnode locks can
1237          * thus be held concurrently.
1238          *
1239          * for non-DAFS to be safe, VOL_LOCK really shouldn't
1240          * be dropped in VnLoad.  Of course, this would likely
1241          * lead to an unacceptable slow-down.
1242          */
1243
1244         VnLoad(ec, vp, vnp, vcp, class);
1245         if (*ec) {
1246             VnCancelReservation_r(vnp);
1247             return NULL;
1248         }
1249 #ifndef AFS_DEMAND_ATTACH_FS
1250         AddToVnHash(vnp);
1251 #endif
1252         /*
1253          * DAFS:
1254          * there is no possibility for contention. we "own" this vnode.
1255          */
1256     }
1257
1258     /*
1259      * DAFS:
1260      * it is imperative that nothing drop vol lock between here
1261      * and the VnBeginRead/VnChangeState stanza below
1262      */
1263
1264     VnLock(vnp, locktype, VOL_LOCK_HELD, MIGHT_DEADLOCK);
1265
1266     /* Check that the vnode hasn't been removed while we were obtaining
1267      * the lock */
1268     VNLog(102, 2, vnodeNumber, (intptr_t) vnp, 0, 0);
1269     if ((vnp->disk.type == vNull) || (Vn_cacheCheck(vnp) == 0)) {
1270         VnUnlock(vnp, locktype);
1271         VnCancelReservation_r(vnp);
1272         *ec = VNOVNODE;
1273         /* vnode is labelled correctly by now, so we don't have to invalidate it */
1274         return NULL;
1275     }
1276
1277 #ifdef AFS_DEMAND_ATTACH_FS
1278     if (locktype == READ_LOCK) {
1279         VnBeginRead_r(vnp);
1280     } else {
1281         VnChangeState_r(vnp, VN_STATE_EXCLUSIVE);
1282     }
1283 #endif
1284
1285     if (programType == fileServer)
1286         VBumpVolumeUsage_r(Vn_volume(vnp));     /* Hack; don't know where it should be
1287                                                  * called from.  Maybe VGetVolume */
1288     return vnp;
1289 }
1290
1291
1292 int TrustVnodeCacheEntry = 1;
1293 /* This variable is bogus--when it's set to 0, the hash chains fill
1294    up with multiple versions of the same vnode.  Should fix this!! */
1295 void
1296 VPutVnode(Error * ec, Vnode * vnp)
1297 {
1298     VOL_LOCK;
1299     VPutVnode_r(ec, vnp);
1300     VOL_UNLOCK;
1301 }
1302
1303 /**
1304  * put back a handle to a vnode object.
1305  *
1306  * @param[out] ec   client error code
1307  * @param[in]  vnp  vnode object pointer
1308  *
1309  * @pre VOL_LOCK held.
1310  *      ref held on vnode.
1311  *
1312  * @post ref dropped on vnode.
1313  *       if vnode was modified or deleted, it is written out to disk
1314  *       (assuming a write lock was held).
1315  *
1316  * @internal volume package internal use only
1317  */
1318 void
1319 VPutVnode_r(Error * ec, Vnode * vnp)
1320 {
1321     int writeLocked;
1322     VnodeClass class;
1323     struct VnodeClassInfo *vcp;
1324
1325     *ec = 0;
1326     osi_Assert(Vn_refcount(vnp) != 0);
1327     class = vnodeIdToClass(Vn_id(vnp));
1328     vcp = &VnodeClassInfo[class];
1329     osi_Assert(vnp->disk.vnodeMagic == vcp->magic);
1330     VNLog(200, 2, Vn_id(vnp), (intptr_t) vnp, 0, 0);
1331
1332 #ifdef AFS_DEMAND_ATTACH_FS
1333     writeLocked = (Vn_state(vnp) == VN_STATE_EXCLUSIVE);
1334 #else
1335     writeLocked = WriteLocked(&vnp->lock);
1336 #endif
1337
1338     if (writeLocked) {
1339         /* sanity checks */
1340 #ifdef AFS_PTHREAD_ENV
1341         pthread_t thisProcess = pthread_self();
1342 #else /* AFS_PTHREAD_ENV */
1343         PROCESS thisProcess;
1344         LWP_CurrentProcess(&thisProcess);
1345 #endif /* AFS_PTHREAD_ENV */
1346         VNLog(201, 2, (intptr_t) vnp,
1347               ((vnp->changed_newTime) << 1) | ((vnp->
1348                                                 changed_oldTime) << 1) | vnp->
1349               delete, 0, 0);
1350         if (thisProcess != vnp->writer)
1351             Abort("VPutVnode: Vnode at %"AFS_PTR_FMT" locked by another process!\n",
1352                   vnp);
1353
1354
1355         if (vnp->changed_oldTime || vnp->changed_newTime || vnp->delete) {
1356             Volume *vp = Vn_volume(vnp);
1357             afs_uint32 now = FT_ApproxTime();
1358             osi_Assert(Vn_cacheCheck(vnp) == vp->cacheCheck);
1359
1360             if (vnp->delete) {
1361                 /* No longer any directory entries for this vnode. Free the Vnode */
1362                 memset(&vnp->disk, 0, sizeof(vnp->disk));
1363                 /* delete flag turned off further down */
1364                 VNLog(202, 2, Vn_id(vnp), (intptr_t) vnp, 0, 0);
1365             } else if (vnp->changed_newTime) {
1366                 vnp->disk.serverModifyTime = now;
1367             }
1368             if (vnp->changed_newTime)
1369             {
1370                 V_updateDate(vp) = vp->updateTime = now;
1371                 if(V_volUpCounter(vp)< UINT_MAX)
1372                         V_volUpCounter(vp)++;
1373             }
1374
1375             /* The vnode has been changed. Write it out to disk */
1376             if (!V_inUse(vp)) {
1377 #ifdef AFS_DEMAND_ATTACH_FS
1378                 VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, 0);
1379 #else
1380                 osi_Assert(V_needsSalvaged(vp));
1381                 *ec = VSALVAGE;
1382 #endif
1383             } else {
1384                 VnStore(ec, vp, vnp, vcp, class);
1385
1386                 /* If the vnode is to be deleted, and we wrote the vnode out,
1387                  * free its bitmap entry. Do after the vnode is written so we
1388                  * don't allocate from bitmap before the vnode is written
1389                  * (doing so could cause a "addled bitmap" message).
1390                  */
1391                 if (vnp->delete && !*ec) {
1392                     if (Vn_volume(vnp)->header->diskstuff.filecount-- < 1)
1393                         Vn_volume(vnp)->header->diskstuff.filecount = 0;
1394                     VFreeBitMapEntry_r(ec, vp, &vp->vnodeIndex[class],
1395                                        vnodeIdToBitNumber(Vn_id(vnp)),
1396                                        VOL_FREE_BITMAP_WAIT);
1397                 }
1398             }
1399             vcp->writes++;
1400             vnp->changed_newTime = vnp->changed_oldTime = 0;
1401         }
1402 #ifdef AFS_DEMAND_ATTACH_FS
1403         VnChangeState_r(vnp, VN_STATE_ONLINE);
1404 #endif
1405     } else {                    /* Not write locked */
1406         if (vnp->changed_newTime || vnp->changed_oldTime || vnp->delete)
1407             Abort
1408                 ("VPutVnode: Change or delete flag for vnode "
1409                  "%"AFS_PTR_FMT" is set but vnode is not write locked!\n",
1410                  vnp);
1411 #ifdef AFS_DEMAND_ATTACH_FS
1412         VnEndRead_r(vnp);
1413 #endif
1414     }
1415
1416     /* Do not look at disk portion of vnode after this point; it may
1417      * have been deleted above */
1418     vnp->delete = 0;
1419     VnUnlock(vnp, ((writeLocked) ? WRITE_LOCK : READ_LOCK));
1420     VnCancelReservation_r(vnp);
1421 }
1422
1423 /*
1424  * Make an attempt to convert a vnode lock from write to read.
1425  * Do nothing if the vnode isn't write locked or the vnode has
1426  * been deleted.
1427  */
1428 int
1429 VVnodeWriteToRead(Error * ec, Vnode * vnp)
1430 {
1431     int retVal;
1432     VOL_LOCK;
1433     retVal = VVnodeWriteToRead_r(ec, vnp);
1434     VOL_UNLOCK;
1435     return retVal;
1436 }
1437
1438 /**
1439  * convert vnode handle from mutually exclusive to shared access.
1440  *
1441  * @param[out] ec   client error code
1442  * @param[in]  vnp  vnode object pointer
1443  *
1444  * @return unspecified use (see out argument 'ec' for error code return)
1445  *
1446  * @pre VOL_LOCK held.
1447  *      ref held on vnode.
1448  *      write lock held on vnode.
1449  *
1450  * @post read lock held on vnode.
1451  *       if vnode was modified, it has been written to disk.
1452  *
1453  * @internal volume package internal use only
1454  */
1455 int
1456 VVnodeWriteToRead_r(Error * ec, Vnode * vnp)
1457 {
1458     int writeLocked;
1459     VnodeClass class;
1460     struct VnodeClassInfo *vcp;
1461 #ifdef AFS_PTHREAD_ENV
1462     pthread_t thisProcess;
1463 #else /* AFS_PTHREAD_ENV */
1464     PROCESS thisProcess;
1465 #endif /* AFS_PTHREAD_ENV */
1466
1467     *ec = 0;
1468     osi_Assert(Vn_refcount(vnp) != 0);
1469     class = vnodeIdToClass(Vn_id(vnp));
1470     vcp = &VnodeClassInfo[class];
1471     osi_Assert(vnp->disk.vnodeMagic == vcp->magic);
1472     VNLog(300, 2, Vn_id(vnp), (intptr_t) vnp, 0, 0);
1473
1474 #ifdef AFS_DEMAND_ATTACH_FS
1475     writeLocked = (Vn_state(vnp) == VN_STATE_EXCLUSIVE);
1476 #else
1477     writeLocked = WriteLocked(&vnp->lock);
1478 #endif
1479     if (!writeLocked) {
1480         return 0;
1481     }
1482
1483
1484     VNLog(301, 2, (intptr_t) vnp,
1485           ((vnp->changed_newTime) << 1) | ((vnp->
1486                                             changed_oldTime) << 1) | vnp->
1487           delete, 0, 0);
1488
1489     /* sanity checks */
1490 #ifdef AFS_PTHREAD_ENV
1491     thisProcess = pthread_self();
1492 #else /* AFS_PTHREAD_ENV */
1493     LWP_CurrentProcess(&thisProcess);
1494 #endif /* AFS_PTHREAD_ENV */
1495     if (thisProcess != vnp->writer)
1496         Abort("VPutVnode: Vnode at %"AFS_PTR_FMT
1497               " locked by another process!\n", vnp);
1498
1499     if (vnp->delete) {
1500         return 0;
1501     }
1502     if (vnp->changed_oldTime || vnp->changed_newTime) {
1503         Volume *vp = Vn_volume(vnp);
1504         afs_uint32 now = FT_ApproxTime();
1505         osi_Assert(Vn_cacheCheck(vnp) == vp->cacheCheck);
1506         if (vnp->changed_newTime)
1507             vnp->disk.serverModifyTime = now;
1508         if (vnp->changed_newTime)
1509             V_updateDate(vp) = vp->updateTime = now;
1510
1511         /* The inode has been changed.  Write it out to disk */
1512         if (!V_inUse(vp)) {
1513 #ifdef AFS_DEMAND_ATTACH_FS
1514             VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, 0);
1515 #else
1516             osi_Assert(V_needsSalvaged(vp));
1517             *ec = VSALVAGE;
1518 #endif
1519         } else {
1520             VnStore(ec, vp, vnp, vcp, class);
1521         }
1522         vcp->writes++;
1523         vnp->changed_newTime = vnp->changed_oldTime = 0;
1524     }
1525
1526     vnp->writer = 0;
1527 #ifdef AFS_DEMAND_ATTACH_FS
1528     VnChangeState_r(vnp, VN_STATE_ONLINE);
1529     VnBeginRead_r(vnp);
1530 #else
1531     ConvertWriteToReadLock(&vnp->lock);
1532 #endif
1533     return 0;
1534 }
1535
1536 /**
1537  * initial size of ihandle pointer vector.
1538  *
1539  * @see VInvalidateVnodesByVolume_r
1540  */
1541 #define IH_VEC_BASE_SIZE 256
1542
1543 /**
1544  * increment amount for growing ihandle pointer vector.
1545  *
1546  * @see VInvalidateVnodesByVolume_r
1547  */
1548 #define IH_VEC_INCREMENT 256
1549
1550 /**
1551  * Compile list of ihandles to be released/reallyclosed at a later time.
1552  *
1553  * @param[in]   vp            volume object pointer
1554  * @param[out]  vec_out       vector of ihandle pointers to be released/reallyclosed
1555  * @param[out]  vec_len_out   number of valid elements in ihandle vector
1556  *
1557  * @pre - VOL_LOCK is held
1558  *      - volume is in appropriate exclusive state (e.g. VOL_STATE_VNODE_CLOSE,
1559  *        VOL_STATE_VNODE_RELEASE)
1560  *
1561  * @post - all vnodes on VVn list are invalidated
1562  *       - ih_vec is populated with all valid ihandles
1563  *
1564  * @return operation status
1565  *    @retval 0         success
1566  *    @retval ENOMEM    out of memory
1567  *
1568  * @todo we should handle out of memory conditions more gracefully.
1569  *
1570  * @internal vnode package internal use only
1571  */
1572 static int
1573 VInvalidateVnodesByVolume_r(Volume * vp,
1574                             IHandle_t *** vec_out,
1575                             size_t * vec_len_out)
1576 {
1577     int ret = 0;
1578     Vnode *vnp, *nvnp;
1579     size_t i = 0, vec_len;
1580     IHandle_t **ih_vec, **ih_vec_new;
1581
1582 #ifdef AFS_DEMAND_ATTACH_FS
1583     VOL_UNLOCK;
1584 #endif /* AFS_DEMAND_ATTACH_FS */
1585
1586     vec_len = IH_VEC_BASE_SIZE;
1587     ih_vec = malloc(sizeof(IHandle_t *) * vec_len);
1588 #ifdef AFS_DEMAND_ATTACH_FS
1589     VOL_LOCK;
1590 #endif
1591     if (ih_vec == NULL)
1592         return ENOMEM;
1593
1594     /*
1595      * Traverse the volume's vnode list.  Pull all the ihandles out into a
1596      * thread-private array for later asynchronous processing.
1597      */
1598 #ifdef AFS_DEMAND_ATTACH_FS
1599 restart_traversal:
1600 #endif
1601     for (queue_Scan(&vp->vnode_list, vnp, nvnp, Vnode)) {
1602         if (vnp->handle != NULL) {
1603             if (i == vec_len) {
1604 #ifdef AFS_DEMAND_ATTACH_FS
1605                 VOL_UNLOCK;
1606 #endif
1607                 vec_len += IH_VEC_INCREMENT;
1608                 ih_vec_new = realloc(ih_vec, sizeof(IHandle_t *) * vec_len);
1609 #ifdef AFS_DEMAND_ATTACH_FS
1610                 VOL_LOCK;
1611 #endif
1612                 if (ih_vec_new == NULL) {
1613                     ret = ENOMEM;
1614                     goto done;
1615                 }
1616                 ih_vec = ih_vec_new;
1617 #ifdef AFS_DEMAND_ATTACH_FS
1618                 /*
1619                  * Theoretically, the volume's VVn list should not change
1620                  * because the volume is in an exclusive state.  For the
1621                  * sake of safety, we will restart the traversal from the
1622                  * the beginning (which is not expensive because we're
1623                  * deleting the items from the list as we go).
1624                  */
1625                 goto restart_traversal;
1626 #endif
1627             }
1628             ih_vec[i++] = vnp->handle;
1629             vnp->handle = NULL;
1630         }
1631         DeleteFromVVnList(vnp);
1632         VInvalidateVnode_r(vnp);
1633     }
1634
1635  done:
1636     *vec_out = ih_vec;
1637     *vec_len_out = i;
1638
1639     return ret;
1640 }
1641
1642 /* VCloseVnodeFiles - called when a volume is going off line. All open
1643  * files for vnodes in that volume are closed. This might be excessive,
1644  * since we may only be taking one volume of a volume group offline.
1645  */
1646 void
1647 VCloseVnodeFiles_r(Volume * vp)
1648 {
1649 #ifdef AFS_DEMAND_ATTACH_FS
1650     VolState vol_state_save;
1651 #endif
1652     IHandle_t ** ih_vec;
1653     size_t i, vec_len;
1654
1655 #ifdef AFS_DEMAND_ATTACH_FS
1656     vol_state_save = VChangeState_r(vp, VOL_STATE_VNODE_CLOSE);
1657 #endif /* AFS_DEMAND_ATTACH_FS */
1658
1659     /* XXX need better error handling here */
1660     osi_Assert(VInvalidateVnodesByVolume_r(vp,
1661                                        &ih_vec,
1662                                        &vec_len) == 0);
1663
1664     /*
1665      * DAFS:
1666      * now we drop VOL_LOCK while we perform some potentially very
1667      * expensive operations in the background
1668      */
1669 #ifdef AFS_DEMAND_ATTACH_FS
1670     VOL_UNLOCK;
1671 #endif
1672
1673     for (i = 0; i < vec_len; i++) {
1674         IH_REALLYCLOSE(ih_vec[i]);
1675         IH_RELEASE(ih_vec[i]);
1676     }
1677
1678     free(ih_vec);
1679
1680 #ifdef AFS_DEMAND_ATTACH_FS
1681     VOL_LOCK;
1682     VChangeState_r(vp, vol_state_save);
1683 #endif /* AFS_DEMAND_ATTACH_FS */
1684 }
1685
1686
1687 /**
1688  * shut down all vnode cache state for a given volume.
1689  *
1690  * @param[in] vp  volume object pointer
1691  *
1692  * @pre VOL_LOCK is held
1693  *
1694  * @post all file descriptors closed.
1695  *       all inode handles released.
1696  *       all vnode cache objects disassociated from volume.
1697  *
1698  * @note for DAFS, these operations are performed outside the vol glock under
1699  *       volume exclusive state VOL_STATE_VNODE_RELEASE.  Please further note
1700  *       that it would be a bug to acquire and release a volume reservation
1701  *       during this exclusive operation.  This is due to the fact that we are
1702  *       generally called during the refcount 1->0 transition.
1703  *
1704  * @todo we should handle failures in VInvalidateVnodesByVolume_r more
1705  *       gracefully.
1706  *
1707  * @see VInvalidateVnodesByVolume_r
1708  *
1709  * @internal this routine is internal to the volume package
1710  */
1711 void
1712 VReleaseVnodeFiles_r(Volume * vp)
1713 {
1714 #ifdef AFS_DEMAND_ATTACH_FS
1715     VolState vol_state_save;
1716 #endif
1717     IHandle_t ** ih_vec;
1718     size_t i, vec_len;
1719
1720 #ifdef AFS_DEMAND_ATTACH_FS
1721     vol_state_save = VChangeState_r(vp, VOL_STATE_VNODE_RELEASE);
1722 #endif /* AFS_DEMAND_ATTACH_FS */
1723
1724     /* XXX need better error handling here */
1725     osi_Assert(VInvalidateVnodesByVolume_r(vp,
1726                                        &ih_vec,
1727                                        &vec_len) == 0);
1728
1729     /*
1730      * DAFS:
1731      * now we drop VOL_LOCK while we perform some potentially very
1732      * expensive operations in the background
1733      */
1734 #ifdef AFS_DEMAND_ATTACH_FS
1735     VOL_UNLOCK;
1736 #endif
1737
1738     for (i = 0; i < vec_len; i++) {
1739         IH_RELEASE(ih_vec[i]);
1740     }
1741
1742     free(ih_vec);
1743
1744 #ifdef AFS_DEMAND_ATTACH_FS
1745     VOL_LOCK;
1746     VChangeState_r(vp, vol_state_save);
1747 #endif /* AFS_DEMAND_ATTACH_FS */
1748 }