#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>
#include <afs/cellconfig.h>
#include <afs/keys.h>
-#include <afs/auth.h>
#include <signal.h>
#include <afs/partition.h>
#include "viced_prototypes.h"
char hoststr[16], hoststr2[16];
struct ubik_client *uclient;
+ *ahostp = NULL;
+
if (!tconn) {
ViceLog(0, ("CallPreamble: unexpected null tconn!\n"));
return -1;
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);
if (BreakDelayedCallBacks_r(thost)) {
ViceLog(0,
("BreakDelayedCallbacks FAILED for host %s:%d which IS UP. Connection from %s:%d. Possible network or routing failure.\n",
- afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), rxr_AddrStringOf(*tconn),
+ afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), afs_inet_ntoa_r(rxr_HostOf(*tconn), hoststr2),
ntohs(rxr_PortOf(*tconn))));
if (MultiProbeAlternateAddress_r(thost)) {
ViceLog(0,
if (BreakDelayedCallBacks_r(thost)) {
ViceLog(0,
("BreakDelayedCallbacks FAILED AGAIN for host %s:%d which IS UP. Connection from %s:%d. Possible network or routing failure.\n",
- afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), rxr_AddrStringOf(*tconn),
+ afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), afs_inet_ntoa_r(rxr_HostOf(*tconn), hoststr2),
ntohs(rxr_PortOf(*tconn))));
code = -1;
}
H_LOCK;
tclient = h_FindClient_r(aconn);
+ if (!tclient)
+ goto busyout;
thost = tclient->host;
if (thost->hostFlags & HERRORTRANS)
translate = 1;
held = h_Held_r(thost);
if (held)
h_Release_r(thost);
- if (ahost != thost) {
+ if (ahost && ahost != thost) {
char hoststr[16], hoststr2[16];
ViceLog(0, ("CallPostamble: ahost %s:%d (%x) != thost %s:%d (%x)\n",
- afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port),
+ afs_inet_ntoa_r(ahost->host, hoststr), ntohs(ahost->port),
ahost,
afs_inet_ntoa_r(thost->host, hoststr2), ntohs(thost->port),
thost));
h_Release_r(ahost);
+ } else if (!ahost) {
+ char hoststr[16];
+ ViceLog(0, ("CallPostamble: null ahost for thost %s:%d (%x)\n",
+ 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) {
afs_perfstats.fs_nBusies++;
FS_UNLOCK;
}
- return (busyonrst ? VBUSY : VRESTARTING);
+ return (busyonrst ? VBUSY : restarting);
} else {
struct timeval now;
TM_GetTimeOfDay(&now, 0);
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;
("CopyOnWrite failed: volume %u in partition %s (tried reading %u, read %u, wrote %u, errno %u) volume needs salvage\n",
V_id(volptr), volptr->partition->name, length, rdlen,
wrlen, errno));
-#ifdef FAST_RESTART /* if running in no-salvage, don't core the server */
- ViceLog(0, ("CopyOnWrite failed: taking volume offline\n"));
-#elif defined(AFS_DEMAND_ATTACH_FS)
+#if defined(AFS_DEMAND_ATTACH_FS)
ViceLog(0, ("CopyOnWrite failed: requesting salvage\n"));
-#else /* Avoid further corruption and try to get a core. */
- assert(0);
+#else
+ ViceLog(0, ("CopyOnWrite failed: taking volume offline\n"));
#endif
/* Decrement this inode so salvager doesn't find it. */
FDH_REALLYCLOSE(newFdP);
*/
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;
}
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);
+ 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;
struct host *thost;
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#if FS_STATS_DETAILED
struct fs_stats_opTimingData *opP; /* Ptr to this op's timing struct */
struct fs_stats_xferData *xferP; /* Ptr to this op's byte size struct */
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(5,
("SRXAFS_FetchData, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
- Fid->Volume, Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
/*
* Get volume/vnode for the fetched file; caller's access rights to
struct rx_connection *tcon = rx_ConnectionOf(acall);
struct host *thost;
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#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 */
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(5,
("SAFS_FetchACL, Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
AccessList->AFSOpaque_len = 0;
struct client *client = 0; /* pointer to the client data */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_FetchStatus, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
- Fid->Volume, Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.FetchStatus++, AFSCallStats.TotalCalls++;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon;
struct host *thost;
#if FS_STATS_DETAILED
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(5,
("StoreData: Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
/*
struct rx_connection *tcon;
struct host *thost;
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#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 */
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_StoreACL, Fid = %u.%u.%u, ACL=%s, Host %s:%d, Id %d\n",
Fid->Volume, Fid->Vnode, Fid->Unique, AccessList->AFSOpaque_val,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.StoreACL++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_StoreStatus, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
- Fid->Volume, Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.StoreStatus++, AFSCallStats.TotalCalls++;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_RemoveFile %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.RemoveFile++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_CreateFile %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.CreateFile++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
int doDelete; /* deleted the rename target (ref count now 0) */
int code;
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&olddir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_Rename %s to %s, Fid = %u.%u.%u to %u.%u.%u, Host %s:%d, Id %d\n",
OldName, NewName, OldDirFid->Volume, OldDirFid->Vnode,
OldDirFid->Unique, NewDirFid->Volume, NewDirFid->Vnode,
- NewDirFid->Unique, rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ NewDirFid->Unique, inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.Rename++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
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;
}
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
FdHandle_t *fdP;
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_Symlink %s to %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
LinkContents, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.Symlink++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
/* 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
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_Link %s, Did = %u.%u.%u, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
ExistingFid->Volume, ExistingFid->Vnode, ExistingFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.Link++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_MakeDir %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.MakeDir++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
afs_int32 rights, anyrights; /* rights for this and any user */
Vnode debugvnode1, debugvnode2;
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_RemoveDir %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.RemoveDir++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
static char *locktype[4] = { "LockRead", "LockWrite", "LockExtend", "LockRelease" };
struct rx_connection *tcon = rx_ConnectionOf(acall);
}
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_SetLock type = %s Fid = %u.%u.%u, Host %s:%d, Id %d\n",
locktype[(int)type], Fid->Volume, Fid->Vnode, Fid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.SetLock++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_ExtendLock Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.ExtendLock++, AFSCallStats.TotalCalls++;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_ReleaseLock Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.ReleaseLock++, AFSCallStats.TotalCalls++;
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++;
} /*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;
+ TM_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 */
+ TM_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
+ TM_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 */
+
+
/*------------------------------------------------------------------------
* EXPORTED SRXAFS_XStatsVersion
*
if (!FidArray && !CallBackArray) {
ViceLog(1,
- ("SAFS_GiveUpAllCallBacks: host=%s\n",
- (tcon->peer ? rx_AddrStringOf(tcon->peer) : "<unknown>")));
+ ("SAFS_GiveUpAllCallBacks: host=%x\n",
+ (tcon->peer ? tcon->peer->host : 0)));
errorCode = GetClient(tcon, &client);
if (!errorCode) {
+ H_LOCK;
DeleteAllCallBacks_r(client->host, 1);
+ H_UNLOCK;
PutClient(&client);
}
} else {
if (FidArray->AFSCBFids_len < CallBackArray->AFSCBs_len) {
ViceLog(0,
- ("GiveUpCallBacks: #Fids %d < #CallBacks %d, host=%s\n",
+ ("GiveUpCallBacks: #Fids %d < #CallBacks %d, host=%x\n",
FidArray->AFSCBFids_len, CallBackArray->AFSCBs_len,
- (tcon->peer ? rx_AddrStringOf(tcon->peer) : "<unknown>")));
+ (tcon->peer ? tcon->peer->host : 0)));
errorCode = EINVAL;
goto Bad_GiveUpCallBacks;
}
dataBytes = 1 * sizeof(afs_int32);
dataBuffP = (afs_int32 *) malloc(dataBytes);
- dataBuffP[0] = VICED_CAPABILITY_ERRORTRANS;
+ dataBuffP[0] = VICED_CAPABILITY_ERRORTRANS | VICED_CAPABILITY_WRITELOCKACL;
#if defined(AFS_64BIT_ENV) && defined(AFS_LARGEFILE_ENV)
dataBuffP[0] |= VICED_CAPABILITY_64BITFILES;
#endif
+ if (saneacls)
+ dataBuffP[0] |= VICED_CAPABILITY_SANEACLS;
capabilities->Capabilities_len = dataBytes / sizeof(afs_int32);
capabilities->Capabilities_val = dataBuffP;
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);
afs_sfsize_t adjustSize; /* bytes to call VAdjust... with */
int linkCount; /* link count on inode */
FdHandle_t *fdP;
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#if FS_STATS_DETAILED
/*
if (Pos == -1 || VN_GET_INO(targetptr) == 0) {
/* the inode should have been created in Alloc_NewVnode */
+ logHostAddr.s_addr = rxr_HostOf(rx_ConnectionOf(Call));
ViceLog(0,
("StoreData_RXStyle : Inode non-existent Fid = %u.%u.%u, inode = %llu, Pos %llu Host %s:%d\n",
Fid->Volume, Fid->Vnode, Fid->Unique,
(afs_uintmax_t) VN_GET_INO(targetptr), (afs_uintmax_t) Pos,
- rxr_AddrStringOf(rx_ConnectionOf(Call)),
- ntohs(rxr_PortOf(rx_ConnectionOf(Call)))));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(rx_ConnectionOf(Call)))));
return ENOENT; /* is this proper error code? */
} else {
/*
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;
sys2et[ENAMETOOLONG] = UAENAMETOOLONG;
sys2et[ENOLCK] = UAENOLCK;
sys2et[ENOSYS] = UAENOSYS;
+#if (ENOTEMPTY != EEXIST)
sys2et[ENOTEMPTY] = UAENOTEMPTY;
+#endif
sys2et[ELOOP] = UAELOOP;
+#if (EWOULDBLOCK != EAGAIN)
sys2et[EWOULDBLOCK] = UAEWOULDBLOCK;
+#endif
sys2et[ENOMSG] = UAENOMSG;
sys2et[EIDRM] = UAEIDRM;
sys2et[ECHRNG] = UAECHRNG;
sys2et[EDQUOT] = UAEDQUOT;
sys2et[ENOMEDIUM] = UAENOMEDIUM;
sys2et[EMEDIUMTYPE] = UAEMEDIUMTYPE;
+
+ sys2et[EIO] = UAEIO;
}
/* NOTE: 2006-03-01
#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 */