#include <stdio.h>
#include <stdlib.h> /* for malloc() */
#include <time.h> /* ANSI standard location for time stuff */
+#include <string.h>
#ifdef AFS_NT40_ENV
#include <fcntl.h>
#include <io.h>
#include <sys/time.h>
#include <sys/file.h>
#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-#endif
#include <afs/assert.h>
#include <afs/stds.h>
extern afsUUID FS_HostUUID;
extern int hostCount;
+
+#ifndef INTERPRET_DUMP
static int ShowProblems = 1;
+#endif
struct cbcounters cbstuff;
}; /* Anything more: MinTimeOut */
/* minimum time given for a call back */
+#ifndef INTERPRET_DUMP
static int MinTimeOut = (7 * 60);
+#endif
/* Heads of CB queues; a timeout index is 1+index into this array */
static afs_uint32 timeout[CB_NUM_TIMEOUT_QUEUES];
/* Prototypes for static routines */
static struct FileEntry *FindFE(register AFSFid * fid);
+
+#ifndef INTERPRET_DUMP
static struct CallBack *iGetCB(register int *nused);
static int iFreeCB(register struct CallBack *cb, register int *nused);
static struct FileEntry *iGetFE(register int *nused);
static int MultiBreakVolumeCallBack_r(struct host *host, int isheld,
struct VCBParams *parms, int deletefe);
static int MultiBreakVolumeCallBack(struct host *host, int isheld,
- struct VCBParams *parms);
+ void *rock);
static int MultiBreakVolumeLaterCallBack(struct host *host, int isheld,
- struct VCBParams *parms);
+ void *rock);
static int GetSomeSpace_r(struct host *hostp, int locked);
static int ClearHostCallbacks_r(struct host *hp, int locked);
+#endif
#define GetCB() ((struct CallBack *)iGetCB(&cbstuff.nCBs))
#define GetFE() ((struct FileEntry *)iGetFE(&cbstuff.nFEs))
CcdelB++;
*cbp = cb->cnext;
FreeCB(cb);
- if (deletefe && (--fe->ncbs == 0))
+ if ((--fe->ncbs == 0) && deletefe)
FDel(fe);
return 0;
}
struct FileEntry *fe;
struct CallBack *cb = 0, *lastcb = 0;
struct FileEntry *newfe = 0;
- afs_uint32 time_out;
+ afs_uint32 time_out = 0;
afs_uint32 *Thead = thead;
struct CallBack *newcb = 0;
int safety;
+ cbstuff.AddCallBacks++;
+
host->Console |= 2;
/* allocate these guys first, since we can't call the allocator with
return 0;
}
+static int
+CompareCBA(const void *e1, const void *e2)
+{
+ const struct cbstruct *cba1 = (const struct cbstruct *)e1;
+ const struct cbstruct *cba2 = (const struct cbstruct *)e2;
+ return ((cba1->hp)->index - (cba2->hp)->index);
+}
+
/* Take an array full of hosts, all held. Break callbacks to them, and
* release the holds once you're done, except don't release xhost. xhost
* may be NULL. Currently only works for a single Fid in afidp array.
assert(ncbas <= MAX_CB_HOSTS);
+ /* sort cba list to avoid makecall issues */
+ qsort(cba, ncbas, sizeof(struct cbstruct), CompareCBA);
+
/* set up conns for multi-call */
for (i = 0, j = 0; i < ncbas; i++) {
struct host *thishost = cba[i].hp;
register afs_uint32 *pcb;
char hoststr[16];
+ H_LOCK;
cbstuff.DeleteCallBacks++;
- H_LOCK;
h_Lock_r(host);
fe = FindFE(fid);
if (!fe) {
TDel(cb);
HDel(cb);
FreeCB(cb);
+ fe->ncbs--;
}
FDel(fe);
H_UNLOCK;
cbstuff.nbreakers--;
/* If we succeeded it's always ok to unset HFE_LATER */
- if (!host->hostFlags & VENUSDOWN)
+ if (!(host->hostFlags & VENUSDOWN))
host->hostFlags &= ~HFE_LATER;
return (host->hostFlags & VENUSDOWN);
}
** isheld is 1 if the host is held in BreakVolumeCallBacks
*/
static int
-MultiBreakVolumeCallBack(struct host *host, int isheld,
- struct VCBParams *parms)
+MultiBreakVolumeCallBack(struct host *host, int isheld, void *rock)
{
+ struct VCBParams *parms = (struct VCBParams *) rock;
+
int retval;
H_LOCK;
retval = MultiBreakVolumeCallBack_r(host, isheld, parms, 1);
** isheld is 1 if the host is held in BreakVolumeCallBacks
*/
static int
-MultiBreakVolumeLaterCallBack(struct host *host, int isheld,
- struct VCBParams *parms)
+MultiBreakVolumeLaterCallBack(struct host *host, int isheld, void *rock)
{
+ struct VCBParams *parms = (struct VCBParams *)rock;
int retval;
H_LOCK;
retval = MultiBreakVolumeCallBack_r(host, isheld, parms, 0);
henumParms.fid = &fid;
henumParms.thead = tthead;
H_UNLOCK;
- h_Enumerate(MultiBreakVolumeCallBack, (char *)&henumParms);
+ h_Enumerate(MultiBreakVolumeCallBack, &henumParms);
H_LOCK;
if (henumParms.ncbas) { /* do left-overs */
struct AFSCBFids tf;
* are held by other threads.
*/
static int
-lih0_r(register struct host *host, register int held,
- register struct host *hostp)
+lih0_r(register struct host *host, register int held, void *rock)
{
+ struct host *hostp = (struct host *) rock;
if (host->cblist
&& (hostp && host != hostp)
&& (!held && !h_OtherHolds_r(host))
* prevent held hosts from being selected.
*/
static int
-lih1_r(register struct host *host, register int held,
- register struct host *hostp)
+lih1_r(register struct host *host, register int held, void *rock)
{
+ struct host *hostp = (struct host *) rock;
+
if (host->cblist
&& (hostp && host != hostp)
&& (!lih_host || host->ActiveCall < lih_host->ActiveCall)
}
#define MAGIC 0x12345678 /* To check byte ordering of dump when it is read in */
+#define MAGICV2 0x12345679 /* To check byte ordering & version of dump when it is read in */
+
#ifndef INTERPRET_DUMP
static int
cb_stateSaveFE(struct fs_dump_state * state, struct FileEntry * fe)
{
- int ret = 0, iovcnt, cbi, idx, len, written = 0;
+ int ret = 0, iovcnt, cbi, written = 0;
afs_uint32 fei;
struct callback_state_entry_header hdr;
struct FEDiskEntry fedsk;
}
iov[0].iov_base = (char *)&hdr;
- len = iov[0].iov_len = sizeof(hdr);
+ iov[0].iov_len = sizeof(hdr);
iov[1].iov_base = (char *)&fedsk;
- len += iov[1].iov_len = sizeof(struct FEDiskEntry);
+ iov[1].iov_len = sizeof(struct FEDiskEntry);
iovcnt = 2;
- for (cbi = fe->firstcb, cb = itocb(cbi), idx = 2;
+ for (cbi = fe->firstcb, cb = itocb(cbi);
cb != NULL;
- cbi = cb->cnext, cb = itocb(cbi), idx++, hdr.nCBs++) {
+ cbi = cb->cnext, cb = itocb(cbi), hdr.nCBs++) {
if (cbi > state->cb_hdr->cb_max) {
state->cb_hdr->cb_max = cbi;
}
- if (cb_stateCBToDiskEntry(cb, &cbdsk[idx])) {
+ if (cb_stateCBToDiskEntry(cb, &cbdsk[iovcnt])) {
ret = 1;
goto done;
}
- cbdsk[idx].index = cbi;
- iov[idx].iov_base = (char *)&cbdsk[idx];
- len += iov[idx].iov_len = sizeof(struct CBDiskEntry);
+ cbdsk[iovcnt].index = cbi;
+ iov[iovcnt].iov_base = (char *)&cbdsk[iovcnt];
+ iov[iovcnt].iov_len = sizeof(struct CBDiskEntry);
iovcnt++;
if ((iovcnt == 16) || (!cb->cnext)) {
if (fs_stateWriteV(state, iov, iovcnt)) {
}
written = 1;
iovcnt = 0;
- len = 0;
}
}
static int
cb_stateRestoreFE(struct fs_dump_state * state)
{
- int ret = 0, iovcnt, len, nCBs, idx;
+ int ret = 0, iovcnt, nCBs;
struct callback_state_entry_header hdr;
struct FEDiskEntry fedsk;
struct CBDiskEntry cbdsk[16];
struct CallBack * cb;
iov[0].iov_base = (char *)&hdr;
- len = iov[0].iov_len = sizeof(hdr);
+ iov[0].iov_len = sizeof(hdr);
iov[1].iov_base = (char *)&fedsk;
- len += iov[1].iov_len = sizeof(fedsk);
+ iov[1].iov_len = sizeof(fedsk);
iovcnt = 2;
if (fs_stateReadV(state, iov, iovcnt)) {
}
if (hdr.nCBs) {
- for (iovcnt = 0, idx = 0, len = 0, nCBs = 0;
+ for (iovcnt = 0, nCBs = 0;
nCBs < hdr.nCBs;
- idx++, nCBs++) {
- iov[idx].iov_base = (char *)&cbdsk[idx];
- len += iov[idx].iov_len = sizeof(struct CBDiskEntry);
+ nCBs++) {
+ iov[iovcnt].iov_base = (char *)&cbdsk[iovcnt];
+ iov[iovcnt].iov_len = sizeof(struct CBDiskEntry);
iovcnt++;
if ((iovcnt == 16) || (nCBs == hdr.nCBs - 1)) {
if (fs_stateReadV(state, iov, iovcnt)) {
ret = 1;
goto done;
}
- len = 0;
iovcnt = 0;
}
}
int
DumpCallBackState(void)
{
- int fd;
- afs_uint32 magic = MAGIC, now = FT_ApproxTime(), freelisthead;
+ int fd, oflag;
+ afs_uint32 magic = MAGICV2, now = (afs_int32) FT_ApproxTime(), freelisthead;
- fd = open(AFSDIR_SERVER_CBKDUMP_FILEPATH, O_WRONLY | O_CREAT | O_TRUNC,
- 0666);
+ oflag = O_WRONLY | O_CREAT | O_TRUNC;
+#ifdef AFS_NT40_ENV
+ oflag |= O_BINARY;
+#endif
+ fd = open(AFSDIR_SERVER_CBKDUMP_FILEPATH, oflag, 0666);
if (fd < 0) {
ViceLog(0,
("Couldn't create callback dump file %s\n",
/* This is only compiled in for the callback analyzer program */
/* Returns the time of the dump */
time_t
-ReadDump(char *file)
+ReadDump(char *file, int timebits)
{
- int fd;
+ int fd, oflag;
afs_uint32 magic, freelisthead;
- time_t now;
+ afs_uint32 now;
+#ifdef AFS_64BIT_ENV
+ afs_int64 now64;
+#endif
- fd = open(file, O_RDONLY);
+ oflag = O_RDONLY;
+#ifdef AFS_NT40_ENV
+ oflag |= O_BINARY;
+#endif
+ fd = open(file, oflag);
if (fd < 0) {
fprintf(stderr, "Couldn't read dump file %s\n", file);
exit(1);
}
read(fd, &magic, sizeof(magic));
- if (magic != MAGIC) {
- fprintf(stderr,
- "Magic number of %s is invalid. You might be trying to\n",
- file);
- fprintf(stderr,
- "run this program on a machine type with a different byte ordering.\n");
- exit(1);
+ if (magic == MAGICV2) {
+ timebits = 32;
+ } else {
+ if (magic != MAGIC) {
+ fprintf(stderr,
+ "Magic number of %s is invalid. You might be trying to\n",
+ file);
+ fprintf(stderr,
+ "run this program on a machine type with a different byte ordering.\n");
+ exit(1);
+ }
}
- read(fd, &now, sizeof(now));
+#ifdef AFS_64BIT_ENV
+ if (timebits == 64) {
+ read(fd, &now64, sizeof(afs_int64));
+ now = (afs_int32) now64;
+ } else
+#endif
+ read(fd, &now, sizeof(afs_int32));
read(fd, &cbstuff, sizeof(cbstuff));
read(fd, TimeOuts, sizeof(TimeOuts));
read(fd, timeout, sizeof(timeout));
read(fd, &tfirst, sizeof(tfirst));
read(fd, &freelisthead, sizeof(freelisthead));
CB = ((struct CallBack
- *)(calloc(cbstuff.nblks, sizeof(struct FileEntry)))) - 1;
+ *)(calloc(cbstuff.nblks, sizeof(struct CallBack)))) - 1;
FE = ((struct FileEntry
*)(calloc(cbstuff.nblks, sizeof(struct FileEntry)))) - 1;
CBfree = (struct CallBack *)itocb(freelisthead);
static AFSFid fid;
register struct FileEntry *fe;
register struct CallBack *cb;
- time_t now;
-
+ afs_int32 now;
+ int timebits = 32;
+
memset(&fid, 0, sizeof(fid));
argc--;
argv++;
all = 1;
} else if (!strcmp(*argv, "-raw")) {
raw = 1;
+ } else if (!strcmp(*argv, "-timebits")) {
+ if (argc < 1) {
+ err++;
+ break;
+ }
+ argc--;
+ timebits = atoi(*++argv);
+ if ((timebits != 32)
+#ifdef AFS_64BIT_ENV
+ && (timebits != 64)
+#endif
+ )
+ err++;
} else if (!strcmp(*argv, "-volume")) {
if (argc < 1) {
err++;
}
if (err || argc != 1) {
fprintf(stderr,
- "Usage: cbd [-host cbid] [-fid volume vnode] [-stats] [-all] callbackdumpfile\n");
+ "Usage: cbd [-host cbid] [-fid volume vnode] [-stats] [-all] [-timebits 32"
+#ifdef AFS_64BIT_ENV
+ "|64"
+#endif
+ "] callbackdumpfile\n");
fprintf(stderr,
"[cbid is shown for each host in the hosts.dump file]\n");
exit(1);
}
- now = ReadDump(*argv);
+ now = ReadDump(*argv, timebits);
if (stats || noptions == 0) {
time_t uxtfirst = UXtime(tfirst);
- printf("The time of the dump was %u %s", now, ctime(&now));
- printf("The last time cleanup ran was %u %s", uxtfirst,
+ printf("The time of the dump was %u %s", (unsigned int) now, ctime(&now));
+ printf("The last time cleanup ran was %u %s", (unsigned int) uxtfirst,
ctime(&uxtfirst));
PrintCallBackStats();
}
if (fe == NULL)
return;
- printf("vol=%u vn=%u cbs=%d hi=%d st=%d fest=%d, exp in %d secs at %s",
+ printf("vol=%u vn=%u cbs=%d hi=%d st=%d fest=%d, exp in %lu secs at %s",
fe->volid, fe->vnode, fe->ncbs, cb->hhead, cb->status, fe->status,
expires - now, ctime(&expires));
}
if (!host->interface)
return 1; /* failure */
- assert(host->interface->numberOfInterfaces > 0);
-
/* the only address is the primary interface */
- if (host->interface->numberOfInterfaces == 1)
- return 1; /* failure */
+ if (host->interface->numberOfInterfaces <= 1)
+ return 1; /* failure */
/* initialise a security object only once */
if (!sc)