static int
do_volop(struct fssync_state * state, afs_int32 command, SYNC_response * res)
{
afs_int32 code;
SYNC_PROTO_BUF_DECL(res_buf);
SYNC_response res_l;
if (!res) {
res = &res_l;
res->payload.len = SYNC_PROTO_MAX_LEN;
res->payload.buf = res_buf;
}
fprintf(stderr, "calling FSYNC_VolOp with command code %d (%s)\n",
command, FSYNC_com2string(command));
code = FSYNC_VolOp(state->vop->volume,
state->vop->partName,
command,
state->reason,
res);
debug_response(code, res);
VDisconnectFS();
return 0;
}
static int
VGCDel(struct cmd_syndesc * as, void * rock)
{
afs_int32 code;
struct fssync_state state;
char * partName;
VolumeId parent, child;
struct cmd_item *ti;
SYNC_response res;
if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) { /* -partition */
return -1;
}
partName = ti->data;
if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) { /* -parent */
return -1;
}
parent = atoi(ti->data);
if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+2].items)) { /* -child */
return -1;
}
child = atoi(ti->data);
common_prolog(as, &state);
fprintf(stderr, "calling FSYNC_VCGDel\n");
code = FSYNC_VGCDel(partName, parent, child, state.reason, &res);
debug_response(code, &res);
VDisconnectFS();
return 0;
}
static int
VGCScanAll(struct cmd_syndesc * as, void * rock)
{
afs_int32 code;
struct fssync_state state;
common_prolog(as, &state);
fprintf(stderr, "calling FSYNC_VCGScanAll\n");
code = FSYNC_VGCScan(NULL, state.reason);
debug_response(code, NULL);
VDisconnectFS();
return 0;
}
/**
* query VGC.
*
* @notes args:
* - CUSTOM_PARMS_OFFSET+0 is partition string
* - CUSTOM_PARMS_OFFSET+1 is volume id
*
* @return operation status
* @retval 0 success
*/
static int
VGCQuery(struct cmd_syndesc * as, void * rock)
{
afs_int32 code;
struct fssync_state state;
char * partName;
VolumeId volid;
FSSYNC_VGQry_response_t q_res;
SYNC_response res;
int i;
struct cmd_item *ti;
if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) { /* -partition */
return -1;
}
partName = ti->data;
if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) { /* -volumeid */
return -1;
}
volid = atoi(ti->data);
common_prolog(as, &state);
fprintf(stderr, "calling FSYNC_VCGQuery\n");
code = FSYNC_VGCQuery(partName, volid, &q_res, &res);
debug_response(code, &res);
if (code == SYNC_OK) {
printf("VG = {\n");
printf("\trw\t=\t%u\n", q_res.rw);
printf("\tchildren\t= (\n");
for (i = 0; i < VOL_VG_MAX_VOLS; i++) {
if (q_res.children[i]) {
printf("\t\t%u\n", q_res.children[i]);
}
}
printf("\t)\n");
}
VDisconnectFS();
return 0;
}
static int
VGCScan(struct cmd_syndesc * as, void * rock)
{
afs_int32 code;
struct fssync_state state;
char * partName;
struct cmd_item *ti;
if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) { /* -partition */
return -1;
}
partName = ti->data;
common_prolog(as, &state);
fprintf(stderr, "calling FSYNC_VCGScan\n");
code = FSYNC_VGCScan(partName, state.reason);
debug_response(code, NULL);
VDisconnectFS();
return 0;
}
static int
do_volop(struct state * state, afs_int32 command, SYNC_response * res)
{
afs_int32 code;
SYNC_PROTO_BUF_DECL(res_buf);
SYNC_response res_l;
if (!res) {
res = &res_l;
res->payload.len = SYNC_PROTO_MAX_LEN;
res->payload.buf = res_buf;
}
fprintf(stderr, "calling FSYNC_VolOp with command code %d (%s)\n",
command, command_code_to_string(command));
code = FSYNC_VolOp(state->vop->volume,
state->vop->partName,
command,
state->reason,
res);
switch (code) {
case SYNC_OK:
case SYNC_DENIED:
break;
default:
fprintf(stderr, "possible sync protocol error. return code was %d\n", code);
}
fprintf(stderr, "FSYNC_VolOp returned %d (%s)\n", code, response_code_to_string(code));
fprintf(stderr, "protocol response code was %d (%s)\n",
res->hdr.response, response_code_to_string(res->hdr.response));
fprintf(stderr, "protocol reason code was %d (%s)\n",
res->hdr.reason, reason_code_to_string(res->hdr.reason));
VDisconnectFS();
}
static int
do_vnqry(struct state * state, SYNC_response * res)
{
afs_int32 code;
int command = FSYNC_VOL_QUERY_VNODE;
FSSYNC_VnQry_hdr qry;
qry.volume = state->vop->volume;
qry.vnode = state->vop->vnode;
qry.unique = state->vop->unique;
qry.spare = 0;
strlcpy(qry.partName, state->vop->partName, sizeof(qry.partName));
fprintf(stderr, "calling FSYNC_GenericOp with command code %d (%s)\n",
command, command_code_to_string(command));
code = FSYNC_GenericOp(&qry, sizeof(qry), command, FSYNC_OPERATOR, res);
switch (code) {
case SYNC_OK:
case SYNC_DENIED:
break;
default:
fprintf(stderr, "possible sync protocol error. return code was %d\n", code);
}
fprintf(stderr, "FSYNC_GenericOp returned %d (%s)\n", code, response_code_to_string(code));
fprintf(stderr, "protocol response code was %d (%s)\n",
res->hdr.response, response_code_to_string(res->hdr.response));
fprintf(stderr, "protocol reason code was %d (%s)\n",
res->hdr.reason, reason_code_to_string(res->hdr.reason));
VDisconnectFS();
return 0;
}
static int
do_vnqry(struct fssync_state * state, SYNC_response * res)
{
afs_int32 code;
int command = FSYNC_VOL_QUERY_VNODE;
FSSYNC_VnQry_hdr qry;
qry.volume = state->vop->volume;
qry.vnode = state->vop->vnode;
qry.unique = state->vop->unique;
qry.spare = 0;
strlcpy(qry.partName, state->vop->partName, sizeof(qry.partName));
fprintf(stderr, "calling FSYNC_GenericOp with command code %d (%s)\n",
command, FSYNC_com2string(command));
code = FSYNC_GenericOp(&qry, sizeof(qry), command, FSYNC_OPERATOR, res);
debug_response(code, res);
VDisconnectFS();
return 0;
}
static int
StatsQuery(struct cmd_syndesc * as, void * rock)
{
afs_int32 code;
int command;
struct cmd_item *ti;
struct state state;
SYNC_PROTO_BUF_DECL(res_buf);
SYNC_response res;
FSSYNC_StatsOp_hdr scom;
union {
void * ptr;
struct VolPkgStats * vol_stats;
struct VolumeHashChainStats * hash_stats;
#ifdef AFS_DEMAND_ATTACH_FS
struct volume_hdr_LRU_stats * hdr_stats;
#endif
struct DiskPartitionStats64 * vicep_stats;
} sres;
sres.ptr = res_buf;
res.hdr.response_len = sizeof(res.hdr);
res.payload.buf = res_buf;
res.payload.len = SYNC_PROTO_MAX_LEN;
if ((ti = as->parms[CUSTOM_PARMS_OFFSET].items)) { /* -subcommand */
if (!strcasecmp(ti->data, "vicep")) {
command = FSYNC_VOL_STATS_VICEP;
} else if (!strcasecmp(ti->data, "hash")) {
command = FSYNC_VOL_STATS_HASH;
#ifdef AFS_DEMAND_ATTACH_FS
} else if (!strcasecmp(ti->data, "hdr")) {
command = FSYNC_VOL_STATS_HDR;
} else if (!strcasecmp(ti->data, "vlru")) {
command = FSYNC_VOL_STATS_VLRU;
#endif
} else if (!strcasecmp(ti->data, "pkg")) {
command = FSYNC_VOL_STATS_GENERAL;
} else if (!strcasecmp(ti->data, "help")) {
fprintf(stderr, "fssync-debug stats subcommands:\n");
fprintf(stderr, "\tpkg\tgeneral volume package stats\n");
fprintf(stderr, "\tvicep\tvice partition stats\n");
fprintf(stderr, "\thash\tvolume hash chain stats\n");
#ifdef AFS_DEMAND_ATTACH_FS
fprintf(stderr, "\thdr\tvolume header cache stats\n");
fprintf(stderr, "\tvlru\tvlru generation stats\n");
#endif
exit(0);
} else {
fprintf(stderr, "invalid stats subcommand");
exit(1);
}
} else {
command = FSYNC_VOL_STATS_GENERAL;
}
if ((ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) { /* -arg1 */
switch (command) {
case FSYNC_VOL_STATS_VICEP:
strlcpy(scom.args.partName, ti->data, sizeof(state.vop->partName));
break;
case FSYNC_VOL_STATS_HASH:
scom.args.hash_bucket = atoi(ti->data);
break;
case FSYNC_VOL_STATS_VLRU:
scom.args.vlru_generation = atoi(ti->data);
break;
default:
fprintf(stderr, "unrecognized arguments\n");
exit(1);
}
} else {
switch (command) {
case FSYNC_VOL_STATS_VICEP:
case FSYNC_VOL_STATS_HASH:
case FSYNC_VOL_STATS_VLRU:
fprintf(stderr, "this subcommand requires more parameters\n");
exit(1);
}
}
common_prolog(as, &state);
fprintf(stderr, "calling FSYNC_askfs with command code %d (%s)\n",
command, command_code_to_string(command));
code = FSYNC_StatsOp(&scom, command, FSYNC_WHATEVER, &res);
switch (code) {
case SYNC_OK:
case SYNC_DENIED:
break;
default:
fprintf(stderr, "possible sync protocol error. return code was %d\n", code);
}
fprintf(stderr, "FSYNC_VolOp returned %d (%s)\n", code, response_code_to_string(code));
fprintf(stderr, "protocol response code was %d (%s)\n",
res.hdr.response, response_code_to_string(res.hdr.response));
fprintf(stderr, "protocol reason code was %d (%s)\n",
res.hdr.reason, reason_code_to_string(res.hdr.reason));
VDisconnectFS();
if (res.hdr.response == SYNC_OK) {
switch (command) {
case FSYNC_VOL_STATS_GENERAL:
print_vol_stats_general(sres.vol_stats);
break;
case FSYNC_VOL_STATS_VICEP:
print_vol_stats_viceP(sres.vicep_stats);
break;
case FSYNC_VOL_STATS_HASH:
print_vol_stats_hash(sres.hash_stats);
break;
#ifdef AFS_DEMAND_ATTACH_FS
case FSYNC_VOL_STATS_HDR:
print_vol_stats_hdr(sres.hdr_stats);
break;
#endif /* AFS_DEMAND_ATTACH_FS */
}
}
return 0;
}
