static void
print_vol_stats_hash(struct VolumeHashChainStats * stats)
{
afs_uint32 hi, lo;
printf("DiskPartitionStats = {\n");
printf("\ttable_size = %d\n", stats->table_size);
printf("\tchain_len = %d\n", stats->chain_len);
#ifdef AFS_DEMAND_ATTACH_FS
printf("\tchain_cacheCheck = %d\n", stats->chain_cacheCheck);
printf("\tchain_busy = %d\n", stats->chain_busy);
SplitInt64(stats->chain_looks, hi, lo);
printf("\tchain_looks = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->chain_gets, hi, lo);
printf("\tchain_gets = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->chain_reorders, hi, lo);
printf("\tchain_reorders = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
#endif /* AFS_DEMAND_ATTACH_FS */
printf("}\n");
}
static int
get_cb_hdr(void)
{
char * buf;
afs_uint32 hi, lo;
if (hdrs.cb_hdr_valid)
return 0;
if (get_hdr())
return 1;
SplitInt64(hdrs.hdr.cb_offset, hi, lo);
if (hi) {
fprintf(stderr, "hi offset bits set in cb_offset; can't get callback_state_header\n");
return 1;
}
if ((lo >= map_len) ||
((lo + sizeof(struct callback_state_header)) > map_len) ||
(lo + sizeof(struct callback_state_header) < lo)) {
fprintf(stderr, "cb_offset puts callback_state_header beyond end of memory map\n");
return 1;
}
buf = (char *) map;
buf += lo;
memcpy(&hdrs.cb_hdr, buf, sizeof(struct callback_state_header));
hdrs.cb_hdr_p = buf;
hdrs.cb_hdr_valid = 1;
SplitInt64(hdrs.cb_hdr.fe_offset, hi, lo);
if (hi) {
fprintf(stderr, "hi offset bits set in fe_offset; can't get callback_state_entry_header\n");
return 1;
}
hi = lo + (hdrs.cb_hdr.nFEs * (sizeof(struct callback_state_entry_header) +
sizeof(struct FEDiskEntry)) +
hdrs.cb_hdr.nCBs * sizeof(struct CBDiskEntry));
if ((hi > map_len) ||
(lo > hi)) {
fprintf(stderr, "fe_offset puts callback_state_entry_header beyond end of memory map\n");
return 1;
}
buf = (char *) map;
buf += lo;
fe_cursor.ffe = (void *)buf;
return 0;
}
int
fs_stateSeek(struct fs_dump_state * state, afs_uint64 * offset)
{
int ret = 0;
char * p;
#ifndef AFS_64BIT_ENV
afs_uint32 hi, lo;
SplitInt64(*offset, hi, lo);
#endif
/* update cursor */
p = (char *) state->mmap.map;
#ifdef AFS_64BIT_ENV
p += *offset;
#else
p += lo;
#endif
state->mmap.cursor = (void *) p;
/* update offset */
state->mmap.offset = *offset;
return ret;
}
static int
get_cb_fehash_hdr(void)
{
char * buf;
afs_uint32 hi, lo;
if (hdrs.fehash_hdr_valid)
return 0;
if (get_cb_hdr())
return 1;
SplitInt64(hdrs.cb_hdr.fehash_offset, hi, lo);
if (hi) {
fprintf(stderr, "hi offset bits set in fehash_offset; can't get callback_state_fehash_header\n");
return 1;
}
if ((lo >= map_len) ||
((lo + sizeof(struct callback_state_fehash_header)) > map_len) ||
(lo + sizeof(struct callback_state_fehash_header) < lo)) {
fprintf(stderr, "timeout_offset puts callback_state_fehash_header beyond end of memory map\n");
return 1;
}
buf = (char *) map;
buf += lo;
memcpy(&hdrs.fehash_hdr, buf, sizeof(struct callback_state_fehash_header));
hdrs.fehash_hdr_p = buf;
hdrs.fehash_hdr_valid = 1;
buf += sizeof(struct callback_state_fehash_header);
hdrs.fehash_p = buf;
return 0;
}
static int
get_h_hdr(void)
{
char * buf;
afs_uint32 hi, lo;
if (hdrs.h_hdr_valid)
return 0;
if (get_hdr())
return 1;
SplitInt64(hdrs.hdr.h_offset, hi, lo);
if (hi) {
fprintf(stderr, "hi offset bits set in h_offset; can't get host_state_header\n");
return 1;
}
if ((lo >= map_len) ||
((lo + sizeof(struct host_state_header)) > map_len) ||
(lo + sizeof(struct host_state_header) < lo)) {
fprintf(stderr, "h_offset puts host_state_header beyond end of memory map\n");
return 1;
}
buf = (char *) map;
buf += lo;
memcpy(&hdrs.h_hdr, buf, sizeof(struct host_state_header));
hdrs.h_hdr_p = buf;
buf += sizeof(struct host_state_header);
he_cursor.fh = (void *)buf;
return 0;
}
static void
dump_cb_hdr(void)
{
afs_uint32 hi, lo;
if (get_cb_hdr())
return;
DPFOFF(hdrs.cb_hdr_p);
DPFSO0("callback_state_header");
DPFSO1("stamp");
DPFX2("magic", hdrs.cb_hdr.stamp.magic);
DPFV2("version", "u", hdrs.cb_hdr.stamp.version);
DPFSC1;
DPFV1("nFEs", "u", hdrs.cb_hdr.nFEs);
DPFV1("nCBs", "u", hdrs.cb_hdr.nCBs);
DPFV1("fe_max", "u", hdrs.cb_hdr.fe_max);
DPFV1("cb_max", "u", hdrs.cb_hdr.cb_max);
DPFV1("tfirst", "d", hdrs.cb_hdr.tfirst);
SplitInt64(hdrs.cb_hdr.timeout_offset, hi, lo);
DPFSO1("timeout_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
SplitInt64(hdrs.cb_hdr.fehash_offset, hi, lo);
DPFSO1("fehash_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
SplitInt64(hdrs.cb_hdr.fe_offset, hi, lo);
DPFSO1("fe_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
DPFSC0;
if (hdrs.cb_hdr.stamp.magic != CALLBACK_STATE_MAGIC) {
fprintf(stderr, "* magic check failed\n");
}
if (hdrs.cb_hdr.stamp.version != CALLBACK_STATE_VERSION) {
fprintf(stderr, "* version check failed\n");
}
}
static void
dump_hdr(void)
{
char uuid_str[40];
afs_uint32 hi, lo;
if (get_hdr())
return;
DPFOFF(map);
DPFSO0("fs_state_header");
DPFSO1("stamp");
DPFX2("magic", hdrs.hdr.stamp.magic);
DPFV2("version", "u", hdrs.hdr.stamp.version);
DPFSC1;
DPFT1("timestamp", hdrs.hdr.timestamp);
DPFV1("sys_name", "u", hdrs.hdr.sys_name);
afsUUID_to_string(&hdrs.hdr.server_uuid, uuid_str, sizeof(uuid_str));
DPFS1("server_uuid", uuid_str);
DPFV1("valid", "d", hdrs.hdr.valid);
DPFV1("endianness", "d", hdrs.hdr.endianness);
DPFV1("stats_detailed", "d", hdrs.hdr.stats_detailed);
SplitInt64(hdrs.hdr.h_offset, hi, lo);
DPFSO1("h_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
SplitInt64(hdrs.hdr.cb_offset, hi, lo);
DPFSO1("cb_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
DPFS1("server_version_string", hdrs.hdr.server_version_string);
DPFSC0;
if (hdrs.hdr.stamp.magic != FS_STATE_MAGIC) {
fprintf(stderr, "* magic check failed\n");
}
if (hdrs.hdr.stamp.version != FS_STATE_VERSION) {
fprintf(stderr, "* version check failed\n");
}
}
static int
fs_stateTruncateFile(struct fs_dump_state * state)
{
int ret = 0;
#ifdef AFS_LARGEFILE_ENV
if (afs_ftruncate(state->fd, state->eof_offset) != 0) {
ret = 1;
}
#else
afs_uint32 hi, lo;
SplitInt64(state->eof_offset, hi, lo);
if (afs_ftruncate(state->fd, lo) != 0) {
ret = 1;
}
#endif
return ret;
}
/* update offset */
#ifdef AFS_LARGEFILE_ENV
state->mmap.offset = *offset;
#else
if (hi)
ret = 1;
state->mmap.offset = lo;
#endif
return ret;
}
#else /* !FS_STATE_USE_MMAP */
int
fs_stateSeek(struct fs_dump_state * state, afs_uint64 * offset)
{
int ret = 0;
#ifndef AFS_LARGEFILE_ENV
afs_uint32 high, low;
SplitInt64(*offset, high, low);
if (high) {
ret = 1;
goto done;
}
if (afs_lseek(state->fd, low, SEEK_SET) == -1)
ret = 1;
#else
if (afs_lseek(state->fd, *offset, SEEK_SET) == -1)
ret = 1;
#endif
return ret;
}
static int
VolQuery(struct cmd_syndesc * as, void * rock)
{
struct state state;
SYNC_PROTO_BUF_DECL(res_buf);
SYNC_response res;
Volume v;
int hi, lo;
res.hdr.response_len = sizeof(res.hdr);
res.payload.buf = res_buf;
res.payload.len = SYNC_PROTO_MAX_LEN;
common_prolog(as, &state);
common_volop_prolog(as, &state);
do_volop(&state, FSYNC_VOL_QUERY, &res);
if (res.hdr.response == SYNC_OK) {
memcpy(&v, res.payload.buf, sizeof(Volume));
printf("volume = {\n");
printf("\thashid = %u\n", v.hashid);
printf("\theader = 0x%x\n", v.header);
printf("\tdevice = %d\n", v.device);
printf("\tpartition = 0x%x\n", v.partition);
printf("\tlinkHandle = 0x%x\n", v.linkHandle);
printf("\tnextVnodeUnique = %u\n", v.nextVnodeUnique);
printf("\tdiskDataHandle = 0x%x\n", v.diskDataHandle);
printf("\tvnodeHashOffset = %u\n", v.vnodeHashOffset);
printf("\tshuttingDown = %d\n", v.shuttingDown);
printf("\tgoingOffline = %d\n", v.goingOffline);
printf("\tcacheCheck = %u\n", v.cacheCheck);
printf("\tnUsers = %d\n", v.nUsers);
printf("\tneedsPutBack = %d\n", v.needsPutBack);
printf("\tspecialStatus = %d\n", v.specialStatus);
printf("\tupdateTime = %u\n", v.updateTime);
printf("\tvnodeIndex[vSmall] = {\n");
printf("\t\thandle = 0x%x\n", v.vnodeIndex[vSmall].handle);
printf("\t\tbitmap = 0x%x\n", v.vnodeIndex[vSmall].bitmap);
printf("\t\tbitmapSize = %u\n", v.vnodeIndex[vSmall].bitmapSize);
printf("\t\tbitmapOffset = %u\n", v.vnodeIndex[vSmall].bitmapOffset);
printf("\t}\n");
printf("\tvnodeIndex[vLarge] = {\n");
printf("\t\thandle = 0x%x\n", v.vnodeIndex[vLarge].handle);
printf("\t\tbitmap = 0x%x\n", v.vnodeIndex[vLarge].bitmap);
printf("\t\tbitmapSize = %u\n", v.vnodeIndex[vLarge].bitmapSize);
printf("\t\tbitmapOffset = %u\n", v.vnodeIndex[vLarge].bitmapOffset);
printf("\t}\n");
#ifdef AFS_DEMAND_ATTACH_FS
if (res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS) {
printf("\tupdateTime = %u\n", v.updateTime);
printf("\tattach_state = %s\n", vol_state_to_string(v.attach_state));
printf("\tattach_flags = %s\n", vol_flags_to_string(v.attach_flags));
printf("\tnWaiters = %d\n", v.nWaiters);
printf("\tchainCacheCheck = %d\n", v.chainCacheCheck);
/* online salvage structure */
printf("\tsalvage = {\n");
printf("\t\tprio = %u\n", v.salvage.prio);
printf("\t\treason = %d\n", v.salvage.reason);
printf("\t\trequested = %d\n", v.salvage.requested);
printf("\t\tscheduled = %d\n", v.salvage.scheduled);
printf("\t}\n");
/* statistics structure */
printf("\tstats = {\n");
printf("\t\thash_lookups = {\n");
SplitInt64(v.stats.hash_lookups,hi,lo);
printf("\t\t\thi = %u\n", hi);
printf("\t\t\tlo = %u\n", lo);
printf("\t\t}\n");
printf("\t\thash_short_circuits = {\n");
SplitInt64(v.stats.hash_short_circuits,hi,lo);
printf("\t\t\thi = %u\n", hi);
printf("\t\t\tlo = %u\n", lo);
printf("\t\t}\n");
printf("\t\thdr_loads = {\n");
SplitInt64(v.stats.hdr_loads,hi,lo);
printf("\t\t\thi = %u\n", hi);
printf("\t\t\tlo = %u\n", lo);
printf("\t\t}\n");
printf("\t\thdr_gets = {\n");
SplitInt64(v.stats.hdr_gets,hi,lo);
printf("\t\t\thi = %u\n", hi);
printf("\t\t\tlo = %u\n", lo);
printf("\t\t}\n");
printf("\t\tattaches = %u\n", v.stats.attaches);
printf("\t\tsoft_detaches = %u\n", v.stats.soft_detaches);
printf("\t\tsalvages = %u\n", v.stats.salvages);
printf("\t\tvol_ops = %u\n", v.stats.vol_ops);
printf("\t\tlast_attach = %u\n", v.stats.last_attach);
printf("\t\tlast_get = %u\n", v.stats.last_get);
printf("\t\tlast_promote = %u\n", v.stats.last_promote);
printf("\t\tlast_hdr_get = %u\n", v.stats.last_hdr_get);
printf("\t\tlast_hdr_load = %u\n", v.stats.last_hdr_load);
printf("\t\tlast_salvage = %u\n", v.stats.last_salvage);
printf("\t\tlast_salvage_req = %u\n", v.stats.last_salvage_req);
printf("\t\tlast_vol_op = %u\n", v.stats.last_vol_op);
printf("\t}\n");
/* VLRU state */
printf("\tvlru = {\n");
printf("\t\tidx = %d (%s)\n",
v.vlru.idx, vlru_idx_to_string(v.vlru.idx));
printf("\t}\n");
/* volume op state */
printf("\tpending_vol_op = 0x%x\n", v.pending_vol_op);
}
#else /* !AFS_DEMAND_ATTACH_FS */
if (res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS) {
printf("*** server asserted demand attach extensions. fssync-debug not built to\n");
printf("*** recognize those extensions. please recompile fssync-debug if you need\n");
printf("*** to dump dafs extended state\n");
}
#endif /* !AFS_DEMAND_ATTACH_FS */
printf("}\n");
}
return 0;
}
static void
print_vol_stats_general(VolPkgStats * stats)
{
int i;
afs_uint32 hi, lo;
printf("VolPkgStats = {\n");
#ifdef AFS_DEMAND_ATTACH_FS
for (i = 0; i < VOL_STATE_COUNT; i++) {
printf("\tvol_state_count[%s] = %d\n",
vol_state_to_string(i),
stats->state_levels[i]);
}
SplitInt64(stats->hash_looks, hi, lo);
printf("\thash_looks = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->hash_reorders, hi, lo);
printf("\thash_reorders = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->salvages, hi, lo);
printf("\tsalvages = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->vol_ops, hi, lo);
printf("\tvol_ops = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
#endif
SplitInt64(stats->hdr_loads, hi, lo);
printf("\thdr_loads = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->hdr_gets, hi, lo);
printf("\thdr_gets = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->attaches, hi, lo);
printf("\tattaches = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
SplitInt64(stats->soft_detaches, hi, lo);
printf("\tsoft_detaches = {\n");
printf("\t\thi = %u\n", hi);
printf("\t\tlo = %u\n", lo);
printf("\t}\n");
printf("\thdr_cache_size = %d\n", stats->hdr_cache_size);
printf("}\n");
}
static int
DumpFile(int dumpfd, int vnode, FdHandle_t * handleP, struct VnodeDiskObject *v)
{
int code = 0, failed_seek = 0, failed_write = 0;
afs_int32 pad = 0;
afs_int32 offset = 0;
afs_sfsize_t n, nbytes, howMany, howBig;
byte *p;
#ifndef AFS_NT40_ENV
struct afs_stat status;
#endif
afs_sfsize_t size, tmpsize;
#ifdef AFS_AIX_ENV
#include <sys/statfs.h>
struct statfs tstatfs;
#endif
if (verbose)
fprintf(stderr, "dumping file for vnode %d\n", vnode);
#ifdef AFS_NT40_ENV
howBig = _filelength(handleP->fd_fd);
howMany = 4096;
#else
afs_fstat(handleP->fd_fd, &status);
howBig = status.st_size;
#ifdef AFS_AIX_ENV
/* Unfortunately in AIX valuable fields such as st_blksize are
* gone from the stat structure.
*/
fstatfs(handleP->fd_fd, &tstatfs);
howMany = tstatfs.f_bsize;
#else
howMany = status.st_blksize;
#endif /* AFS_AIX_ENV */
#endif /* AFS_NT40_ENV */
size = FDH_SIZE(handleP);
if (verbose)
fprintf(stderr, " howBig = %u, howMany = %u, fdh size = %u\n",
howBig, howMany, size);
#ifdef AFS_LARGEFILE_ENV
{
afs_uint32 hi, lo;
SplitInt64(size, hi, lo);
if (hi == 0L) {
code = DumpInt32(dumpfd, 'f', lo);
} else {
code = DumpDouble(dumpfd, 'h', hi, lo);
}
}
#else /* !AFS_LARGEFILE_ENV */
code = DumpInt32(dumpfd, 'f', size);
#endif /* !AFS_LARGEFILE_ENV */
if (code) {
return VOLSERDUMPERROR;
}
p = (unsigned char *)malloc(howMany);
if (!p) {
fprintf(stderr, "out of memory!\n");
return VOLSERDUMPERROR;
}
/* loop through whole file, while we still have bytes left, and no errors, in chunks of howMany bytes */
for (nbytes = size; (nbytes && !failed_write); nbytes -= howMany) {
if (nbytes < howMany)
howMany = nbytes;
/* Read the data - unless we know we can't */
n = (failed_seek ? 0 : FDH_READ(handleP, p, howMany));
/* If read any good data and we null padded previously, log the
* amount that we had null padded.
*/
if ((n > 0) && pad) {
fprintf(stderr, "Null padding file %d bytes at offset %u\n", pad,
offset);
pad = 0;
}
/* If didn't read enough data, null padd the rest of the buffer. This
* can happen if, for instance, the media has some bad spots. We don't
* want to quit the dump, so we start null padding.
*/
if (n < howMany) {
if (verbose) fprintf(stderr, " read %u instead of %u bytes.\n", n, howMany);
/* Record the read error */
if (n < 0) {
n = 0;
fprintf(stderr, "Error %d reading inode %s for vnode %d\n",
errno, PrintInode(NULL, handleP->fd_ih->ih_ino),
vnode);
} else if (!pad) {
fprintf(stderr, "Error reading inode %s for vnode %d\n",
PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
}
/* Pad the rest of the buffer with zeros. Remember offset we started
* padding. Keep total tally of padding.
*/
memset(p + n, 0, howMany - n);
if (!pad)
offset = (howBig - nbytes) + n;
pad += (howMany - n);
/* Now seek over the data we could not get. An error here means we
* can't do the next read.
*/
failed_seek = FDH_SEEK(handleP, ((size - nbytes) + howMany), SEEK_SET);
if (failed_seek != ((size - nbytes) + howMany)) {
if (failed_seek < 0) {
fprintf(stderr,
"Error %d seeking in inode %s for vnode %d\n",
errno, PrintInode(NULL, handleP->fd_ih->ih_ino),
vnode);
} else {
fprintf(stderr,
"Error seeking in inode %s for vnode %d\n",
PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
failed_seek = -1;
}
} else {
failed_seek = 0;
}
}
/* Now write the data out */
if (write(dumpfd, (char *)p, howMany) != howMany)
failed_write = VOLSERDUMPERROR;
}
if (pad) { /* Any padding we hadn't reported yet */
fprintf(stderr, "Null padding file: %d bytes at offset %u\n", pad,
offset);
}
free(p);
return failed_write;
}
