2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afs/param.h>
22 osi_rwlock_t cm_volumeLock;
25 cm_ValidateVolume(void)
30 for (volp = cm_data.allVolumesp, count = 0; volp; volp=volp->allNextp, count++) {
31 if ( volp->magic != CM_VOLUME_MAGIC ) {
32 afsi_log("cm_ValidateVolume failure: volp->magic != CM_VOLUME_MAGIC");
33 fprintf(stderr, "cm_ValidateVolume failure: volp->magic != CM_VOLUME_MAGIC\n");
36 if ( volp->cellp && volp->cellp->magic != CM_CELL_MAGIC ) {
37 afsi_log("cm_ValidateVolume failure: volp->cellp->magic != CM_CELL_MAGIC");
38 fprintf(stderr, "cm_ValidateVolume failure: volp->cellp->magic != CM_CELL_MAGIC\n");
41 if ( volp->allNextp && volp->allNextp->magic != CM_VOLUME_MAGIC ) {
42 afsi_log("cm_ValidateVolume failure: volp->allNextp->magic != CM_VOLUME_MAGIC");
43 fprintf(stderr, "cm_ValidateVolume failure: volp->allNextp->magic != CM_VOLUME_MAGIC\n");
46 if ( count != 0 && volp == cm_data.allVolumesp ||
47 count > cm_data.maxVolumes ) {
48 afsi_log("cm_ValidateVolume failure: cm_data.allVolumep loop detected");
49 fprintf(stderr, "cm_ValidateVolume failure: cm_data.allVolumep loop detected\n");
54 if ( count != cm_data.currentVolumes ) {
55 afsi_log("cm_ValidateVolume failure: count != cm_data.currentVolumes");
56 fprintf(stderr, "cm_ValidateVolume failure: count != cm_data.currentVolumes\n");
64 cm_ShutdownVolume(void)
68 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
70 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
71 if (volp->vol[volType].ID)
72 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
74 volp->cbExpiresRO = 0;
75 lock_FinalizeRWLock(&volp->rw);
81 void cm_InitVolume(int newFile, long maxVols)
83 static osi_once_t once;
85 if (osi_Once(&once)) {
86 lock_InitializeRWLock(&cm_volumeLock, "cm global volume lock");
89 cm_data.allVolumesp = NULL;
90 cm_data.currentVolumes = 0;
91 cm_data.maxVolumes = maxVols;
92 memset(cm_data.volumeNameHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
93 memset(cm_data.volumeRWIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
94 memset(cm_data.volumeROIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
95 memset(cm_data.volumeBKIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
96 cm_data.volumeLRUFirstp = cm_data.volumeLRULastp = NULL;
100 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
103 lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock");
104 volp->flags |= CM_VOLUMEFLAG_RESET;
105 volp->flags &= ~CM_VOLUMEFLAG_UPDATING_VL;
106 for (volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
107 volp->vol[volType].state = vl_unknown;
108 volp->vol[volType].serversp = NULL;
109 if (volp->vol[volType].ID)
110 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, vl_alldown, volp->vol[volType].state);
112 volp->cbExpiresRO = 0;
120 /* returns true if the id is a decimal integer, in which case we interpret it
121 * as an id. make the cache manager much simpler.
122 * Stolen from src/volser/vlprocs.c */
124 cm_VolNameIsID(char *aname)
127 while (tc = *aname++) {
128 if (tc > '9' || tc < '0')
136 * Update a volume. Caller holds a write lock on the volume (volp->rw).
139 * shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU} 01:38 (JHutz)
140 * Yes, we support multihomed fileservers.
141 * Since before we got the code from IBM.
142 * But to find out about multiple addresses on a multihomed server, you need
143 * to use VL_GetEntryByNameU and VL_GetAddrsU. If you use
144 * VL_GetEntryByNameO or VL_GetEntryByNameN, the vlserver just gives you one
145 * address per server.
146 * shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU} 01:39 (JHutz)
147 * see src/afs/afs_volume.c, paying particular attention to
148 * afs_NewVolumeByName, afs_SetupVolume, and InstallUVolumeEntry
149 * shadow / openafs / jaltman {ANDREW.CMU.EDU} 01:40 (Jeffrey Altman)
150 * thanks. The windows client calls the 0 versions.
151 * shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU} 01:51 (JHutz)
153 * By not using the N versions, you only get up to 8 sites instead of 13.
154 * By not using the U versions, you don't get to know about multihomed serve
155 * shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU} 01:52 (JHutz)
156 * Of course, you probably want to support the older versions for backward
157 * compatibility. If you do that, you need to call the newest interface
158 * first, and fall back to successively older versions if you get
162 long cm_UpdateVolumeLocation(struct cm_cell *cellp, cm_user_t *userp, cm_req_t *reqp,
167 cm_serverRef_t *tsrp;
169 struct sockaddr_in tsockAddr;
172 struct vldbentry vldbEntry;
173 struct nvldbentry nvldbEntry;
175 struct uvldbentry uvldbEntry;
180 enum volstatus rwNewstate = vl_online;
181 enum volstatus roNewstate = vl_online;
182 enum volstatus bkNewstate = vl_online;
183 #ifdef AFS_FREELANCE_CLIENT
188 #ifdef AFS_FREELANCE_CLIENT
189 if ( cellp->cellID == AFS_FAKE_ROOT_CELL_ID && volp->vol[RWVOL].ID == AFS_FAKE_ROOT_VOL_ID )
192 memset(&vldbEntry, 0, sizeof(vldbEntry));
193 vldbEntry.flags |= VLF_RWEXISTS;
194 vldbEntry.volumeId[0] = AFS_FAKE_ROOT_VOL_ID;
200 while (volp->flags & CM_VOLUMEFLAG_UPDATING_VL) {
201 osi_Log3(afsd_logp, "cm_UpdateVolumeLocation sleeping name %s:%s flags 0x%x",
202 volp->cellp->name, volp->namep, volp->flags);
203 osi_SleepW((LONG_PTR) &volp->flags, &volp->rw);
204 lock_ObtainWrite(&volp->rw);
205 osi_Log3(afsd_logp, "cm_UpdateVolumeLocation awake name %s:%s flags 0x%x",
206 volp->cellp->name, volp->namep, volp->flags);
207 if (!(volp->flags & CM_VOLUMEFLAG_RESET)) {
208 osi_Log3(afsd_logp, "cm_UpdateVolumeLocation nothing to do, waking others name %s:%s flags 0x%x",
209 volp->cellp->name, volp->namep, volp->flags);
210 osi_Wakeup((LONG_PTR) &volp->flags);
215 /* clear out old bindings */
216 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
217 if (volp->vol[volType].serversp)
218 cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
221 volp->flags |= CM_VOLUMEFLAG_UPDATING_VL;
222 lock_ReleaseWrite(&volp->rw);
224 if (cellp->flags & CM_CELLFLAG_VLSERVER_INVALID)
225 cm_UpdateCell(cellp, 0);
227 /* now we have volume structure locked and held; make RPC to fill it */
228 osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s", volp->cellp->name, volp->namep);
230 struct rx_connection * rxconnp;
232 code = cm_ConnByMServers(cellp->vlServersp, userp, reqp, &connp);
236 rxconnp = cm_GetRxConn(connp);
238 code = VL_GetEntryByNameU(rxconnp, volp->namep, &uvldbEntry);
240 if ( code == RXGEN_OPCODE )
243 code = VL_GetEntryByNameN(rxconnp, volp->namep, &nvldbEntry);
246 if ( code == RXGEN_OPCODE ) {
247 code = VL_GetEntryByNameO(rxconnp, volp->namep, &vldbEntry);
250 rx_PutConnection(rxconnp);
251 } while (cm_Analyze(connp, userp, reqp, NULL, NULL, cellp->vlServersp, NULL, code));
252 code = cm_MapVLRPCError(code, reqp);
254 osi_Log3(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s FAILURE, code 0x%x",
255 volp->cellp->name, volp->namep, code);
257 osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s SUCCESS",
258 volp->cellp->name, volp->namep);
261 /* We can end up here with code == CM_ERROR_NOSUCHVOLUME if the base volume name
262 * does not exist but there might exist a .readonly volume. If the base name
263 * doesn't exist we will not care about the .backup that might be left behind
264 * since there should be no method to access it.
266 if (code == CM_ERROR_NOSUCHVOLUME && volp->vol[RWVOL].ID == 0 && strlen(volp->namep) < (VL_MAXNAMELEN - 9)) {
267 char name[VL_MAXNAMELEN];
269 snprintf(name, VL_MAXNAMELEN, "%s.readonly", volp->namep);
271 /* now we have volume structure locked and held; make RPC to fill it */
272 osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s", volp->cellp->name,
273 osi_LogSaveString(afsd_logp,name));
275 struct rx_connection * rxconnp;
277 code = cm_ConnByMServers(cellp->vlServersp, userp, reqp, &connp);
281 rxconnp = cm_GetRxConn(connp);
283 code = VL_GetEntryByNameU(connp->rxconnp, name, &uvldbEntry);
285 if ( code == RXGEN_OPCODE )
288 code = VL_GetEntryByNameN(connp->rxconnp, name, &nvldbEntry);
291 if ( code == RXGEN_OPCODE ) {
292 code = VL_GetEntryByNameO(connp->rxconnp, name, &vldbEntry);
295 rx_PutConnection(rxconnp);
296 } while (cm_Analyze(connp, userp, reqp, NULL, NULL, cellp->vlServersp, NULL, code));
297 code = cm_MapVLRPCError(code, reqp);
299 osi_Log3(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s FAILURE, code 0x%x",
300 volp->cellp->name, osi_LogSaveString(afsd_logp,name), code);
302 osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s SUCCESS",
303 volp->cellp->name, osi_LogSaveString(afsd_logp,name));
306 lock_ObtainWrite(&volp->rw);
313 afs_int32 serverNumber[NMAXNSERVERS];
314 afs_int32 serverFlags[NMAXNSERVERS];
315 afs_int32 rwServers_alldown = 1;
316 afs_int32 roServers_alldown = 1;
317 afs_int32 bkServers_alldown = 1;
318 char name[VL_MAXNAMELEN];
320 #ifdef AFS_FREELANCE_CLIENT
322 rwServers_alldown = 0;
327 flags = vldbEntry.flags;
328 nServers = vldbEntry.nServers;
329 rwID = vldbEntry.volumeId[0];
330 roID = vldbEntry.volumeId[1];
331 bkID = vldbEntry.volumeId[2];
332 for ( i=0; i<nServers; i++ ) {
333 serverFlags[i] = vldbEntry.serverFlags[i];
334 serverNumber[i] = vldbEntry.serverNumber[i];
336 strncpy(name, vldbEntry.name, VL_MAXNAMELEN);
337 name[VL_MAXNAMELEN - 1] = '\0';
340 flags = nvldbEntry.flags;
341 nServers = nvldbEntry.nServers;
342 rwID = nvldbEntry.volumeId[0];
343 roID = nvldbEntry.volumeId[1];
344 bkID = nvldbEntry.volumeId[2];
345 for ( i=0; i<nServers; i++ ) {
346 serverFlags[i] = nvldbEntry.serverFlags[i];
347 serverNumber[i] = nvldbEntry.serverNumber[i];
349 strncpy(name, nvldbEntry.name, VL_MAXNAMELEN);
350 name[VL_MAXNAMELEN - 1] = '\0';
354 flags = uvldbEntry.flags;
355 nServers = uvldbEntry.nServers;
356 rwID = uvldbEntry.volumeId[0];
357 roID = uvldbEntry.volumeId[1];
358 bkID = uvldbEntry.volumeId[2];
359 for ( i=0, j=0; code == 0 && i<nServers && j<NMAXNSERVERS; i++ ) {
360 if ( !(uvldbEntry.serverFlags[i] & VLSERVER_FLAG_UUID) ) {
361 serverFlags[j] = uvldbEntry.serverFlags[i];
362 serverNumber[j] = uvldbEntry.serverNumber[i].time_low;
365 afs_uint32 * addrp, nentries, code, unique;
367 ListAddrByAttributes attrs;
370 memset((char *)&attrs, 0, sizeof(attrs));
371 attrs.Mask = VLADDR_UUID;
372 attrs.uuid = uvldbEntry.serverNumber[i];
373 memset((char *)&uuid, 0, sizeof(uuid));
374 memset((char *)&addrs, 0, sizeof(addrs));
377 struct rx_connection *rxconnp;
379 code = cm_ConnByMServers(cellp->vlServersp, userp, reqp, &connp);
383 rxconnp = cm_GetRxConn(connp);
384 code = VL_GetAddrsU(rxconnp, &attrs, &uuid, &unique, &nentries, &addrs);
385 rx_PutConnection(rxconnp);
386 } while (cm_Analyze(connp, userp, reqp, NULL, NULL, cellp->vlServersp, NULL, code));
389 code = cm_MapVLRPCError(code, reqp);
390 osi_Log2(afsd_logp, "CALL VL_GetAddrsU serverNumber %u FAILURE, code 0x%x",
394 osi_Log1(afsd_logp, "CALL VL_GetAddrsU serverNumber %u SUCCESS", i);
396 addrp = addrs.bulkaddrs_val;
397 for (k = 0; k < nentries && j < NMAXNSERVERS; j++, k++) {
398 serverFlags[j] = uvldbEntry.serverFlags[i];
399 serverNumber[j] = addrp[k];
402 free(addrs.bulkaddrs_val); /* This is wrong */
405 code = CM_ERROR_INVAL;
408 nServers = j; /* update the server count */
409 strncpy(name, uvldbEntry.name, VL_MAXNAMELEN);
410 name[VL_MAXNAMELEN - 1] = '\0';
415 /* decode the response */
416 lock_ObtainWrite(&cm_volumeLock);
417 if (cm_VolNameIsID(volp->namep)) {
422 if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
423 name[len - 7] = '\0';
424 } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
425 name[len - 9] = '\0';
428 osi_Log2(afsd_logp, "cm_UpdateVolume name %s -> %s", volp->namep, name);
430 if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
431 cm_RemoveVolumeFromNameHashTable(volp);
433 strcpy(volp->namep, name);
435 cm_AddVolumeToNameHashTable(volp);
438 if (flags & VLF_RWEXISTS) {
439 if (volp->vol[RWVOL].ID != rwID) {
440 if (volp->vol[RWVOL].flags & CM_VOLUMEFLAG_IN_HASH)
441 cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
442 volp->vol[RWVOL].ID = rwID;
443 cm_AddVolumeToIDHashTable(volp, RWVOL);
446 if (volp->vol[RWVOL].flags & CM_VOLUMEFLAG_IN_HASH)
447 cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
448 volp->vol[RWVOL].ID = 0;
450 if (flags & VLF_ROEXISTS) {
451 if (volp->vol[ROVOL].ID != roID) {
452 if (volp->vol[ROVOL].flags & CM_VOLUMEFLAG_IN_HASH)
453 cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
454 volp->vol[ROVOL].ID = roID;
455 cm_AddVolumeToIDHashTable(volp, ROVOL);
458 if (volp->vol[ROVOL].flags & CM_VOLUMEFLAG_IN_HASH)
459 cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
460 volp->vol[ROVOL].ID = 0;
462 if (flags & VLF_BACKEXISTS) {
463 if (volp->vol[BACKVOL].ID != bkID) {
464 if (volp->vol[BACKVOL].flags & CM_VOLUMEFLAG_IN_HASH)
465 cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
466 volp->vol[BACKVOL].ID = bkID;
467 cm_AddVolumeToIDHashTable(volp, BACKVOL);
470 if (volp->vol[BACKVOL].flags & CM_VOLUMEFLAG_IN_HASH)
471 cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
472 volp->vol[BACKVOL].ID = 0;
474 lock_ReleaseWrite(&cm_volumeLock);
475 for (i=0; i<nServers; i++) {
476 /* create a server entry */
477 tflags = serverFlags[i];
478 if (tflags & VLSF_DONTUSE)
480 tsockAddr.sin_family = AF_INET;
481 tempAddr = htonl(serverNumber[i]);
482 tsockAddr.sin_addr.s_addr = tempAddr;
483 tsp = cm_FindServer(&tsockAddr, CM_SERVER_FILE);
485 /* cm_NewServer will probe the server which in turn will
486 * update the state on the volume group object */
487 lock_ReleaseWrite(&volp->rw);
488 tsp = cm_NewServer(&tsockAddr, CM_SERVER_FILE, cellp, 0);
489 lock_ObtainWrite(&volp->rw);
491 /* if this server was created by fs setserverprefs */
495 osi_assertx(tsp != NULL, "null cm_server_t");
497 /* and add it to the list(s). */
499 * Each call to cm_NewServerRef() increments the
500 * ref count of tsp. These reference will be dropped,
501 * if and when the volume is reset; see reset code
502 * earlier in this function.
504 if ((tflags & VLSF_RWVOL) && (flags & VLF_RWEXISTS)) {
505 tsrp = cm_NewServerRef(tsp, rwID);
506 cm_InsertServerList(&volp->vol[RWVOL].serversp, tsrp);
508 lock_ObtainWrite(&cm_serverLock);
509 tsrp->refCount--; /* drop allocation reference */
510 lock_ReleaseWrite(&cm_serverLock);
512 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
513 rwServers_alldown = 0;
515 if ((tflags & VLSF_ROVOL) && (flags & VLF_ROEXISTS)) {
516 tsrp = cm_NewServerRef(tsp, roID);
517 cm_InsertServerList(&volp->vol[ROVOL].serversp, tsrp);
518 lock_ObtainWrite(&cm_serverLock);
519 tsrp->refCount--; /* drop allocation reference */
520 lock_ReleaseWrite(&cm_serverLock);
523 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
524 roServers_alldown = 0;
526 /* We don't use VLSF_BACKVOL !?! */
527 /* Because only the backup on the server holding the RW
528 * volume can be valid. This check prevents errors if a
529 * RW is moved but the old backup is not removed.
531 if ((tflags & VLSF_RWVOL) && (flags & VLF_BACKEXISTS)) {
532 tsrp = cm_NewServerRef(tsp, bkID);
533 cm_InsertServerList(&volp->vol[BACKVOL].serversp, tsrp);
534 lock_ObtainWrite(&cm_serverLock);
535 tsrp->refCount--; /* drop allocation reference */
536 lock_ReleaseWrite(&cm_serverLock);
538 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
539 bkServers_alldown = 0;
541 /* Drop the reference obtained by cm_FindServer() */
548 * If the first n servers have the same ipRank, then we
549 * randomly pick one among them and move it to the beginning.
550 * We don't bother to re-order the whole list because
551 * the rest of the list is used only if the first server is
552 * down. We only do this for the RO list; we assume the other
553 * lists are length 1.
556 cm_RandomizeServer(&volp->vol[ROVOL].serversp);
559 rwNewstate = rwServers_alldown ? vl_alldown : vl_online;
560 roNewstate = roServers_alldown ? vl_alldown : vl_online;
561 bkNewstate = bkServers_alldown ? vl_alldown : vl_online;
562 } else if (code == CM_ERROR_NOSUCHVOLUME || code == VL_NOENT) {
563 /* this volume does not exist - we should discard it */
564 if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
565 cm_RemoveVolumeFromNameHashTable(volp);
566 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
567 if (volp->vol[volType].flags & CM_VOLUMEFLAG_IN_HASH)
568 cm_RemoveVolumeFromIDHashTable(volp, volType);
569 if (volp->vol[volType].ID) {
570 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
571 volp->vol[volType].ID = 0;
573 cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
576 /* Move to the end so it will be recycled first */
577 cm_MoveVolumeToLRULast(volp);
579 volp->namep[0] ='\0';
581 rwNewstate = roNewstate = bkNewstate = vl_alldown;
584 if (volp->vol[RWVOL].state != rwNewstate) {
585 if (volp->vol[RWVOL].ID)
586 cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, rwNewstate);
587 volp->vol[RWVOL].state = rwNewstate;
589 if (volp->vol[ROVOL].state != roNewstate) {
590 if (volp->vol[ROVOL].ID)
591 cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, roNewstate);
592 volp->vol[ROVOL].state = roNewstate;
594 if (volp->vol[BACKVOL].state != bkNewstate) {
595 if (volp->vol[BACKVOL].ID)
596 cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, bkNewstate);
597 volp->vol[BACKVOL].state = bkNewstate;
601 volp->flags &= ~CM_VOLUMEFLAG_RESET;
603 volp->flags &= ~CM_VOLUMEFLAG_UPDATING_VL;
604 osi_Log4(afsd_logp, "cm_UpdateVolumeLocation done, waking others name %s:%s flags 0x%x code 0x%x",
605 volp->cellp->name, volp->namep, volp->flags, code);
606 osi_Wakeup((LONG_PTR) &volp->flags);
611 /* Requires read or write lock on cm_volumeLock */
612 void cm_GetVolume(cm_volume_t *volp)
614 InterlockedIncrement(&volp->refCount);
617 cm_volume_t *cm_GetVolumeByFID(cm_fid_t *fidp)
622 lock_ObtainRead(&cm_volumeLock);
623 hash = CM_VOLUME_ID_HASH(fidp->volume);
624 /* The volumeID can be any one of the three types. So we must
625 * search the hash table for all three types until we find it.
626 * We will search in the order of RO, RW, BK.
628 for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
629 if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[ROVOL].ID )
634 for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
635 if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[RWVOL].ID )
641 for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
642 if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[BACKVOL].ID )
647 /* hold the volume if we found it */
651 lock_ReleaseRead(&cm_volumeLock);
655 long cm_FindVolumeByID(cm_cell_t *cellp, afs_uint32 volumeID, cm_user_t *userp,
656 cm_req_t *reqp, afs_uint32 flags, cm_volume_t **outVolpp)
659 #ifdef SEARCH_ALL_VOLUMES
662 char volNameString[VL_MAXNAMELEN];
666 lock_ObtainRead(&cm_volumeLock);
667 #ifdef SEARCH_ALL_VOLUMES
668 for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
669 if (cellp == volp->cellp &&
670 ((unsigned) volumeID == volp->vol[RWVOL].ID ||
671 (unsigned) volumeID == volp->vol[ROVOL].ID ||
672 (unsigned) volumeID == volp->vol[BACKVOL].ID))
677 #endif /* SEARCH_ALL_VOLUMES */
679 hash = CM_VOLUME_ID_HASH(volumeID);
680 /* The volumeID can be any one of the three types. So we must
681 * search the hash table for all three types until we find it.
682 * We will search in the order of RO, RW, BK.
684 for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
685 if ( cellp == volp->cellp && volumeID == volp->vol[ROVOL].ID )
690 for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
691 if ( cellp == volp->cellp && volumeID == volp->vol[RWVOL].ID )
697 for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
698 if ( cellp == volp->cellp && volumeID == volp->vol[BACKVOL].ID )
703 #ifdef SEARCH_ALL_VOLUMES
704 osi_assertx(volp == volp2, "unexpected cm_vol_t");
707 /* hold the volume if we found it */
711 lock_ReleaseRead(&cm_volumeLock);
715 lock_ObtainWrite(&volp->rw);
718 if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
719 code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
721 lock_ReleaseWrite(&volp->rw);
725 if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
726 lock_ObtainWrite(&cm_volumeLock);
727 cm_AdjustVolumeLRU(volp);
728 lock_ReleaseWrite(&cm_volumeLock);
731 lock_ObtainRead(&cm_volumeLock);
733 lock_ReleaseRead(&cm_volumeLock);
738 /* otherwise, we didn't find it so consult the VLDB */
739 sprintf(volNameString, "%u", volumeID);
740 code = cm_FindVolumeByName(cellp, volNameString, userp, reqp,
746 long cm_FindVolumeByName(struct cm_cell *cellp, char *volumeNamep,
747 struct cm_user *userp, struct cm_req *reqp,
748 afs_uint32 flags, cm_volume_t **outVolpp)
751 #ifdef SEARCH_ALL_VOLUMES
755 char name[VL_MAXNAMELEN];
760 strncpy(name, volumeNamep, VL_MAXNAMELEN);
761 name[VL_MAXNAMELEN-1] = '\0';
764 if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
766 name[len - 7] = '\0';
767 } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
769 name[len - 9] = '\0';
774 lock_ObtainRead(&cm_volumeLock);
775 #ifdef SEARCH_ALL_VOLUMES
776 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
777 if (cellp == volp->cellp && strcmp(name, volp->namep) == 0) {
782 #endif /* SEARCH_ALL_VOLUMES */
784 hash = CM_VOLUME_NAME_HASH(name);
785 for (volp = cm_data.volumeNameHashTablep[hash]; volp; volp = volp->nameNextp) {
786 if (cellp == volp->cellp && strcmp(name, volp->namep) == 0)
790 #ifdef SEARCH_ALL_VOLUMES
791 osi_assertx(volp2 == volp, "unexpected cm_vol_t");
794 if (!volp && (flags & CM_GETVOL_FLAG_CREATE)) {
796 /* otherwise, get from VLDB */
798 if ( cm_data.currentVolumes >= cm_data.maxVolumes ) {
799 #ifdef RECYCLE_FROM_ALL_VOLUMES_LIST
800 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
801 if ( volp->refCount == 0 ) {
802 /* There is one we can re-use */
807 for ( volp = cm_data.volumeLRULastp;
809 volp = (cm_volume_t *) osi_QPrev(&volp->q))
811 if ( volp->refCount == 0 ) {
812 /* There is one we can re-use */
818 osi_panic("Exceeded Max Volumes", __FILE__, __LINE__);
820 lock_ReleaseRead(&cm_volumeLock);
821 lock_ObtainWrite(&volp->rw);
822 lock_ObtainWrite(&cm_volumeLock);
824 osi_Log2(afsd_logp, "Recycling Volume %s:%s",
825 volp->cellp->name, volp->namep);
827 if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
828 cm_RemoveVolumeFromLRU(volp);
829 if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
830 cm_RemoveVolumeFromNameHashTable(volp);
832 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
833 if (volp->vol[volType].flags & CM_VOLUMEFLAG_IN_HASH)
834 cm_RemoveVolumeFromIDHashTable(volp, volType);
835 if (volp->vol[volType].ID)
836 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_unknown);
837 volp->vol[volType].ID = 0;
838 cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
841 volp = &cm_data.volumeBaseAddress[cm_data.currentVolumes++];
842 memset(volp, 0, sizeof(cm_volume_t));
843 volp->magic = CM_VOLUME_MAGIC;
844 volp->allNextp = cm_data.allVolumesp;
845 cm_data.allVolumesp = volp;
846 lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock");
847 lock_ReleaseRead(&cm_volumeLock);
848 lock_ObtainWrite(&volp->rw);
849 lock_ObtainWrite(&cm_volumeLock);
852 strncpy(volp->namep, name, VL_MAXNAMELEN);
853 volp->namep[VL_MAXNAMELEN-1] = '\0';
854 volp->refCount = 1; /* starts off held */
855 volp->flags = CM_VOLUMEFLAG_RESET;
857 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
858 volp->vol[volType].state = vl_unknown;
859 volp->vol[volType].nextp = NULL;
860 volp->vol[volType].flags = 0;
862 volp->cbExpiresRO = 0;
863 cm_AddVolumeToNameHashTable(volp);
864 lock_ReleaseWrite(&cm_volumeLock);
869 lock_ReleaseRead(&cm_volumeLock);
872 return CM_ERROR_NOSUCHVOLUME;
874 lock_ObtainWrite(&volp->rw);
877 /* if we get here we are holding the mutex */
878 if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
879 code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
881 lock_ReleaseWrite(&volp->rw);
883 if (code == 0 && (type == BACKVOL && volp->vol[BACKVOL].ID == 0 ||
884 type == ROVOL && volp->vol[ROVOL].ID == 0))
885 code = CM_ERROR_NOSUCHVOLUME;
890 if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
891 lock_ObtainWrite(&cm_volumeLock);
892 cm_AdjustVolumeLRU(volp);
893 lock_ReleaseWrite(&cm_volumeLock);
896 lock_ObtainRead(&cm_volumeLock);
898 lock_ReleaseRead(&cm_volumeLock);
903 void cm_ForceUpdateVolume(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
907 #ifdef SEARCH_ALL_VOLUMES
914 cellp = cm_FindCellByID(fidp->cell, 0);
917 /* search for the volume */
918 lock_ObtainRead(&cm_volumeLock);
919 #ifdef SEARCH_ALL_VOLUMES
920 for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
921 if (cellp == volp->cellp &&
922 (fidp->volume == volp->vol[RWVOL].ID ||
923 fidp->volume == volp->vol[ROVOL].ID ||
924 fidp->volume == volp->vol[BACKVOL].ID))
927 #endif /* SEARCH_ALL_VOLUMES */
929 hash = CM_VOLUME_ID_HASH(fidp->volume);
930 /* The volumeID can be any one of the three types. So we must
931 * search the hash table for all three types until we find it.
932 * We will search in the order of RO, RW, BK.
934 for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
935 if ( cellp == volp->cellp && fidp->volume == volp->vol[ROVOL].ID )
940 for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
941 if ( cellp == volp->cellp && fidp->volume == volp->vol[RWVOL].ID )
947 for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
948 if ( cellp == volp->cellp && fidp->volume == volp->vol[BACKVOL].ID )
953 #ifdef SEARCH_ALL_VOLUMES
954 osi_assertx(volp == volp2, "unexpected cm_vol_t");
956 /* hold the volume if we found it */
960 lock_ReleaseRead(&cm_volumeLock);
966 cm_data.mountRootGen = time(NULL);
967 lock_ObtainWrite(&volp->rw);
968 volp->flags |= CM_VOLUMEFLAG_RESET;
970 /* Mark the volume to be updated but don't update it now.
971 * This function is called only from within cm_Analyze
972 * when cm_ConnByMServers has failed with all servers down
973 * The problem is that cm_UpdateVolume is going to call
974 * cm_ConnByMServers which may cause a recursive chain
975 * of calls each returning a retry on failure.
976 * Instead, set the flag so the next time the volume is
977 * accessed by Name or ID the UpdateVolume call will
980 code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
982 lock_ReleaseWrite(&volp->rw);
984 lock_ObtainRead(&cm_volumeLock);
986 lock_ReleaseRead(&cm_volumeLock);
989 /* find the appropriate servers from a volume */
990 cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volume)
992 cm_serverRef_t **serverspp;
993 cm_serverRef_t *current;;
995 lock_ObtainWrite(&cm_serverLock);
997 if (volume == volp->vol[RWVOL].ID)
998 serverspp = &volp->vol[RWVOL].serversp;
999 else if (volume == volp->vol[ROVOL].ID)
1000 serverspp = &volp->vol[ROVOL].serversp;
1001 else if (volume == volp->vol[BACKVOL].ID)
1002 serverspp = &volp->vol[BACKVOL].serversp;
1004 osi_panic("bad volume ID in cm_GetVolServers", __FILE__, __LINE__);
1006 for (current = *serverspp; current; current = current->next)
1007 current->refCount++;
1009 lock_ReleaseWrite(&cm_serverLock);
1014 void cm_PutVolume(cm_volume_t *volp)
1016 afs_int32 refCount = InterlockedDecrement(&volp->refCount);
1017 osi_assertx(refCount >= 0, "cm_volume_t refCount underflow has occurred");
1020 /* return the read-only volume, if there is one, or the read-write volume if
1023 long cm_GetROVolumeID(cm_volume_t *volp)
1027 lock_ObtainRead(&volp->rw);
1028 if (volp->vol[ROVOL].ID && volp->vol[ROVOL].serversp)
1029 id = volp->vol[ROVOL].ID;
1031 id = volp->vol[RWVOL].ID;
1032 lock_ReleaseRead(&volp->rw);
1037 void cm_RefreshVolumes(void)
1043 cm_data.mountRootGen = time(NULL);
1045 /* force a re-loading of volume data from the vldb */
1046 lock_ObtainRead(&cm_volumeLock);
1047 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1048 InterlockedIncrement(&volp->refCount);
1049 lock_ReleaseRead(&cm_volumeLock);
1051 lock_ObtainWrite(&volp->rw);
1052 volp->flags |= CM_VOLUMEFLAG_RESET;
1053 lock_ReleaseWrite(&volp->rw);
1055 lock_ObtainRead(&cm_volumeLock);
1056 refCount = InterlockedDecrement(&volp->refCount);
1057 osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
1059 lock_ReleaseRead(&cm_volumeLock);
1061 /* force mount points to be re-evaluated so that
1062 * if the volume location has changed we will pick
1065 for ( scp = cm_data.scacheLRUFirstp;
1067 scp = (cm_scache_t *) osi_QNext(&scp->q)) {
1068 if ( scp->fileType == CM_SCACHETYPE_MOUNTPOINT
1069 #ifdef AFS_FREELANCE_CLIENT
1070 && !(scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID)
1073 lock_ObtainWrite(&scp->rw);
1074 scp->mountPointStringp[0] = '\0';
1075 lock_ReleaseWrite(&scp->rw);
1082 /* The return code is 0 if the volume is not online and
1083 * 1 if the volume is online
1086 cm_CheckOfflineVolume(cm_volume_t *volp, afs_uint32 volID)
1090 AFSFetchVolumeStatus volStat;
1095 struct rx_connection * rxconnp;
1097 char offLineMsg[256];
1100 cm_serverRef_t *serversp;
1103 OfflineMsg = offLineMsg;
1106 lock_ObtainWrite(&volp->rw);
1108 if (volp->flags & CM_VOLUMEFLAG_RESET) {
1110 code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1113 if (volp->vol[RWVOL].ID != 0 && (!volID || volID == volp->vol[RWVOL].ID) &&
1114 volp->vol[RWVOL].serversp) {
1116 for (serversp = volp->vol[RWVOL].serversp; serversp; serversp = serversp->next) {
1117 if (serversp->status == srv_busy || serversp->status == srv_offline) {
1118 serversp->status = srv_not_busy;
1123 if (volp->vol[RWVOL].state == vl_busy || volp->vol[RWVOL].state == vl_offline || volp->vol[RWVOL].state == vl_unknown) {
1126 lock_ReleaseWrite(&volp->rw);
1128 code = cm_ConnFromVolume(volp, volp->vol[RWVOL].ID, cm_rootUserp, &req, &connp);
1132 rxconnp = cm_GetRxConn(connp);
1133 code = RXAFS_GetVolumeStatus(rxconnp, volp->vol[RWVOL].ID,
1134 &volStat, &Name, &OfflineMsg, &MOTD);
1135 rx_PutConnection(rxconnp);
1137 } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
1138 code = cm_MapRPCError(code, &req);
1140 lock_ObtainWrite(&volp->rw);
1141 if (code == 0 && volStat.Online) {
1142 cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, vl_online);
1143 volp->vol[RWVOL].state = vl_online;
1145 } else if (code == CM_ERROR_NOACCESS) {
1146 cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, vl_unknown);
1147 volp->vol[RWVOL].state = vl_unknown;
1153 if (volp->vol[ROVOL].ID != 0 && (!volID || volID == volp->vol[ROVOL].ID) &&
1154 volp->vol[ROVOL].serversp) {
1156 for (serversp = volp->vol[ROVOL].serversp; serversp; serversp = serversp->next) {
1157 if (serversp->status == srv_busy || serversp->status == srv_offline) {
1158 serversp->status = srv_not_busy;
1163 if (volp->vol[ROVOL].state == vl_busy || volp->vol[ROVOL].state == vl_offline || volp->vol[ROVOL].state == vl_unknown) {
1166 lock_ReleaseWrite(&volp->rw);
1168 code = cm_ConnFromVolume(volp, volp->vol[ROVOL].ID, cm_rootUserp, &req, &connp);
1172 rxconnp = cm_GetRxConn(connp);
1173 code = RXAFS_GetVolumeStatus(rxconnp, volp->vol[ROVOL].ID,
1174 &volStat, &Name, &OfflineMsg, &MOTD);
1175 rx_PutConnection(rxconnp);
1177 } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
1178 code = cm_MapRPCError(code, &req);
1180 lock_ObtainWrite(&volp->rw);
1181 if (code == 0 && volStat.Online) {
1182 cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, vl_online);
1183 volp->vol[ROVOL].state = vl_online;
1185 } else if (code == CM_ERROR_NOACCESS) {
1186 cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, vl_unknown);
1187 volp->vol[ROVOL].state = vl_unknown;
1193 if (volp->vol[BACKVOL].ID != 0 && (!volID || volID == volp->vol[BACKVOL].ID) &&
1194 volp->vol[BACKVOL].serversp) {
1196 for (serversp = volp->vol[BACKVOL].serversp; serversp; serversp = serversp->next) {
1197 if (serversp->status == srv_busy || serversp->status == srv_offline) {
1198 serversp->status = srv_not_busy;
1203 if (volp->vol[BACKVOL].state == vl_busy || volp->vol[BACKVOL].state == vl_offline || volp->vol[BACKVOL].state == vl_unknown) {
1206 lock_ReleaseWrite(&volp->rw);
1208 code = cm_ConnFromVolume(volp, volp->vol[BACKVOL].ID, cm_rootUserp, &req, &connp);
1212 rxconnp = cm_GetRxConn(connp);
1213 code = RXAFS_GetVolumeStatus(rxconnp, volp->vol[BACKVOL].ID,
1214 &volStat, &Name, &OfflineMsg, &MOTD);
1215 rx_PutConnection(rxconnp);
1217 } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
1218 code = cm_MapRPCError(code, &req);
1220 lock_ObtainWrite(&volp->rw);
1221 if (code == 0 && volStat.Online) {
1222 cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, vl_online);
1223 volp->vol[BACKVOL].state = vl_online;
1225 } else if (code == CM_ERROR_NOACCESS) {
1226 cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, vl_unknown);
1227 volp->vol[BACKVOL].state = vl_unknown;
1233 lock_ReleaseWrite(&volp->rw);
1238 /* called from the Daemon thread */
1239 void cm_CheckOfflineVolumes(void)
1244 lock_ObtainRead(&cm_volumeLock);
1245 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1246 if (volp->flags & CM_VOLUMEFLAG_IN_HASH) {
1247 InterlockedIncrement(&volp->refCount);
1248 lock_ReleaseRead(&cm_volumeLock);
1249 cm_CheckOfflineVolume(volp, 0);
1250 lock_ObtainRead(&cm_volumeLock);
1251 refCount = InterlockedDecrement(&volp->refCount);
1252 osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
1255 lock_ReleaseRead(&cm_volumeLock);
1260 cm_UpdateVolumeStatusInt(cm_volume_t *volp, struct cm_vol_state *statep)
1262 enum volstatus newStatus;
1263 cm_serverRef_t *tsrp;
1265 int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
1267 if (!volp || !statep) {
1274 lock_ObtainWrite(&cm_serverLock);
1275 for (tsrp = statep->serversp; tsrp; tsrp=tsrp->next) {
1277 cm_GetServerNoLock(tsp);
1278 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
1280 if (tsrp->status == srv_busy) {
1283 } else if (tsrp->status == srv_offline) {
1291 cm_PutServerNoLock(tsp);
1293 lock_ReleaseWrite(&cm_serverLock);
1296 newStatus = vl_alldown;
1297 else if (allBusy || (someBusy && someOffline))
1298 newStatus = vl_busy;
1299 else if (allOffline)
1300 newStatus = vl_offline;
1302 newStatus = vl_online;
1304 if (statep->ID && statep->state != newStatus)
1305 cm_VolumeStatusNotification(volp, statep->ID, statep->state, newStatus);
1307 statep->state = newStatus;
1311 cm_UpdateVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1314 if (volp->vol[RWVOL].ID == volID) {
1315 cm_UpdateVolumeStatusInt(volp, &volp->vol[RWVOL]);
1316 } else if (volp->vol[ROVOL].ID == volID) {
1317 cm_UpdateVolumeStatusInt(volp, &volp->vol[ROVOL]);
1318 } else if (volp->vol[BACKVOL].ID == volID) {
1319 cm_UpdateVolumeStatusInt(volp, &volp->vol[BACKVOL]);
1322 * If we are called with volID == 0 then something has gone wrong.
1323 * Most likely a race occurred in the server volume list maintenance.
1324 * Since we don't know which volume's status should be updated,
1325 * just update all of them that are known to exist. Better to be
1326 * correct than fast.
1329 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1330 if (volp->vol[volType].ID != 0)
1331 cm_UpdateVolumeStatusInt(volp, &volp->vol[volType]);
1337 ** Finds all volumes that reside on this server and reorders their
1338 ** RO list according to the changed rank of server.
1340 void cm_ChangeRankVolume(cm_server_t *tsp)
1346 /* find volumes which might have RO copy on server*/
1347 lock_ObtainRead(&cm_volumeLock);
1348 for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1350 code = 1 ; /* assume that list is unchanged */
1351 InterlockedIncrement(&volp->refCount);
1352 lock_ReleaseRead(&cm_volumeLock);
1353 lock_ObtainWrite(&volp->rw);
1355 if ((tsp->cellp==volp->cellp) && (volp->vol[ROVOL].serversp))
1356 code =cm_ChangeRankServer(&volp->vol[ROVOL].serversp, tsp);
1358 /* this volume list was changed */
1360 cm_RandomizeServer(&volp->vol[ROVOL].serversp);
1362 lock_ReleaseWrite(&volp->rw);
1363 lock_ObtainRead(&cm_volumeLock);
1364 refCount = InterlockedDecrement(&volp->refCount);
1365 osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
1367 lock_ReleaseRead(&cm_volumeLock);
1370 /* dump all volumes that have reference count > 0 to a file.
1371 * cookie is used to identify this batch for easy parsing,
1372 * and it a string provided by a caller
1374 int cm_DumpVolumes(FILE *outputFile, char *cookie, int lock)
1381 lock_ObtainRead(&cm_scacheLock);
1382 lock_ObtainRead(&cm_volumeLock);
1385 sprintf(output, "%s - dumping volumes - cm_data.currentVolumes=%d, cm_data.maxVolumes=%d\r\n", cookie, cm_data.currentVolumes, cm_data.maxVolumes);
1386 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1388 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1390 sprintf(output, "%s - volp=0x%p cell=%s name=%s rwID=%u roID=%u bkID=%u flags=0x%x refCount=%u\r\n",
1391 cookie, volp, volp->cellp->name, volp->namep, volp->vol[RWVOL].ID, volp->vol[ROVOL].ID, volp->vol[BACKVOL].ID, volp->flags,
1393 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1395 sprintf(output, "%s - Done dumping volumes.\r\n", cookie);
1396 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1399 lock_ReleaseRead(&cm_volumeLock);
1400 lock_ReleaseRead(&cm_scacheLock);
1407 * String hash function used by SDBM project.
1408 * It was chosen because it is fast and provides
1411 afs_uint32 SDBMHash(const char * str)
1413 afs_uint32 hash = 0;
1419 for(i = 0, len = strlen(str); i < len; i++)
1421 hash = str[i] + (hash << 6) + (hash << 16) - hash;
1424 return (hash & 0x7FFFFFFF);
1427 /* call with volume write-locked and mutex held */
1428 void cm_AddVolumeToNameHashTable(cm_volume_t *volp)
1432 if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
1435 i = CM_VOLUME_NAME_HASH(volp->namep);
1437 volp->nameNextp = cm_data.volumeNameHashTablep[i];
1438 cm_data.volumeNameHashTablep[i] = volp;
1439 volp->flags |= CM_VOLUMEFLAG_IN_HASH;
1442 /* call with volume write-locked and mutex held */
1443 void cm_RemoveVolumeFromNameHashTable(cm_volume_t *volp)
1445 cm_volume_t **lvolpp;
1449 if (volp->flags & CM_VOLUMEFLAG_IN_HASH) {
1450 /* hash it out first */
1451 i = CM_VOLUME_NAME_HASH(volp->namep);
1452 for (lvolpp = &cm_data.volumeNameHashTablep[i], tvolp = cm_data.volumeNameHashTablep[i];
1454 lvolpp = &tvolp->nameNextp, tvolp = tvolp->nameNextp) {
1455 if (tvolp == volp) {
1456 *lvolpp = volp->nameNextp;
1457 volp->flags &= ~CM_VOLUMEFLAG_IN_HASH;
1458 volp->nameNextp = NULL;
1465 /* call with volume write-locked and mutex held */
1466 void cm_AddVolumeToIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1469 struct cm_vol_state * statep;
1471 statep = cm_VolumeStateByType(volp, volType);
1473 if (statep->flags & CM_VOLUMEFLAG_IN_HASH)
1476 i = CM_VOLUME_ID_HASH(statep->ID);
1480 statep->nextp = cm_data.volumeRWIDHashTablep[i];
1481 cm_data.volumeRWIDHashTablep[i] = volp;
1484 statep->nextp = cm_data.volumeROIDHashTablep[i];
1485 cm_data.volumeROIDHashTablep[i] = volp;
1488 statep->nextp = cm_data.volumeBKIDHashTablep[i];
1489 cm_data.volumeBKIDHashTablep[i] = volp;
1492 statep->flags |= CM_VOLUMEFLAG_IN_HASH;
1496 /* call with volume write-locked and mutex held */
1497 void cm_RemoveVolumeFromIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1499 cm_volume_t **lvolpp;
1501 struct cm_vol_state * statep;
1504 statep = cm_VolumeStateByType(volp, volType);
1506 if (statep->flags & CM_VOLUMEFLAG_IN_HASH) {
1507 /* hash it out first */
1508 i = CM_VOLUME_ID_HASH(statep->ID);
1512 lvolpp = &cm_data.volumeRWIDHashTablep[i];
1513 tvolp = cm_data.volumeRWIDHashTablep[i];
1516 lvolpp = &cm_data.volumeROIDHashTablep[i];
1517 tvolp = cm_data.volumeROIDHashTablep[i];
1520 lvolpp = &cm_data.volumeBKIDHashTablep[i];
1521 tvolp = cm_data.volumeBKIDHashTablep[i];
1524 osi_assertx(0, "invalid volume type");
1527 if (tvolp == volp) {
1528 *lvolpp = statep->nextp;
1529 statep->flags &= ~CM_VOLUMEFLAG_IN_HASH;
1530 statep->nextp = NULL;
1534 lvolpp = &tvolp->vol[volType].nextp;
1535 tvolp = tvolp->vol[volType].nextp;
1540 /* must be called with cm_volumeLock write-locked! */
1541 void cm_AdjustVolumeLRU(cm_volume_t *volp)
1543 if (volp == cm_data.volumeLRULastp)
1544 cm_data.volumeLRULastp = (cm_volume_t *) osi_QPrev(&volp->q);
1545 if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
1546 osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1547 osi_QAdd((osi_queue_t **) &cm_data.volumeLRUFirstp, &volp->q);
1548 volp->flags |= CM_VOLUMEFLAG_IN_LRU_QUEUE;
1549 if (!cm_data.volumeLRULastp)
1550 cm_data.volumeLRULastp = volp;
1553 /* must be called with cm_volumeLock write-locked! */
1554 void cm_MoveVolumeToLRULast(cm_volume_t *volp)
1556 if (volp == cm_data.volumeLRULastp)
1559 if (volp == cm_data.volumeLRUFirstp)
1560 cm_data.volumeLRUFirstp = (cm_volume_t *) osi_QNext(&volp->q);
1561 if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
1562 osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1563 osi_QAddT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1564 volp->flags |= CM_VOLUMEFLAG_IN_LRU_QUEUE;
1565 if (!cm_data.volumeLRULastp)
1566 cm_data.volumeLRULastp = volp;
1569 /* must be called with cm_volumeLock write-locked! */
1570 void cm_RemoveVolumeFromLRU(cm_volume_t *volp)
1572 if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE) {
1573 if (volp == cm_data.volumeLRULastp)
1574 cm_data.volumeLRULastp = (cm_volume_t *) osi_QPrev(&volp->q);
1575 osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1576 volp->flags &= ~CM_VOLUMEFLAG_IN_LRU_QUEUE;
1580 static char * volstatus_str(enum volstatus vs)
1596 void cm_VolumeStatusNotification(cm_volume_t * volp, afs_uint32 volID, enum volstatus old, enum volstatus new)
1598 char volstr[CELL_MAXNAMELEN + VL_MAXNAMELEN]="";
1601 if (volID == volp->vol[RWVOL].ID)
1603 else if (volID == volp->vol[ROVOL].ID)
1605 else if (volID == volp->vol[BACKVOL].ID)
1609 snprintf(volstr, sizeof(volstr), "%s:%s%s", volp->cellp->name, volp->namep, ext);
1611 osi_Log4(afsd_logp, "VolumeStatusNotification: %-48s [%10u] (%s -> %s)",
1612 osi_LogSaveString(afsd_logp, volstr), volID, volstatus_str(old), volstatus_str(new));
1614 cm_VolStatus_Change_Notification(volp->cellp->cellID, volID, new);
1617 enum volstatus cm_GetVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1619 cm_vol_state_t * statep = cm_VolumeStateByID(volp, volID);
1621 return statep->state;
1626 /* Renew .readonly volume callbacks that are more than
1627 * 30 minutes old. (A volume callback is issued for 2 hours.)
1630 cm_VolumeRenewROCallbacks(void)
1633 time_t minexp = time(NULL) + 90 * 60;
1635 lock_ObtainRead(&cm_volumeLock);
1636 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1637 if ( volp->cbExpiresRO > 0 && volp->cbExpiresRO < minexp) {
1642 cm_SetFid(&fid, volp->cellp->cellID, volp->vol[ROVOL].ID, 1, 1);
1646 lock_ReleaseRead(&cm_volumeLock);
1647 if (cm_GetSCache(&fid, &scp, cm_rootUserp, &req) == 0) {
1648 lock_ObtainWrite(&scp->rw);
1649 cm_GetCallback(scp, cm_rootUserp, &req, 1);
1650 lock_ReleaseWrite(&scp->rw);
1651 cm_ReleaseSCache(scp);
1653 lock_ObtainRead(&cm_volumeLock);
1656 lock_ReleaseRead(&cm_volumeLock);
1660 cm_VolumeStateByType(cm_volume_t *volp, afs_uint32 volType)
1662 return &volp->vol[volType];
1666 cm_VolumeStateByID(cm_volume_t *volp, afs_uint32 id)
1668 cm_vol_state_t * statep = NULL;
1670 if (id == volp->vol[RWVOL].ID)
1671 statep = &volp->vol[RWVOL];
1672 else if (id == volp->vol[ROVOL].ID)
1673 statep = &volp->vol[ROVOL];
1674 else if (id == volp->vol[BACKVOL].ID)
1675 statep = &volp->vol[BACKVOL];
1681 cm_VolumeStateByName(cm_volume_t *volp, char *volname)
1683 size_t len = strlen(volname);
1684 cm_vol_state_t *statep;
1686 if (cm_stricmp_utf8N(".readonly", &volname[len-9]) == 0)
1687 statep = &volp->vol[ROVOL];
1688 else if (cm_stricmp_utf8N(".backup", &volname[len-7]) == 0)
1689 statep = &volp->vol[BACKVOL];
1691 statep = &volp->vol[RWVOL];