* directory or online at http://www.openafs.org/dl/license10.html
*/
+#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
+
#include <afs/stds.h>
#include <windows.h>
cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
}
volp->cbExpiresRO = 0;
+ volp->cbServerpRO = NULL;
lock_FinalizeRWLock(&volp->rw);
}
cm_VolumeStatusNotification(volp, volp->vol[volType].ID, vl_unknown, volp->vol[volType].state);
}
volp->cbExpiresRO = 0;
+ volp->cbServerpRO = NULL;
}
}
osi_EndOnce(&once);
cm_volume_t *volp)
{
cm_conn_t *connp;
- int i, j, k;
+ int i;
+ afs_uint32 j, k;
cm_serverRef_t *tsrp;
cm_server_t *tsp;
struct sockaddr_in tsockAddr;
lock_AssertWrite(&volp->rw);
+ /*
+ * If the last volume update was in the last five
+ * minutes and it did not exist, then avoid the RPC
+ * and return No Such Volume immediately.
+ */
+ if ((volp->flags & CM_VOLUMEFLAG_NOEXIST) &&
+ volp->lastUpdateTime + 600 < time(0))
+ {
+ return CM_ERROR_NOSUCHVOLUME;
+ }
+
#ifdef AFS_FREELANCE_CLIENT
if ( cellp->cellID == AFS_FAKE_ROOT_CELL_ID && volp->vol[RWVOL].ID == AFS_FAKE_ROOT_VOL_ID )
{
}
}
- /* clear out old bindings */
- for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
- if (volp->vol[volType].serversp)
- cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
- }
-
volp->flags |= CM_VOLUMEFLAG_UPDATING_VL;
lock_ReleaseWrite(&volp->rw);
}
/* We can end up here with code == CM_ERROR_NOSUCHVOLUME if the base volume name
- * does not exist but there might exist a .readonly volume. If the base name
- * doesn't exist we will not care about the .backup that might be left behind
- * since there should be no method to access it.
+ * does not exist and is not a numeric string but there might exist a .readonly volume.
+ * If the base name doesn't exist we will not care about the .backup that might be left
+ * behind since there should be no method to access it.
*/
- if (code == CM_ERROR_NOSUCHVOLUME && volp->vol[RWVOL].ID == 0 && strlen(volp->namep) < (VL_MAXNAMELEN - 9)) {
+ if (code == CM_ERROR_NOSUCHVOLUME &&
+ _atoi64(volp->namep) == 0 &&
+ volp->vol[RWVOL].ID == 0 &&
+ strlen(volp->namep) < (VL_MAXNAMELEN - 9)) {
char name[VL_MAXNAMELEN];
snprintf(name, VL_MAXNAMELEN, "%s.readonly", volp->namep);
afs_int32 bkID;
afs_int32 serverNumber[NMAXNSERVERS];
afs_int32 serverFlags[NMAXNSERVERS];
+ afsUUID serverUUID[NMAXNSERVERS];
afs_int32 rwServers_alldown = 1;
afs_int32 roServers_alldown = 1;
afs_int32 bkServers_alldown = 1;
rwServers_alldown = 0;
#endif
+ /* clear out old bindings */
+ for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
+ if (volp->vol[volType].serversp)
+ cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
+ }
+
+ memset(serverUUID, 0, sizeof(serverUUID));
+
switch ( method ) {
case 0:
flags = vldbEntry.flags;
ListAddrByAttributes attrs;
afsUUID uuid;
- memset((char *)&attrs, 0, sizeof(attrs));
+ memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_UUID;
attrs.uuid = uvldbEntry.serverNumber[i];
- memset((char *)&uuid, 0, sizeof(uuid));
- memset((char *)&addrs, 0, sizeof(addrs));
+ memset(&uuid, 0, sizeof(uuid));
+ memset(&addrs, 0, sizeof(addrs));
do {
struct rx_connection *rxconnp;
for (k = 0; k < nentries && j < NMAXNSERVERS; j++, k++) {
serverFlags[j] = uvldbEntry.serverFlags[i];
serverNumber[j] = addrp[k];
+ serverUUID[j] = uuid;
}
- free(addrs.bulkaddrs_val); /* This is wrong */
+ xdr_free((xdrproc_t) xdr_bulkaddrs, &addrs);
if (nentries == 0)
code = CM_ERROR_INVAL;
osi_Log2(afsd_logp, "cm_UpdateVolume name %s -> %s",
osi_LogSaveString(afsd_logp,volp->namep), osi_LogSaveString(afsd_logp,name));
- if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromNameHashTable(volp);
strcpy(volp->namep, name);
cm_AddVolumeToNameHashTable(volp);
}
+ if (flags & VLF_DFSFILESET) {
+ volp->flags |= CM_VOLUMEFLAG_DFS_VOLUME;
+ osi_Log1(afsd_logp, "cm_UpdateVolume Volume Group '%s' is a DFS File Set. Correct behavior is not implemented.",
+ osi_LogSaveString(afsd_logp, volp->namep));
+ }
+
if (flags & VLF_RWEXISTS) {
if (volp->vol[RWVOL].ID != rwID) {
- if (volp->vol[RWVOL].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[RWVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
volp->vol[RWVOL].ID = rwID;
cm_AddVolumeToIDHashTable(volp, RWVOL);
}
} else {
- if (volp->vol[RWVOL].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[RWVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
volp->vol[RWVOL].ID = 0;
}
if (flags & VLF_ROEXISTS) {
if (volp->vol[ROVOL].ID != roID) {
- if (volp->vol[ROVOL].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[ROVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
volp->vol[ROVOL].ID = roID;
cm_AddVolumeToIDHashTable(volp, ROVOL);
}
} else {
- if (volp->vol[ROVOL].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[ROVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
volp->vol[ROVOL].ID = 0;
}
if (flags & VLF_BACKEXISTS) {
if (volp->vol[BACKVOL].ID != bkID) {
- if (volp->vol[BACKVOL].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[BACKVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
volp->vol[BACKVOL].ID = bkID;
cm_AddVolumeToIDHashTable(volp, BACKVOL);
}
} else {
- if (volp->vol[BACKVOL].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[BACKVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
volp->vol[BACKVOL].ID = 0;
}
tflags = serverFlags[i];
if (tflags & VLSF_DONTUSE)
continue;
+ tsockAddr.sin_port = htons(7000);
tsockAddr.sin_family = AF_INET;
tempAddr = htonl(serverNumber[i]);
tsockAddr.sin_addr.s_addr = tempAddr;
tsp = cm_FindServer(&tsockAddr, CM_SERVER_FILE);
+ if (tsp && (method == 2) && (tsp->flags & CM_SERVERFLAG_UUID)) {
+ /*
+ * Check to see if the uuid of the server we know at this address
+ * matches the uuid of the server we are being told about by the
+ * vlserver. If not, ...?
+ */
+ if (!afs_uuid_equal(&serverUUID[i], &tsp->uuid)) {
+ char uuid1[128], uuid2[128];
+ char hoststr[16];
+
+ afsUUID_to_string(&serverUUID[i], uuid1, sizeof(uuid1));
+ afsUUID_to_string(&tsp->uuid, uuid2, sizeof(uuid2));
+ afs_inet_ntoa_r(serverNumber[i], hoststr);
+
+ osi_Log3(afsd_logp, "cm_UpdateVolumeLocation UUIDs do not match! %s != %s (%s)",
+ osi_LogSaveString(afsd_logp, uuid1),
+ osi_LogSaveString(afsd_logp, uuid2),
+ osi_LogSaveString(afsd_logp, hoststr));
+ }
+ }
if (!tsp) {
- /* cm_NewServer will probe the server which in turn will
- * update the state on the volume group object */
+ /*
+ * cm_NewServer will probe the file server which in turn will
+ * update the state on the volume group object
+ */
lock_ReleaseWrite(&volp->rw);
- tsp = cm_NewServer(&tsockAddr, CM_SERVER_FILE, cellp, 0);
+ tsp = cm_NewServer(&tsockAddr, CM_SERVER_FILE, cellp, &serverUUID[i], 0);
lock_ObtainWrite(&volp->rw);
}
- /* if this server was created by fs setserverprefs */
+ osi_assertx(tsp != NULL, "null cm_server_t");
+
+ /*
+ * if this server was created by fs setserverprefs
+ * then it won't have either a cell assignment or
+ * a server uuid.
+ */
if ( !tsp->cellp )
tsp->cellp = cellp;
+ if ( (method == 2) && !(tsp->flags & CM_SERVERFLAG_UUID) &&
+ !afs_uuid_is_nil(&serverUUID[i])) {
+ tsp->uuid = serverUUID[i];
+ tsp->flags |= CM_SERVERFLAG_UUID;
+ }
- osi_assertx(tsp != NULL, "null cm_server_t");
-
/* and add it to the list(s). */
/*
* Each call to cm_NewServerRef() increments the
cm_RandomizeServer(&volp->vol[ROVOL].serversp);
}
-
rwNewstate = rwServers_alldown ? vl_alldown : vl_online;
roNewstate = roServers_alldown ? vl_alldown : vl_online;
bkNewstate = bkServers_alldown ? vl_alldown : vl_online;
- } else if (code == CM_ERROR_NOSUCHVOLUME || code == VL_NOENT || code == VL_BADNAME) {
- /* this volume does not exist - we should discard it */
- if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
- cm_RemoveVolumeFromNameHashTable(volp);
- for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
- if (volp->vol[volType].flags & CM_VOLUMEFLAG_IN_HASH)
- cm_RemoveVolumeFromIDHashTable(volp, volType);
- if (volp->vol[volType].ID) {
- cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
- volp->vol[volType].ID = 0;
- }
- cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
- }
- /* Move to the end so it will be recycled first */
- cm_MoveVolumeToLRULast(volp);
-
- volp->namep[0] ='\0';
+ volp->flags &= ~CM_VOLUMEFLAG_NOEXIST;
+ } else if (code == CM_ERROR_NOSUCHVOLUME || code == VL_NOENT || code == VL_BADNAME) {
+ volp->flags |= CM_VOLUMEFLAG_NOEXIST;
} else {
rwNewstate = roNewstate = bkNewstate = vl_alldown;
}
volp->vol[BACKVOL].state = bkNewstate;
}
+ volp->lastUpdateTime = time(0);
+
if (code == 0)
volp->flags &= ~CM_VOLUMEFLAG_RESET;
/* otherwise, we didn't find it so consult the VLDB */
sprintf(volNameString, "%u", volumeID);
code = cm_FindVolumeByName(cellp, volNameString, userp, reqp,
- flags, outVolpp);
+ flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL, outVolpp);
+
+ if (code == CM_ERROR_NOSUCHVOLUME && cellp->linkedName[0] &&
+ !(flags & CM_GETVOL_FLAG_IGNORE_LINKED_CELL)) {
+ cm_cell_t *linkedCellp = cm_GetCell(cellp->linkedName, flags);
+
+ if (linkedCellp)
+ code = cm_FindVolumeByID(linkedCellp, volumeID, userp, reqp,
+ flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL,
+ outVolpp);
+ }
return code;
}
osi_Log2(afsd_logp, "Recycling Volume %s:%s",
volp->cellp->name, volp->namep);
- if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
+ /* The volp is removed from the LRU queue in order to
+ * prevent two threads from attempting to recycle the
+ * same object. This volp must be re-inserted back into
+ * the LRU queue before this function exits.
+ */
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
cm_RemoveVolumeFromLRU(volp);
- if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromNameHashTable(volp);
for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
- if (volp->vol[volType].flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->vol[volType].qflags & CM_VOLUME_QFLAG_IN_HASH)
cm_RemoveVolumeFromIDHashTable(volp, volType);
if (volp->vol[volType].ID)
cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_unknown);
volp->vol[volType].flags = 0;
}
volp->cbExpiresRO = 0;
+ volp->cbServerpRO = NULL;
+ volp->creationDateRO = 0;
cm_AddVolumeToNameHashTable(volp);
lock_ReleaseWrite(&cm_volumeLock);
}
if (code == 0) {
*outVolpp = volp;
- if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
- lock_ObtainWrite(&cm_volumeLock);
+ lock_ObtainWrite(&cm_volumeLock);
+ if (!(volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) ||
+ (flags & CM_GETVOL_FLAG_NO_LRU_UPDATE))
cm_AdjustVolumeLRU(volp);
- lock_ReleaseWrite(&cm_volumeLock);
- }
+ lock_ReleaseWrite(&cm_volumeLock);
} else {
- lock_ObtainRead(&cm_volumeLock);
+ /*
+ * do not return it to the caller but do insert it in the LRU
+ * otherwise it will be lost
+ */
+ lock_ObtainWrite(&cm_volumeLock);
+ if (!(volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) ||
+ (flags & CM_GETVOL_FLAG_NO_LRU_UPDATE))
+ cm_AdjustVolumeLRU(volp);
cm_PutVolume(volp);
- lock_ReleaseRead(&cm_volumeLock);
+ lock_ReleaseWrite(&cm_volumeLock);
+ }
+
+ if (code == CM_ERROR_NOSUCHVOLUME && cellp->linkedName[0] &&
+ !(flags & CM_GETVOL_FLAG_IGNORE_LINKED_CELL)) {
+ cm_cell_t *linkedCellp = cm_GetCell(cellp->linkedName, flags);
+
+ if (linkedCellp)
+ code = cm_FindVolumeByName(linkedCellp, volumeNamep, userp, reqp,
+ flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL,
+ outVolpp);
}
return code;
}
}
/* find the appropriate servers from a volume */
-cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volume)
+cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volume, cm_user_t *userp, cm_req_t *reqp)
{
cm_serverRef_t **serverspp;
cm_serverRef_t *current;
+ int firstTry = 1;
+ start:
lock_ObtainWrite(&cm_serverLock);
if (volume == volp->vol[RWVOL].ID)
serverspp = &volp->vol[ROVOL].serversp;
else if (volume == volp->vol[BACKVOL].ID)
serverspp = &volp->vol[BACKVOL].serversp;
- else
- osi_panic("bad volume ID in cm_GetVolServers", __FILE__, __LINE__);
-
+ else {
+ lock_ReleaseWrite(&cm_serverLock);
+ if (firstTry) {
+ afs_int32 code;
+ firstTry = 0;
+ lock_ObtainWrite(&volp->rw);
+ volp->flags |= CM_VOLUMEFLAG_RESET;
+ code = cm_UpdateVolumeLocation(volp->cellp, userp, reqp, volp);
+ lock_ReleaseWrite(&volp->rw);
+ if (code == 0)
+ goto start;
+ }
+ return NULL;
+ }
+
/*
* Increment the refCount on deleted items as well.
* They will be freed by cm_FreeServerList when they get to zero
return id;
}
-void cm_RefreshVolumes(void)
+void cm_RefreshVolumes(int lifetime)
{
cm_volume_t *volp;
- cm_scache_t *scp;
afs_int32 refCount;
+ time_t now;
- cm_data.mountRootGen = time(NULL);
+ now = time(NULL);
- /* force a re-loading of volume data from the vldb */
+ /* force mount point target updates */
+ if (cm_data.mountRootGen + lifetime <= now)
+ cm_data.mountRootGen = now;
+
+ /*
+ * force a re-loading of volume data from the vldb
+ * if the lifetime for the cached data has expired
+ */
lock_ObtainRead(&cm_volumeLock);
for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
InterlockedIncrement(&volp->refCount);
lock_ReleaseRead(&cm_volumeLock);
- lock_ObtainWrite(&volp->rw);
- volp->flags |= CM_VOLUMEFLAG_RESET;
- lock_ReleaseWrite(&volp->rw);
-
+ if (!(volp->flags & CM_VOLUMEFLAG_RESET)) {
+ lock_ObtainWrite(&volp->rw);
+ if (volp->lastUpdateTime + lifetime <= now)
+ volp->flags |= CM_VOLUMEFLAG_RESET;
+ lock_ReleaseWrite(&volp->rw);
+ }
+
lock_ObtainRead(&cm_volumeLock);
refCount = InterlockedDecrement(&volp->refCount);
osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
}
lock_ReleaseRead(&cm_volumeLock);
-
- /* force mount points to be re-evaluated so that
- * if the volume location has changed we will pick
- * that up
- */
- for ( scp = cm_data.scacheLRUFirstp;
- scp;
- scp = (cm_scache_t *) osi_QNext(&scp->q)) {
- if ( scp->fileType == CM_SCACHETYPE_MOUNTPOINT
-#ifdef AFS_FREELANCE_CLIENT
- && !(scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID)
-#endif
- ) {
- lock_ObtainWrite(&scp->rw);
- scp->mountPointStringp[0] = '\0';
- lock_ReleaseWrite(&scp->rw);
- }
- }
-
}
void
char motd[256];
long alldown, alldeleted;
cm_serverRef_t *serversp;
+ cm_fid_t fid;
Name = volName;
OfflineMsg = offLineMsg;
MOTD = motd;
if (statep->ID != 0 && (!volID || volID == statep->ID)) {
+ /* create fid for volume root so that VNOVOL and VMOVED errors can be processed */
+ cm_SetFid(&fid, volp->cellp->cellID, statep->ID, 1, 1);
+
if (!statep->serversp && !(*volumeUpdatedp)) {
cm_InitReq(&req);
code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
if (statep->state == vl_busy || statep->state == vl_offline || statep->state == vl_unknown ||
(!alldown && statep->state == vl_alldown)) {
cm_InitReq(&req);
+ req.flags |= CM_REQ_OFFLINE_VOL_CHK;
lock_ReleaseWrite(&volp->rw);
do {
code = cm_ConnFromVolume(volp, statep->ID, cm_rootUserp, &req, &connp);
- if (code)
+ if (code)
continue;
rxconnp = cm_GetRxConn(connp);
code = RXAFS_GetVolumeStatus(rxconnp, statep->ID,
&volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(rxconnp);
-
- } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
+ rx_PutConnection(rxconnp);
+ } while (cm_Analyze(connp, cm_rootUserp, &req, &fid, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, &req);
lock_ObtainWrite(&volp->rw);
}
-/* called from the Daemon thread */
+/*
+ * called from the Daemon thread.
+ * when checking the offline status, check those of the most recently used volumes first.
+ */
void cm_CheckOfflineVolumes(void)
{
cm_volume_t *volp;
afs_int32 refCount;
+ extern int daemon_ShutdownFlag;
+ extern int powerStateSuspended;
lock_ObtainRead(&cm_volumeLock);
- for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
- if (volp->flags & CM_VOLUMEFLAG_IN_HASH) {
+ for (volp = cm_data.volumeLRULastp;
+ volp && !daemon_ShutdownFlag && !powerStateSuspended;
+ volp=(cm_volume_t *) osi_QPrev(&volp->q)) {
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH) {
InterlockedIncrement(&volp->refCount);
lock_ReleaseRead(&cm_volumeLock);
cm_CheckOfflineVolume(volp, 0);
cm_serverRef_t *tsrp;
cm_server_t *tsp;
int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
+ char addr[16];
if (!volp || !statep) {
#ifdef DEBUG
lock_ObtainWrite(&cm_serverLock);
for (tsrp = statep->serversp; tsrp; tsrp=tsrp->next) {
- if (tsrp->status == srv_deleted)
- continue;
tsp = tsrp->server;
+ sprintf(addr, "%d.%d.%d.%d",
+ ((tsp->addr.sin_addr.s_addr & 0xff)),
+ ((tsp->addr.sin_addr.s_addr & 0xff00)>> 8),
+ ((tsp->addr.sin_addr.s_addr & 0xff0000)>> 16),
+ ((tsp->addr.sin_addr.s_addr & 0xff000000)>> 24));
+
+ if (tsrp->status == srv_deleted) {
+ osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s deleted",
+ statep->ID, osi_LogSaveString(afsd_logp,addr));
+ continue;
+ }
if (tsp) {
cm_GetServerNoLock(tsp);
if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
allDown = 0;
if (tsrp->status == srv_busy) {
+ osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s busy",
+ statep->ID, osi_LogSaveString(afsd_logp,addr));
allOffline = 0;
someBusy = 1;
} else if (tsrp->status == srv_offline) {
+ osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s offline",
+ statep->ID, osi_LogSaveString(afsd_logp,addr));
allBusy = 0;
someOffline = 1;
} else {
+ osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s online",
+ statep->ID, osi_LogSaveString(afsd_logp,addr));
allOffline = 0;
allBusy = 0;
}
+ } else {
+ osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s down",
+ statep->ID, osi_LogSaveString(afsd_logp,addr));
}
cm_PutServerNoLock(tsp);
}
}
lock_ReleaseWrite(&cm_serverLock);
+ osi_Log5(afsd_logp, "cm_UpdateVolumeStatusInt allDown %d allBusy %d someBusy %d someOffline %d allOffline %d",
+ allDown, allBusy, someBusy, someOffline, allOffline);
+
if (allDown)
newStatus = vl_alldown;
else if (allBusy || (someBusy && someOffline))
lock_ObtainRead(&cm_volumeLock);
}
- sprintf(output, "%s - dumping volumes - cm_data.currentVolumes=%d, cm_data.maxVolumes=%d\r\n", cookie, cm_data.currentVolumes, cm_data.maxVolumes);
+ sprintf(output, "%s - dumping volumes - cm_data.currentVolumes=%d, cm_data.maxVolumes=%d\r\n",
+ cookie, cm_data.currentVolumes, cm_data.maxVolumes);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
{
- sprintf(output, "%s - volp=0x%p cell=%s name=%s rwID=%u roID=%u bkID=%u flags=0x%x refCount=%u\r\n",
- cookie, volp, volp->cellp->name, volp->namep, volp->vol[RWVOL].ID, volp->vol[ROVOL].ID, volp->vol[BACKVOL].ID, volp->flags,
+ time_t t;
+ char *srvStr = NULL;
+ afs_uint32 srvStrRpc = TRUE;
+ char *cbt = NULL;
+ char *cdrot = NULL;
+
+ if (volp->cbServerpRO) {
+ if (!((volp->cbServerpRO->flags & CM_SERVERFLAG_UUID) &&
+ UuidToString((UUID *)&volp->cbServerpRO->uuid, &srvStr) == RPC_S_OK)) {
+ afs_asprintf(&srvStr, "%.0I", volp->cbServerpRO->addr.sin_addr.s_addr);
+ srvStrRpc = FALSE;
+ }
+ }
+ if (volp->cbExpiresRO) {
+ t = volp->cbExpiresRO;
+ cbt = ctime(&t);
+ if (cbt) {
+ cbt = strdup(cbt);
+ cbt[strlen(cbt)-1] = '\0';
+ }
+ }
+ if (volp->creationDateRO) {
+ t = volp->creationDateRO;
+ cdrot = ctime(&t);
+ if (cdrot) {
+ cdrot = strdup(cdrot);
+ cdrot[strlen(cdrot)-1] = '\0';
+ }
+ }
+
+ sprintf(output,
+ "%s - volp=0x%p cell=%s name=%s rwID=%u roID=%u bkID=%u flags=0x%x:%x "
+ "cbServerpRO='%s' cbExpiresRO='%s' creationDateRO='%s' refCount=%u\r\n",
+ cookie, volp, volp->cellp->name, volp->namep, volp->vol[RWVOL].ID,
+ volp->vol[ROVOL].ID, volp->vol[BACKVOL].ID, volp->flags, volp->qflags,
+ srvStr ? srvStr : "<none>", cbt ? cbt : "<none>", cdrot ? cdrot : "<none>",
volp->refCount);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
+
+ if (srvStr) {
+ if (srvStrRpc)
+ RpcStringFree(&srvStr);
+ else
+ free(srvStr);
+ }
+ if (cbt)
+ free(cbt);
+ if (cdrot)
+ free(cdrot);
}
sprintf(output, "%s - Done dumping volumes.\r\n", cookie);
WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
{
int i;
- if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
return;
i = CM_VOLUME_NAME_HASH(volp->namep);
volp->nameNextp = cm_data.volumeNameHashTablep[i];
cm_data.volumeNameHashTablep[i] = volp;
- volp->flags |= CM_VOLUMEFLAG_IN_HASH;
+ volp->qflags |= CM_VOLUME_QFLAG_IN_HASH;
}
/* call with volume write-locked and mutex held */
cm_volume_t *tvolp;
int i;
- if (volp->flags & CM_VOLUMEFLAG_IN_HASH) {
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH) {
/* hash it out first */
i = CM_VOLUME_NAME_HASH(volp->namep);
for (lvolpp = &cm_data.volumeNameHashTablep[i], tvolp = cm_data.volumeNameHashTablep[i];
lvolpp = &tvolp->nameNextp, tvolp = tvolp->nameNextp) {
if (tvolp == volp) {
*lvolpp = volp->nameNextp;
- volp->flags &= ~CM_VOLUMEFLAG_IN_HASH;
+ volp->qflags &= ~CM_VOLUME_QFLAG_IN_HASH;
volp->nameNextp = NULL;
break;
}
statep = cm_VolumeStateByType(volp, volType);
- if (statep->flags & CM_VOLUMEFLAG_IN_HASH)
+ if (statep->qflags & CM_VOLUME_QFLAG_IN_HASH)
return;
i = CM_VOLUME_ID_HASH(statep->ID);
cm_data.volumeBKIDHashTablep[i] = volp;
break;
}
- statep->flags |= CM_VOLUMEFLAG_IN_HASH;
+ statep->qflags |= CM_VOLUME_QFLAG_IN_HASH;
}
statep = cm_VolumeStateByType(volp, volType);
- if (statep->flags & CM_VOLUMEFLAG_IN_HASH) {
+ if (statep->qflags & CM_VOLUME_QFLAG_IN_HASH) {
/* hash it out first */
i = CM_VOLUME_ID_HASH(statep->ID);
do {
if (tvolp == volp) {
*lvolpp = statep->nextp;
- statep->flags &= ~CM_VOLUMEFLAG_IN_HASH;
+ statep->qflags &= ~CM_VOLUME_QFLAG_IN_HASH;
statep->nextp = NULL;
break;
}
/* must be called with cm_volumeLock write-locked! */
void cm_AdjustVolumeLRU(cm_volume_t *volp)
{
- if (volp == cm_data.volumeLRULastp)
- cm_data.volumeLRULastp = (cm_volume_t *) osi_QPrev(&volp->q);
- if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
+ lock_AssertWrite(&cm_volumeLock);
+
+ if (volp == cm_data.volumeLRUFirstp)
+ return;
+
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
- osi_QAdd((osi_queue_t **) &cm_data.volumeLRUFirstp, &volp->q);
- volp->flags |= CM_VOLUMEFLAG_IN_LRU_QUEUE;
- if (!cm_data.volumeLRULastp)
- cm_data.volumeLRULastp = volp;
+ osi_QAddH((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
+ volp->qflags |= CM_VOLUME_QFLAG_IN_LRU_QUEUE;
+
+ osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
}
/* must be called with cm_volumeLock write-locked! */
void cm_MoveVolumeToLRULast(cm_volume_t *volp)
{
+ lock_AssertWrite(&cm_volumeLock);
+
if (volp == cm_data.volumeLRULastp)
return;
- if (volp == cm_data.volumeLRUFirstp)
- cm_data.volumeLRUFirstp = (cm_volume_t *) osi_QNext(&volp->q);
- if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
osi_QAddT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
- volp->flags |= CM_VOLUMEFLAG_IN_LRU_QUEUE;
- if (!cm_data.volumeLRULastp)
- cm_data.volumeLRULastp = volp;
+ volp->qflags |= CM_VOLUME_QFLAG_IN_LRU_QUEUE;
+
+ osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
}
/* must be called with cm_volumeLock write-locked! */
void cm_RemoveVolumeFromLRU(cm_volume_t *volp)
{
- if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE) {
- if (volp == cm_data.volumeLRULastp)
- cm_data.volumeLRULastp = (cm_volume_t *) osi_QPrev(&volp->q);
+ lock_AssertWrite(&cm_volumeLock);
+
+ if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) {
osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
- volp->flags &= ~CM_VOLUMEFLAG_IN_LRU_QUEUE;
+ volp->qflags &= ~CM_VOLUME_QFLAG_IN_LRU_QUEUE;
}
+
+ osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
}
static char * volstatus_str(enum volstatus vs)
{
cm_volume_t * volp;
time_t minexp = time(NULL) + 90 * 60;
+ extern int daemon_ShutdownFlag;
+ extern int powerStateSuspended;
lock_ObtainRead(&cm_volumeLock);
- for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
+ for (volp = cm_data.allVolumesp;
+ volp && !daemon_ShutdownFlag && !powerStateSuspended;
+ volp=volp->allNextp) {
if ( volp->cbExpiresRO > 0 && volp->cbExpiresRO < minexp) {
cm_req_t req;
cm_fid_t fid;
return statep;
}
+afs_int32
+cm_VolumeType(cm_volume_t *volp, afs_uint32 id)
+{
+ if (id == volp->vol[RWVOL].ID)
+ return(RWVOL);
+ else if (id == volp->vol[ROVOL].ID)
+ return(ROVOL);
+ else if (id == volp->vol[BACKVOL].ID)
+ return (BACKVOL);
+
+ return -1;
+}
git://git.openafs.org / openafs.git / blobdiff