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