#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
-
-#ifdef HAVE_STRING_H
#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-#endif
#ifndef AFS_LINUX20_ENV
#include <net/if.h>
H_LOCK;
retry:
tclient = h_FindClient_r(*tconn);
+ if (!tclient) {
+ ViceLog(0, ("CallPreamble: Couldn't get CPS. Too many lockers\n"));
+ H_UNLOCK;
+ return VBUSY;
+ }
thost = tclient->host;
if (tclient->prfail == 1) { /* couldn't get the CPS */
if (!retry_flag) {
hpr_End(uclient);
code = hpr_Initialize(&uclient);
- assert(pthread_setspecific(viced_uclient_key, (void *)uclient) == 0);
+ if (!code)
+ assert(pthread_setspecific(viced_uclient_key, (void *)uclient) == 0);
H_LOCK;
#else
code = pr_Initialize(2, AFSDIR_SERVER_ETC_DIRPATH, 0);
H_LOCK;
tclient = h_FindClient_r(aconn);
+ if (!tclient)
+ goto busyout;
thost = tclient->host;
if (thost->hostFlags & HERRORTRANS)
translate = 1;
afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port),
thost));
}
+ busyout:
H_UNLOCK;
return (translate ? sys_error_to_et(ret) : ret);
} /*CallPostamble */
extern int VInit;
while (1) {
+ int restarting =
+#ifdef AFS_DEMAND_ATTACH_FS
+ VSALVAGE
+#else
+ VRESTARTING
+#endif
+ ;
+
errorCode = 0;
*volptr = VGetVolume(&local_errorCode, &errorCode, (afs_int32) fid->Volume);
if (!errorCode) {
if (restartedat.tv_sec == 0) {
/* I'm not really worried about when we restarted, I'm */
/* just worried about when the first VBUSY was returned. */
- TM_GetTimeOfDay(&restartedat, 0);
+ FT_GetTimeOfDay(&restartedat, 0);
if (busyonrst) {
FS_LOCK;
afs_perfstats.fs_nBusies++;
FS_UNLOCK;
}
- return (busyonrst ? VBUSY : VRESTARTING);
+ return (busyonrst ? VBUSY : restarting);
} else {
struct timeval now;
- TM_GetTimeOfDay(&now, 0);
+ FT_GetTimeOfDay(&now, 0);
if ((now.tv_sec - restartedat.tv_sec) < (11 * 60)) {
if (busyonrst) {
FS_LOCK;
afs_perfstats.fs_nBusies++;
FS_UNLOCK;
}
- return (busyonrst ? VBUSY : VRESTARTING);
+ return (busyonrst ? VBUSY : restarting);
} else {
- return (VRESTARTING);
+ return (restarting);
}
}
}
* must check local_errorCode because demand attach fs
* can have local_errorCode == VSALVAGING, errorCode == VBUSY */
else if (local_errorCode == VBUSY && lock == READ_LOCK) {
+#ifdef AFS_DEMAND_ATTACH_FS
+ /* DAFS case is complicated by the fact that local_errorCode can
+ * be VBUSY in cases where the volume is truly offline */
+ if (!*volptr) {
+ /* volume is in VOL_STATE_UNATTACHED */
+ return (errorCode);
+ }
+#endif /* AFS_DEMAND_ATTACH_FS */
errorCode = 0;
break;
} else if (errorCode)
}
ino = VN_GET_INO(targetptr);
- assert(VALID_INO(ino));
+ if (!VALID_INO(ino)) {
+ free(buff);
+ VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
+ return EIO;
+ }
targFdP = IH_OPEN(targetptr->handle);
if (targFdP == NULL) {
rc = errno;
*/
if ((*targetptr)->disk.uniquifier != fileFid->Unique) {
VTakeOffline(volptr);
+ ViceLog(0,
+ ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
errorCode = VSALVAGE;
return errorCode;
}
if (IsEmpty(&childdir) != 0)
return (EEXIST);
DZap(&childdir);
+ FidZap(&childdir);
(*targetptr)->delete = 1;
} else if ((--(*targetptr)->disk.linkCount) == 0)
(*targetptr)->delete = 1;
errno));
if (errno != ENOENT)
{
+ VTakeOffline(volptr);
ViceLog(0,
("Volume %u now offline, must be salvaged.\n",
volptr->hashid));
- VTakeOffline(volptr);
return (EIO);
}
DT1++;
("Error %d deleting %s\n", code,
(((*targetptr)->disk.type ==
Directory) ? "directory" : "file")));
+ VTakeOffline(volptr);
ViceLog(0,
("Volume %u now offline, must be salvaged.\n",
volptr->hashid));
- VTakeOffline(volptr);
if (!errorCode)
errorCode = code;
}
AdjustDiskUsage(volptr, BlocksPreallocatedForVnode,
BlocksPreallocatedForVnode))) {
ViceLog(25,
- ("Insufficient space to allocate %lld blocks\n",
+ ("Insufficient space to allocate %" AFS_INT64_FMT " blocks\n",
(afs_intmax_t) BlocksPreallocatedForVnode));
return (errorCode);
}
0;
Time += AFS_LOCKWAIT;
if (LockingType == LockRead) {
- if ( !(rights & PRSFS_LOCK) )
- return(EACCES);
+ if ( !(rights & PRSFS_LOCK) &&
+ !(rights & PRSFS_WRITE) &&
+ !(OWNSp(client, targetptr) && (rights & PRSFS_INSERT)) )
+ return(EACCES);
if (targetptr->disk.lock.lockCount >= 0) {
++(targetptr->disk.lock.lockCount);
status->MinQuota = V_minquota(volptr);
status->MaxQuota = V_maxquota(volptr);
status->BlocksInUse = V_diskused(volptr);
- status->PartBlocksAvail = volptr->partition->free;
- status->PartMaxBlocks = volptr->partition->totalUsable;
+ status->PartBlocksAvail = RoundInt64ToInt32(volptr->partition->free);
+ status->PartMaxBlocks = RoundInt64ToInt32(volptr->partition->totalUsable);
/* now allocate and copy these things; they're freed by the RXGEN stub */
temp = strlen(V_name(volptr)) + 1;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
ViceLog(1,
/*
* Remember when the data transfer started.
*/
- TM_GetTimeOfDay(&xferStartTime, 0);
+ FT_GetTimeOfDay(&xferStartTime, 0);
#endif /* FS_STATS_DETAILED */
/* actually do the data transfer */
* integrate the transfer size and elapsed time into the stats. If the
* operation failed, we jump to the appropriate point.
*/
- TM_GetTimeOfDay(&xferStopTime, 0);
+ FT_GetTimeOfDay(&xferStopTime, 0);
FS_LOCK;
(xferP->numXfers)++;
if (!errorCode) {
errorCode = CallPostamble(tcon, errorCode, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
ViceLog(1,
errorCode = CallPostamble(tcon, errorCode, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
ViceLog(1, ("SAFS_BulkStatus\n"));
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
ViceLog(1, ("SAFS_InlineBulkStatus\n"));
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
ViceLog(1,
("StoreData: Fid = %u.%u.%u\n", Fid->Volume, Fid->Vnode,
Fid->Unique));
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
FS_LOCK;
/*
* Remember when the data transfer started.
*/
- TM_GetTimeOfDay(&xferStartTime, 0);
+ FT_GetTimeOfDay(&xferStartTime, 0);
#endif /* FS_STATS_DETAILED */
/* Do the actual storing of the data */
* integrate the transfer size and elapsed time into the stats. If the
* operation failed, we jump to the appropriate point.
*/
- TM_GetTimeOfDay(&xferStopTime, 0);
+ FT_GetTimeOfDay(&xferStopTime, 0);
FS_LOCK;
(xferP->numXfers)++;
if (!errorCode) {
errorCode = CallPostamble(tcon, errorCode, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
goto Bad_StoreACL;
errorCode = CallPostamble(tcon, errorCode, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
memset(OutFid, 0, sizeof(struct AFSFid));
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
VPutVnode(&errorCode, testvptr);
if ((top == 1) && (testnode != 0)) {
VTakeOffline(volptr);
+ ViceLog(0,
+ ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
errorCode = EIO;
goto Bad_Rename;
}
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
/* Write the contents of the symbolic link name into the target inode */
fdP = IH_OPEN(targetptr->handle);
- assert(fdP != NULL);
+ if (fdP == NULL) {
+ (void)PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr,
+ volptr, &client);
+ VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
+ return EIO;
+ }
len = strlen((char *) LinkContents);
- code = (len == FDH_WRITE(fdP, (char *) LinkContents, len)) ? 0 : VDISKFULL;
- if (code) ViceLog(0, ("SAFSS_Symlink FDH_WRITE failed for len=%d, Fid=%u.%d.%d\n", len, OutFid->Volume, OutFid->Vnode, OutFid->Unique));
+ code = (len == FDH_WRITE(fdP, (char *) LinkContents, len)) ? 0 : VDISKFULL;
+ if (code)
+ ViceLog(0, ("SAFSS_Symlink FDH_WRITE failed for len=%d, Fid=%u.%d.%d\n", len, OutFid->Volume, OutFid->Vnode, OutFid->Unique));
FDH_CLOSE(fdP);
/*
* Set up and return modified status for the parent dir and new symlink
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
goto Bad_MakeDir;
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
struct timeval time;
/* this works on all system types */
- TM_GetTimeOfDay(&time, 0);
+ FT_GetTimeOfDay(&time, 0);
stats->CurrentTime = time.tv_sec;
} /*SetSystemStats */
void
SetVolumeStats(struct AFSStatistics *stats)
{
- struct DiskPartition *part;
+ struct DiskPartition64 *part;
int i = 0;
for (part = DiskPartitionList; part && i < AFS_MSTATDISKS;
part = part->next) {
- stats->Disks[i].TotalBlocks = part->totalUsable;
- stats->Disks[i].BlocksAvailable = part->free;
+ stats->Disks[i].TotalBlocks = RoundInt64ToInt32(part->totalUsable);
+ stats->Disks[i].BlocksAvailable = RoundInt64ToInt32(part->free);
memset(stats->Disks[i].Name, 0, AFS_DISKNAMESIZE);
strncpy(stats->Disks[i].Name, part->name, AFS_DISKNAMESIZE);
i++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, NOTACTIVECALL, &tcon, &thost)))
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
+ if (code == 0) {
+ FS_LOCK;
+ (opP->numSuccesses)++;
+ fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
+ fs_stats_AddTo((opP->sumTime), elapsedTime);
+ fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
+ if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
+ fs_stats_TimeAssign((opP->minTime), elapsedTime);
+ }
+ if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
+ fs_stats_TimeAssign((opP->maxTime), elapsedTime);
+ }
+ FS_UNLOCK;
+ }
+#endif /* FS_STATS_DETAILED */
+
+ osi_auditU(acall, GetStatisticsEvent, code,
+ AUD_ID, t_client ? t_client->ViceId : 0, AUD_END);
+ return code;
+} /*SRXAFS_GetStatistics */
+
+
+afs_int32
+SRXAFS_GetStatistics64(struct rx_call *acall, afs_int32 statsVersion, ViceStatistics64 *Statistics)
+{
+ extern afs_int32 StartTime, CurrentConnections;
+ int seconds;
+ afs_int32 code;
+ struct rx_connection *tcon = rx_ConnectionOf(acall);
+ struct host *thost;
+ struct client *t_client = NULL; /* tmp ptr to client data */
+ struct timeval time;
+#if FS_STATS_DETAILED
+ struct fs_stats_opTimingData *opP; /* Ptr to this op's timing struct */
+ struct timeval opStartTime, opStopTime; /* Start/stop times for RPC op */
+ struct timeval elapsedTime; /* Transfer time */
+
+ /*
+ * Set our stats pointer, remember when the RPC operation started, and
+ * tally the operation.
+ */
+ opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_GETSTATISTICS]);
+ FS_LOCK;
+ (opP->numOps)++;
+ FS_UNLOCK;
+ FT_GetTimeOfDay(&opStartTime, 0);
+#endif /* FS_STATS_DETAILED */
+
+ if ((code = CallPreamble(acall, NOTACTIVECALL, &tcon, &thost)))
+ goto Bad_GetStatistics64;
+
+ ViceLog(1, ("SAFS_GetStatistics64 Received\n"));
+ Statistics->ViceStatistics64_val =
+ malloc(statsVersion*sizeof(afs_int64));
+ Statistics->ViceStatistics64_len = statsVersion;
+ FS_LOCK;
+ AFSCallStats.GetStatistics++, AFSCallStats.TotalCalls++;
+ Statistics->ViceStatistics64_val[STATS64_STARTTIME] = StartTime;
+ Statistics->ViceStatistics64_val[STATS64_CURRENTCONNECTIONS] =
+ CurrentConnections;
+ Statistics->ViceStatistics64_val[STATS64_TOTALVICECALLS] =
+ AFSCallStats.TotalCalls;
+ Statistics->ViceStatistics64_val[STATS64_TOTALFETCHES] =
+ AFSCallStats.FetchData + AFSCallStats.FetchACL +
+ AFSCallStats.FetchStatus;
+ Statistics->ViceStatistics64_val[STATS64_FETCHDATAS] =
+ AFSCallStats.FetchData;
+ Statistics->ViceStatistics64_val[STATS64_FETCHEDBYTES] =
+ AFSCallStats.TotalFetchedBytes;
+ seconds = AFSCallStats.AccumFetchTime / 1000;
+ if (seconds <= 0)
+ seconds = 1;
+ Statistics->ViceStatistics64_val[STATS64_FETCHDATARATE] =
+ AFSCallStats.TotalFetchedBytes / seconds;
+ Statistics->ViceStatistics64_val[STATS64_TOTALSTORES] =
+ AFSCallStats.StoreData + AFSCallStats.StoreACL +
+ AFSCallStats.StoreStatus;
+ Statistics->ViceStatistics64_val[STATS64_STOREDATAS] =
+ AFSCallStats.StoreData;
+ Statistics->ViceStatistics64_val[STATS64_STOREDBYTES] =
+ AFSCallStats.TotalStoredBytes;
+ seconds = AFSCallStats.AccumStoreTime / 1000;
+ if (seconds <= 0)
+ seconds = 1;
+ Statistics->ViceStatistics64_val[STATS64_STOREDATARATE] =
+ AFSCallStats.TotalStoredBytes / seconds;
+#ifdef AFS_NT40_ENV
+ Statistics->ViceStatistics64_val[STATS64_PROCESSSIZE] = -1;
+#else
+ Statistics->ViceStatistics64_val[STATS64_PROCESSSIZE] =
+ (afs_int32) ((long)sbrk(0) >> 10);
+#endif
+ FS_UNLOCK;
+ h_GetWorkStats((int *)&(Statistics->ViceStatistics64_val[STATS64_WORKSTATIONS]),
+ (int *)&(Statistics->ViceStatistics64_val[STATS64_ACTIVEWORKSTATIONS]),
+ (int *)0,
+ (afs_int32) (FT_ApproxTime()) - (15 * 60));
+
+
+
+ /* this works on all system types */
+ FT_GetTimeOfDay(&time, 0);
+ Statistics->ViceStatistics64_val[STATS64_CURRENTTIME] = time.tv_sec;
+
+ Bad_GetStatistics64:
+ code = CallPostamble(tcon, code, thost);
+
+ t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+
+#if FS_STATS_DETAILED
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
*a_versionP = AFS_XSTAT_VERSION;
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
fs_stats_AddTo((opP->sumTime), elapsedTime);
fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
/*
} /*Switch on collection number */
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if (FidArray)
(tcon->peer ? tcon->peer->host : 0)));
errorCode = GetClient(tcon, &client);
if (!errorCode) {
+ H_LOCK;
DeleteAllCallBacks_r(client->host, 1);
+ H_UNLOCK;
PutClient(&client);
}
} else {
errorCode = CallPostamble(tcon, errorCode, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
goto Bad_GetVolumeInfo;
code = CallPostamble(tcon, code, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
ViceLog(1, ("SAFS_GetVolumeStatus for volume %u\n", avolid));
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
ViceLog(1, ("SAFS_SetVolumeStatus for volume %u\n", avolid));
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
return FSERR_EOPNOTSUPP;
errorCode = CallPostamble(tcon, errorCode, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (errorCode == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
code = CallPostamble(tcon, code, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
if (code == 0) {
FS_LOCK;
(opP->numSuccesses)++;
FS_LOCK;
(opP->numOps)++;
FS_UNLOCK;
- TM_GetTimeOfDay(&opStartTime, 0);
+ FT_GetTimeOfDay(&opStartTime, 0);
#endif /* FS_STATS_DETAILED */
if ((code = CallPreamble(acall, NOTACTIVECALL, &tcon, &thost)))
FS_LOCK;
AFSCallStats.GetTime++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
- TM_GetTimeOfDay(&tpl, 0);
+ FT_GetTimeOfDay(&tpl, 0);
*Seconds = tpl.tv_sec;
*USeconds = tpl.tv_usec;
code = CallPostamble(tcon, code, thost);
#if FS_STATS_DETAILED
- TM_GetTimeOfDay(&opStopTime, 0);
+ FT_GetTimeOfDay(&opStopTime, 0);
fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
if (code == 0) {
FS_LOCK;
rx_Write(Call, (char *)&zero, sizeof(afs_int32)); /* send 0-length */
return (0);
}
- TM_GetTimeOfDay(&StartTime, 0);
+ FT_GetTimeOfDay(&StartTime, 0);
ihP = targetptr->handle;
fdP = IH_OPEN(ihP);
if (fdP == NULL) {
VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
return EIO;
}
optSize = sendBufSize;
if (tlen < 0) {
FDH_CLOSE(fdP);
VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
return EIO;
}
if (Pos > tlen) {
FDH_CLOSE(fdP);
FreeSendBuffer((struct afs_buffer *)tbuffer);
VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
return EIO;
}
errorCode = rx_Write(Call, tbuffer, wlen);
if (errorCode != wlen) {
FDH_CLOSE(fdP);
VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
return EIO;
}
errorCode = rx_Writev(Call, tiov, tnio, wlen);
FreeSendBuffer((struct afs_buffer *)tbuffer);
#endif /* AFS_NT40_ENV */
FDH_CLOSE(fdP);
- TM_GetTimeOfDay(&StopTime, 0);
+ FT_GetTimeOfDay(&StopTime, 0);
/* Adjust all Fetch Data related stats */
FS_LOCK;
afs_sfsize_t tlen; /* temp for xfr length */
Inode tinode; /* inode for I/O */
afs_int32 optSize; /* optimal transfer size */
- afs_sfsize_t DataLength; /* size of inode */
+ afs_sfsize_t DataLength = 0; /* size of inode */
afs_sfsize_t TruncatedLength; /* size after ftruncate */
afs_fsize_t NewLength; /* size after this store completes */
afs_sfsize_t adjustSize; /* bytes to call VAdjust... with */
- int linkCount; /* link count on inode */
+ int linkCount = 0; /* link count on inode */
FdHandle_t *fdP;
struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
if (GetLinkCountAndSize(volptr, fdP, &linkCount, &DataLength) < 0) {
FDH_CLOSE(fdP);
VTakeOffline(volptr);
+ ViceLog(0, ("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
return EIO;
}
}
tinode = VN_GET_INO(targetptr);
}
- assert(VALID_INO(tinode));
+ if (!VALID_INO(tinode)) {
+ VTakeOffline(volptr);
+ ViceLog(0,("Volume %u now offline, must be salvaged.\n",
+ volptr->hashid));
+ return EIO;
+ }
/* compute new file length */
NewLength = DataLength;
/* this bit means that the locks are set and protections are OK */
rx_SetLocalStatus(Call, 1);
- TM_GetTimeOfDay(&StartTime, 0);
+ FT_GetTimeOfDay(&StartTime, 0);
optSize = sendBufSize;
ViceLog(25,
}
FDH_CLOSE(fdP);
- TM_GetTimeOfDay(&StopTime, 0);
+ FT_GetTimeOfDay(&StopTime, 0);
VN_SET_LEN(targetptr, NewLength);
#else
H_LOCK;
tclient = h_FindClient_r(tcon);
+ if (!tclient) {
+ errorCode = VBUSY;
+ goto Bad_CallBackRxConnAddr;
+ }
thost = tclient->host;
/* nothing more can be done */
if ( !thost->interface )
goto Bad_CallBackRxConnAddr;
- assert(thost->interface->numberOfInterfaces > 0 );
-
/* the only address is the primary interface */
/* can't change when there's only 1 address, anyway */
- if ( thost->interface->numberOfInterfaces == 1 )
+ if ( thost->interface->numberOfInterfaces <= 1 )
goto Bad_CallBackRxConnAddr;
/* initialise a security object only once */
git://git.openafs.org / openafs.git / blobdiff