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