static void print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
struct rtnl_u32 *u)
{
int i;
struct tc_u32_key *key;
if (sel->hmask || sel->hoff) {
/* I guess this will never be used since the kernel only
* exports the selector if no divisor is set but hash offset
* and hash mask make only sense in hash filters with divisor
* set */
nl_dump(p, " hash at %u & 0x%x", sel->hoff, sel->hmask);
}
if (sel->flags & (TC_U32_OFFSET | TC_U32_VAROFFSET)) {
nl_dump(p, " offset at %u", sel->off);
if (sel->flags & TC_U32_VAROFFSET)
nl_dump(p, " variable (at %u & 0x%x) >> %u",
sel->offoff, ntohs(sel->offmask), sel->offshift);
}
if (sel->flags) {
int flags = sel->flags;
nl_dump(p, " <");
#define PRINT_FLAG(f) if (flags & TC_U32_##f) { \
flags &= ~TC_U32_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
PRINT_FLAG(TERMINAL);
PRINT_FLAG(OFFSET);
PRINT_FLAG(VAROFFSET);
PRINT_FLAG(EAT);
#undef PRINT_FLAG
nl_dump(p, ">");
}
for (i = 0; i < sel->nkeys; i++) {
key = &sel->keys[i];
nl_dump(p, "\n");
nl_dump_line(p, " match key at %s%u ",
key->offmask ? "nexthdr+" : "", key->off);
if (key->offmask)
nl_dump(p, "[0x%u] ", key->offmask);
nl_dump(p, "& 0x%08x == 0x%08x", ntohl(key->mask), ntohl(key->val));
if (p->dp_type == NL_DUMP_STATS &&
(u->cu_mask & U32_ATTR_PCNT)) {
struct tc_u32_pcnt *pcnt = u->cu_pcnt->d_data;
nl_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
}
}
}
void PicturePrinter::SetFontFlags(int32 flags) {
Indent(); Print("SetFontFlags");
int f = 0;
if (flags == 0) Print("none set");
PRINT_FLAG(B_DISABLE_ANTIALIASING);
PRINT_FLAG(B_FORCE_ANTIALIASING);
if (flags != f) printf("Unknown Additional Flags %" B_PRId32 "", flags & ~f);
Cr();
}
static void exp_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_exp *exp = (struct nfnl_exp *) a;
char buf[64];
int fp = 0;
exp_dump_line(a, p);
nl_dump(p, " id 0x%x ", exp->exp_id);
nl_dump_line(p, "family %s ",
nl_af2str(exp->exp_family, buf, sizeof(buf)));
if (nfnl_exp_test_timeout(exp)) {
uint64_t timeout_ms = nfnl_exp_get_timeout(exp) * 1000UL;
nl_dump(p, "timeout %s ",
nl_msec2str(timeout_ms, buf, sizeof(buf)));
}
if (nfnl_exp_test_helper_name(exp))
nl_dump(p, "helper %s ", exp->exp_helper_name);
if (nfnl_exp_test_fn(exp))
nl_dump(p, "fn %s ", exp->exp_fn);
if (nfnl_exp_test_class(exp))
nl_dump(p, "class %u ", nfnl_exp_get_class(exp));
if (nfnl_exp_test_zone(exp))
nl_dump(p, "zone %u ", nfnl_exp_get_zone(exp));
if (nfnl_exp_test_flags(exp))
nl_dump(p, "<");
#define PRINT_FLAG(str) \
{ nl_dump(p, "%s%s", fp++ ? "," : "", (str)); }
if (exp->exp_flags & NF_CT_EXPECT_PERMANENT)
PRINT_FLAG("PERMANENT");
if (exp->exp_flags & NF_CT_EXPECT_INACTIVE)
PRINT_FLAG("INACTIVE");
if (exp->exp_flags & NF_CT_EXPECT_USERSPACE)
PRINT_FLAG("USERSPACE");
#undef PRINT_FLAG
if (nfnl_exp_test_flags(exp))
nl_dump(p, ">");
nl_dump(p, "\n");
}
static void
print_uname(u_int flags)
{
PRINT_FLAG(flags, SFLAG, sysname);
PRINT_FLAG(flags, NFLAG, hostname);
PRINT_FLAG(flags, RFLAG, release);
PRINT_FLAG(flags, VFLAG, version);
PRINT_FLAG(flags, MFLAG, platform);
PRINT_FLAG(flags, PFLAG, arch);
PRINT_FLAG(flags, IFLAG, ident);
PRINT_FLAG(flags, KFLAG, kernvers);
PRINT_FLAG(flags, UFLAG, uservers);
printf("\n");
}
static void testClear(const char *title, SceUID flag, u32 bits) {
int result = sceKernelClearEventFlag(flag, bits);
if (result == 0) {
printf("%s: OK\n", title);
} else {
printf("%s: Failed (%X)\n", title, result);
}
PRINT_FLAG(flag);
}
void
print_uname(void)
{
PRINT_FLAG(flags, SFLAG, sysname);
PRINT_FLAG(flags, NFLAG, hostname);
PRINT_FLAG(flags, RFLAG, release);
PRINT_FLAG(flags, VFLAG, version);
PRINT_FLAG(flags, MFLAG, machine);
PRINT_FLAG(flags, PFLAG, arch);
PRINT_FLAG(flags, IFLAG, ident);
PRINT_FLAG(flags, GFLAG, pkgabi);
printf("\n");
}
static int route_dump_brief(struct nl_cache *c, struct nl_common *a, FILE *fd,
struct nl_dump_params *params)
{
struct rtnl_route *r = (struct rtnl_route *) a;
dp_new_line(fd, params, 0);
if (r->rt_mask & ROUTE_HAS_DST) {
char dst[INET6_ADDRSTRLEN+5];
fprintf(fd, "%s ", nl_addr2str_r(&r->rt_dst, dst, sizeof(dst)));
} else if (r->rt_dst_len)
fprintf(fd, "0/%u ", r->rt_dst_len);
else
fprintf(fd, "default ");
if (r->rt_mask & ROUTE_HAS_GATEWAY) {
char via[INET6_ADDRSTRLEN+5];
fprintf(fd, "via %s ", nl_addr2str_r(&r->rt_gateway, via, sizeof(via)));
}
if (r->rt_mask & ROUTE_HAS_OIF) {
const char *dev = rtnl_link_i2name(nl_cache_lookup(RTNL_LINK), r->rt_oif);
fprintf(fd, "dev %s ", dev);
}
if (r->rt_table != RT_TABLE_MAIN)
fprintf(fd, "table %u ", r->rt_table);
if (r->rt_mask & ROUTE_HAS_FLAGS && r->rt_flags) {
int flags = r->rt_flags;
fprintf(fd, "<");
#define PRINT_FLAG(f) if (flags & RTNH_F_##f) { \
flags &= ~RTNH_F_##f; fprintf(fd, #f "%s", flags ? "," : ""); }
PRINT_FLAG(DEAD);
PRINT_FLAG(ONLINK);
PRINT_FLAG(PERVASIVE);
#undef PRINT_FLAG
#define PRINT_FLAG(f) if (flags & RTM_F_##f) { \
flags &= ~RTM_F_##f; fprintf(fd, #f "%s", flags ? "," : ""); }
PRINT_FLAG(NOTIFY);
PRINT_FLAG(CLONED);
PRINT_FLAG(EQUALIZE);
PRINT_FLAG(PREFIX);
#undef PRINT_FLAG
fprintf(fd, ">");
}
fprintf(fd, "\n");
return 1;
}
int main(int argc, char **argv) {
SceUID flag = sceKernelCreateEventFlag("set", 0, 0, NULL);
PRINT_FLAG(flag);
testClear("Basic 0x2", flag, 0x2);
testClear("Basic 0x1", flag, 0x1);
testClear("Basic 0x1", flag, 0x1);
testClear("Basic 0xF000", flag, 0xF000);
testClear("Zero", flag, 0);
sceKernelDeleteEventFlag(flag);
flag = sceKernelCreateEventFlag("signal", 0, 0xFFFFFFFE, NULL);
PRINT_FLAG(flag);
testClear("All but 0x1 + 0x1", flag, 0x1);
sceKernelDeleteEventFlag(flag);
testClear("NULL", 0, 1);
testClear("Invalid", 0xDEADBEEF, 1);
testClear("Deleted", flag, 1);
BASIC_SCHED_TEST("NULL",
result = sceKernelClearEventFlag(0, 0);
);
void PicturePrinter::SetFontFace(int32 flags) {
Indent(); Print("SetFontFace");
int32 f = 0;
if (flags == 0) Print("none set");
PRINT_FLAG(B_REGULAR_FACE);
PRINT_FLAG(B_BOLD_FACE);
PRINT_FLAG(B_ITALIC_FACE);
PRINT_FLAG(B_NEGATIVE_FACE);
PRINT_FLAG(B_OUTLINED_FACE);
PRINT_FLAG(B_UNDERSCORE_FACE);
PRINT_FLAG(B_STRIKEOUT_FACE);
if (flags != f) printf("Unknown Additional Flags %" B_PRId32 "", flags & ~f);
Cr();
}
static int ipneigh_modify(int cmd, int flags, int argc, char **argv)
{
struct {
struct nlmsghdr n;
struct ndmsg ndm;
char buf[256];
} req = {
.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
.n.nlmsg_flags = NLM_F_REQUEST | flags,
.n.nlmsg_type = cmd,
.ndm.ndm_family = preferred_family,
.ndm.ndm_state = NUD_PERMANENT,
};
char *dev = NULL;
int dst_ok = 0;
int dev_ok = 0;
int lladdr_ok = 0;
char *lla = NULL;
inet_prefix dst;
while (argc > 0) {
if (matches(*argv, "lladdr") == 0) {
NEXT_ARG();
if (lladdr_ok)
duparg("lladdr", *argv);
lla = *argv;
lladdr_ok = 1;
} else if (strcmp(*argv, "nud") == 0) {
unsigned int state;
NEXT_ARG();
if (nud_state_a2n(&state, *argv))
invarg("nud state is bad", *argv);
req.ndm.ndm_state = state;
} else if (matches(*argv, "proxy") == 0) {
NEXT_ARG();
if (matches(*argv, "help") == 0)
usage();
if (dst_ok)
duparg("address", *argv);
get_addr(&dst, *argv, preferred_family);
dst_ok = 1;
dev_ok = 1;
req.ndm.ndm_flags |= NTF_PROXY;
} else if (strcmp(*argv, "router") == 0) {
req.ndm.ndm_flags |= NTF_ROUTER;
} else if (matches(*argv, "extern_learn") == 0) {
req.ndm.ndm_flags |= NTF_EXT_LEARNED;
} else if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
dev = *argv;
dev_ok = 1;
} else if (matches(*argv, "protocol") == 0) {
__u32 proto;
NEXT_ARG();
if (rtnl_rtprot_a2n(&proto, *argv))
invarg("\"protocol\" value is invalid\n", *argv);
if (addattr8(&req.n, sizeof(req), NDA_PROTOCOL, proto))
return -1;
} else {
if (strcmp(*argv, "to") == 0) {
NEXT_ARG();
}
if (matches(*argv, "help") == 0) {
NEXT_ARG();
}
if (dst_ok)
duparg2("to", *argv);
get_addr(&dst, *argv, preferred_family);
dst_ok = 1;
}
argc--; argv++;
}
if (!dev_ok || !dst_ok || dst.family == AF_UNSPEC) {
fprintf(stderr, "Device and destination are required arguments.\n");
exit(-1);
}
req.ndm.ndm_family = dst.family;
if (addattr_l(&req.n, sizeof(req), NDA_DST, &dst.data, dst.bytelen) < 0)
return -1;
if (lla && strcmp(lla, "null")) {
char llabuf[20];
int l;
l = ll_addr_a2n(llabuf, sizeof(llabuf), lla);
if (l < 0)
return -1;
if (addattr_l(&req.n, sizeof(req), NDA_LLADDR, llabuf, l) < 0)
return -1;
}
ll_init_map(&rth);
if (dev) {
req.ndm.ndm_ifindex = ll_name_to_index(dev);
if (!req.ndm.ndm_ifindex)
return nodev(dev);
}
if (rtnl_talk(&rth, &req.n, NULL) < 0)
exit(2);
return 0;
}
static void print_cacheinfo(const struct nda_cacheinfo *ci)
{
static int hz;
if (!hz)
hz = get_user_hz();
if (ci->ndm_refcnt)
print_uint(PRINT_ANY, "refcnt",
" ref %u", ci->ndm_refcnt);
print_uint(PRINT_ANY, "used", " used %u", ci->ndm_used / hz);
print_uint(PRINT_ANY, "confirmed", "/%u", ci->ndm_confirmed / hz);
print_uint(PRINT_ANY, "updated", "/%u", ci->ndm_updated / hz);
}
static void print_neigh_state(unsigned int nud)
{
open_json_array(PRINT_JSON,
is_json_context() ? "state" : "");
#define PRINT_FLAG(f) \
if (nud & NUD_##f) { \
nud &= ~NUD_##f; \
print_string(PRINT_ANY, NULL, " %s", #f); \
}
PRINT_FLAG(INCOMPLETE);
PRINT_FLAG(REACHABLE);
PRINT_FLAG(STALE);
PRINT_FLAG(DELAY);
PRINT_FLAG(PROBE);
PRINT_FLAG(FAILED);
PRINT_FLAG(NOARP);
PRINT_FLAG(PERMANENT);
#undef PRINT_FLAG
close_json_array(PRINT_JSON, NULL);
}
int print_neigh(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
{
FILE *fp = (FILE*)arg;
struct ndmsg *r = NLMSG_DATA(n);
int len = n->nlmsg_len;
struct rtattr * tb[NDA_MAX+1];
char abuf[256];
if (n->nlmsg_type != RTM_NEWNEIGH && n->nlmsg_type != RTM_DELNEIGH &&
n->nlmsg_type != RTM_GETNEIGH) {
fprintf(stderr, "Not RTM_NEWNEIGH: %08x %08x %08x\n",
n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
return 0;
}
len -= NLMSG_LENGTH(sizeof(*r));
if (len < 0) {
fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
return -1;
}
if (filter.flushb && n->nlmsg_type != RTM_NEWNEIGH)
return 0;
if (filter.family && filter.family != r->ndm_family)
return 0;
if (filter.index && filter.index != r->ndm_ifindex)
return 0;
if (!(filter.state&r->ndm_state) &&
!(r->ndm_flags & NTF_PROXY) &&
(r->ndm_state || !(filter.state&0x100)) &&
(r->ndm_family != AF_DECnet))
return 0;
parse_rtattr(tb, NDA_MAX, NDA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
if (tb[NDA_DST]) {
if (filter.pfx.family) {
inet_prefix dst;
memset(&dst, 0, sizeof(dst));
dst.family = r->ndm_family;
memcpy(&dst.data, RTA_DATA(tb[NDA_DST]), RTA_PAYLOAD(tb[NDA_DST]));
if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
return 0;
}
}
if (filter.unused_only && tb[NDA_CACHEINFO]) {
struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
if (ci->ndm_refcnt)
return 0;
}
if (filter.flushb) {
struct nlmsghdr *fn;
if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {
if (flush_update())
return -1;
}
fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp));
memcpy(fn, n, n->nlmsg_len);
fn->nlmsg_type = RTM_DELNEIGH;
fn->nlmsg_flags = NLM_F_REQUEST;
fn->nlmsg_seq = ++rth.seq;
filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb;
filter.flushed++;
if (show_stats < 2)
return 0;
}
if (n->nlmsg_type == RTM_DELNEIGH)
fprintf(fp, "delete ");
else if (n->nlmsg_type == RTM_GETNEIGH)
fprintf(fp, "miss ");
if (tb[NDA_DST]) {
fprintf(fp, "%s ",
format_host(r->ndm_family,
RTA_PAYLOAD(tb[NDA_DST]),
RTA_DATA(tb[NDA_DST]),
abuf, sizeof(abuf)));
}
if (!filter.index && r->ndm_ifindex)
fprintf(fp, "dev %s ", ll_index_to_name(r->ndm_ifindex));
if (tb[NDA_LLADDR]) {
SPRINT_BUF(b1);
fprintf(fp, "lladdr %s", ll_addr_n2a(RTA_DATA(tb[NDA_LLADDR]),
RTA_PAYLOAD(tb[NDA_LLADDR]),
ll_index_to_type(r->ndm_ifindex),
b1, sizeof(b1)));
}
if (r->ndm_flags & NTF_ROUTER) {
fprintf(fp, " router");
}
if (r->ndm_flags & NTF_PROXY) {
fprintf(fp, " proxy");
}
if (tb[NDA_CACHEINFO] && show_stats) {
struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
int hz = get_user_hz();
if (ci->ndm_refcnt)
printf(" ref %d", ci->ndm_refcnt);
fprintf(fp, " used %d/%d/%d", ci->ndm_used/hz,
ci->ndm_confirmed/hz, ci->ndm_updated/hz);
}
if (tb[NDA_PROBES] && show_stats) {
__u32 p = rta_getattr_u32(tb[NDA_PROBES]);
fprintf(fp, " probes %u", p);
}
if (r->ndm_state) {
int nud = r->ndm_state;
fprintf(fp, " ");
#define PRINT_FLAG(f) if (nud & NUD_##f) { \
nud &= ~NUD_##f; fprintf(fp, #f "%s", nud ? "," : ""); }
PRINT_FLAG(INCOMPLETE);
PRINT_FLAG(REACHABLE);
PRINT_FLAG(STALE);
PRINT_FLAG(DELAY);
PRINT_FLAG(PROBE);
PRINT_FLAG(FAILED);
PRINT_FLAG(NOARP);
PRINT_FLAG(PERMANENT);
#undef PRINT_FLAG
}
fprintf(fp, "\n");
fflush(fp);
return 0;
}
static void ct_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_ct *ct = (struct nfnl_ct *) a;
char buf[64];
int fp = 0;
ct_dump_line(a, p);
nl_dump(p, " id 0x%x ", ct->ct_id);
nl_dump_line(p, "family %s ",
nl_af2str(ct->ct_family, buf, sizeof(buf)));
if (nfnl_ct_test_use(ct))
nl_dump(p, "refcnt %u ", nfnl_ct_get_use(ct));
if (nfnl_ct_test_timeout(ct)) {
uint64_t timeout_ms = nfnl_ct_get_timeout(ct) * 1000UL;
nl_dump(p, "timeout %s ",
nl_msec2str(timeout_ms, buf, sizeof(buf)));
}
if (ct->ct_status)
nl_dump(p, "<");
#define PRINT_FLAG(str) \
{ nl_dump(p, "%s%s", fp++ ? "," : "", (str)); }
if (ct->ct_status & IPS_EXPECTED)
PRINT_FLAG("EXPECTED");
if (!(ct->ct_status & IPS_SEEN_REPLY))
PRINT_FLAG("NOREPLY");
if (ct->ct_status & IPS_ASSURED)
PRINT_FLAG("ASSURED");
if (!(ct->ct_status & IPS_CONFIRMED))
PRINT_FLAG("NOTSENT");
if (ct->ct_status & IPS_SRC_NAT)
PRINT_FLAG("SNAT");
if (ct->ct_status & IPS_DST_NAT)
PRINT_FLAG("DNAT");
if (ct->ct_status & IPS_SEQ_ADJUST)
PRINT_FLAG("SEQADJUST");
if (!(ct->ct_status & IPS_SRC_NAT_DONE))
PRINT_FLAG("SNAT_INIT");
if (!(ct->ct_status & IPS_DST_NAT_DONE))
PRINT_FLAG("DNAT_INIT");
if (ct->ct_status & IPS_DYING)
PRINT_FLAG("DYING");
if (ct->ct_status & IPS_FIXED_TIMEOUT)
PRINT_FLAG("FIXED_TIMEOUT");
#undef PRINT_FLAG
if (ct->ct_status)
nl_dump(p, ">");
nl_dump(p, "\n");
}
void darm_dump(const darm_t *d)
{
printf(
"encoded: 0x%08x\n"
"instr: I_%s\n"
"instr-type: T_%s\n",
d->w, darm_mnemonic_name(d->instr),
darm_enctype_name(d->instr_type));
if(d->cond == C_UNCOND) {
printf("cond: unconditional\n");
}
else if(d->cond != C_INVLD) {
printf("cond: C_%s\n", darm_condition_name(d->cond, 0));
}
#define PRINT_REG(reg) if(d->reg != R_INVLD) \
printf("%-5s %s\n", #reg ":", darm_register_name(d->reg))
PRINT_REG(Rd);
PRINT_REG(Rn);
PRINT_REG(Rm);
PRINT_REG(Ra);
PRINT_REG(Rt);
PRINT_REG(Rt2);
PRINT_REG(RdHi);
PRINT_REG(RdLo);
if(d->I == B_SET) {
printf("imm: 0x%08x %d\n", d->imm, d->imm);
}
#define PRINT_FLAG(flag, comment, comment2) if(d->flag != B_INVLD) \
printf("%s: %d (%s)\n", #flag, d->flag, \
d->flag == B_SET ? comment : comment2)
PRINT_FLAG(B, "swap one byte", "swap four bytes");
PRINT_FLAG(S, "updates conditional flag",
"does NOT update conditional flags");
PRINT_FLAG(E, "change to big endian", "change to little endian");
PRINT_FLAG(U, "add offset to address", "subtract offset from address");
PRINT_FLAG(H, "Thumb2 instruction is two-byte aligned",
"Thumb2 instruction is four-byte aligned");
PRINT_FLAG(P, "pre-indexed addressing", "post-indexed addressing");
PRINT_FLAG(M, "take the top halfword as source",
"take the bottom halfword as source");
PRINT_FLAG(N, "take the top halfword as source",
"take the bottom halfword as source");
PRINT_FLAG(T, "PKHTB form", "PKHBT form");
PRINT_FLAG(R, "round the result", "do NOT round the result");
PRINT_FLAG(W, "write-back", "do NOT write-back");
PRINT_FLAG(I, "immediate present", "no immediate present");
if(d->option != O_INVLD) {
printf("option: %d\n", d->option);
}
if(d->rotate != 0) {
printf("rotate: %d\n", d->rotate);
}
if(d->shift_type != S_INVLD) {
if(d->Rs == R_INVLD) {
printf(
"type: %s (shift type)\n"
"shift: %-2d (shift constant)\n",
darm_shift_type_name(d->shift_type), d->shift);
}
else {
printf(
"type: %s (shift type)\n"
"Rs: %s (register-shift)\n",
darm_shift_type_name(d->shift_type),
darm_register_name(d->Rs));
}
}
if(d->lsb != 0 || d->width != 0) {
printf(
"lsb: %d\n"
"width: %d\n",
d->lsb, d->width);
}
if(d->reglist != 0) {
char reglist[64];
darm_reglist(d->reglist, reglist);
printf("reglist: %s\n", reglist);
}
if(d->opc1 != 0 || d->opc2 != 0 || d->coproc != 0) {
printf("opc1: %d\n", d->opc1);
printf("opc2: %d\n", d->opc2);
printf("coproc: %d\n", d->coproc);
}
PRINT_REG(CRn);
PRINT_REG(CRm);
PRINT_REG(CRd);
printf("\n");
}
void
PrintStatus(DWORD PdoStatus) {
_tprintf(TEXT("ADAPTERINFO_STATUS : %s\n"),
ADAPTERINFO_ISSTATUS(PdoStatus, NDASSCSI_ADAPTER_STATUS_INIT) ? TEXT("NDASSCSI_ADAPTER_STATUS_INIT") :
ADAPTERINFO_ISSTATUS(PdoStatus, NDASSCSI_ADAPTER_STATUS_RUNNING) ? TEXT("NDASSCSI_ADAPTER_STATUS_RUNNING") :
ADAPTERINFO_ISSTATUS(PdoStatus, NDASSCSI_ADAPTER_STATUS_STOPPING) ? TEXT("NDASSCSI_ADAPTER_STATUS_STOPPING") :
ADAPTERINFO_ISSTATUS(PdoStatus, NDASSCSI_ADAPTER_STATUS_STOPPED) ? TEXT("NDASSCSI_ADAPTER_STATUS_STOPPED") :
TEXT("Unknown status"));
#define PRINT_FLAG(STATUS, FLAG) \
_tprintf(TEXT("") TEXT(#FLAG) TEXT(": %s\n"), ADAPTERINFO_ISSTATUSFLAG((STATUS), (FLAG)) ? TEXT("ON") : TEXT("off"));
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_RECONNECT_PENDING);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_RESTARTING);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_BUSRESET_PENDING);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_MEMBER_FAULT);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_RECOVERING);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_ABNORMAL_TERMINAT);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_POWERRECYCLED);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_RAID_FAILURE);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_RAID_NORMAL);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_RESETSTATUS);
PRINT_FLAG(PdoStatus, NDASSCSI_ADAPTER_STATUSFLAG_NEXT_EVENT_EXIST);
#undef PRINT_FLAG
}
void dump_sdr_flags
(DATA_HDR *ch, /* DATA_HDR for record. */
int detail) /* dump only non-zero field if false. */
{
#ifdef QLIB_DEBUG
PRINT_FLAG("Activity flag","calibration", BIT(ch->activity_flags,0),detail);
PRINT_FLAG("Activity flag","clock correction", BIT(ch->activity_flags,1),detail);
PRINT_FLAG("Activity flag","begin event", BIT(ch->activity_flags,2),detail);
PRINT_FLAG("Activity flag","end event", BIT(ch->activity_flags,3),detail);
PRINT_FLAG("Activity flag","+ leap second", BIT(ch->activity_flags,4),detail);
PRINT_FLAG("Activity flag","- leap second", BIT(ch->activity_flags,5),detail);
PRINT_FLAG("Activity flag","event in progress", BIT(ch->activity_flags,6),detail);
PRINT_FLAG("I/O flag","parity error", BIT(ch->io_flags,0),detail);
PRINT_FLAG("I/O flag","long record", BIT(ch->io_flags,1),detail);
PRINT_FLAG("I/O flag","short record", BIT(ch->io_flags,2),detail);
PRINT_FLAG("Quality flag","saturation", BIT(ch->data_quality_flags,0),detail);
PRINT_FLAG("Quality flag","clipping", BIT(ch->data_quality_flags,1),detail);
PRINT_FLAG("Quality flag","spikes", BIT(ch->data_quality_flags,2),detail);
PRINT_FLAG("Quality flag","glitches", BIT(ch->data_quality_flags,3),detail);
PRINT_FLAG("Quality flag","missing/padded data", BIT(ch->data_quality_flags,4),detail);
PRINT_FLAG("Quality flag","sync error", BIT(ch->data_quality_flags,5),detail);
PRINT_FLAG("Quality flag","charging digital filter", BIT(ch->data_quality_flags,6),detail);
PRINT_FLAG("Quality flag","questionable time tag", BIT(ch->data_quality_flags,7),detail);
#endif
}
int __cdecl _tmain(int argc, LPTSTR* argv)
{
BOOL fSuccess(FALSE);
ULONG SlotNo;
BOOL bret;
if(argc < 2) {
usage();
return 1;
}
if (lstrcmpi(argv[1],TEXT("version")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
bret = LsBusCtlGetVersion(
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate
);
if(bret == FALSE) {
_tprintf(TEXT("LanscsiBus control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- LanscsiBus version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate);
}
} else if(lstrcmpi(argv[1],TEXT("mpversion")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlGetMiniportVersion(
SlotNo,
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate
);
if(bret == FALSE) {
_tprintf(TEXT("NDASSCSI control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- NDASSCSI version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate);
}
} else if(lstrcmpi(argv[1],TEXT("slotlist")) == 0) {
PBUSENUM_INFORMATION busInfo;
bret = LsBusCtlQueryPdoSlotList(&busInfo);
if(bret == FALSE) {
_tprintf(TEXT("Querying slot list failed. LastError:%lu\n"), GetLastError());
} else {
ULONG idx_slot;
_tprintf(TEXT("Slot list:"));
for(idx_slot = 0; idx_slot < busInfo->PdoSlotList.SlotNoCnt; idx_slot++ ) {
_tprintf(TEXT(" %lu"), busInfo->PdoSlotList.SlotNo[idx_slot]);
}
_tprintf(TEXT("\n"));
HeapFree(GetProcessHeap(), 0, busInfo);
}
} else if(lstrcmpi(argv[1],TEXT("pdoevent")) == 0) {
HANDLE alarm;
HANDLE discon;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryPdoEvent(SlotNo, &alarm, &discon);
if(bret == FALSE) {
_tprintf(TEXT("Querying pdo events failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf( TEXT("Alarm event : %p\n")
TEXT("Disconnection event: %p\n"),
alarm, discon
);
bret = CloseHandle(alarm);
if(bret == FALSE) {
_tprintf(TEXT("Closing alarm event failed. LastError:%lu\n"), GetLastError());
}
bret = CloseHandle(discon);
if(bret == FALSE) {
_tprintf(TEXT("Closing disconnection event failed. LastError:%lu\n"), GetLastError());
}
}
} else if(lstrcmpi(argv[1],TEXT("status")) == 0) {
ULONG ulStatus;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryStatus(SlotNo, &ulStatus);
if(bret == FALSE) {
_tprintf(TEXT("Querying LUR full information failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("ADAPTERINFO_STATUS : %s\n"),
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_INIT) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_INIT") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_RUNNING) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_RUNNING") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPING) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_STOPPING") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_IN_ERROR) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_IN_ERROR") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPED) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_STOPPED") :
TEXT("Unknown status"));
#define PRINT_FLAG(STATUS, FLAG) \
_tprintf(TEXT("") TEXT(#FLAG) TEXT(": %s\n"), ADAPTERINFO_ISSTATUSFLAG((STATUS), (FLAG)) ? TEXT("ON") : TEXT("off"));
PRINT_FLAG(ulStatus, NDASSCSI_ADAPTERINFO_STATUSFLAG_RECONNECT_PENDING);
PRINT_FLAG(ulStatus, ADAPTERINFO_STATUSFLAG_POWERSAVING_PENDING);
PRINT_FLAG(ulStatus, ADAPTERINFO_STATUSFLAG_BUSRESET_PENDING);
PRINT_FLAG(ulStatus, NDASSCSI_ADAPTERINFO_STATUSFLAG_MEMBER_FAULT);
#undef PRINT_FLAG
}
} else if(lstrcmpi(argv[1],TEXT("fdoinfo")) == 0) {
PNDSCIOCTL_ADAPTERLURINFO lurFullInfo;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryMiniportFullInformation(SlotNo, &lurFullInfo);
if(bret == FALSE) {
_tprintf(TEXT("Querying LUR full information failed. LastError:%lu\n"), GetLastError());
} else {
ULONG idx_ud;
PNDSC_LURN_FULL unitDisk;
_tprintf(TEXT("Structure length :%u\n"), lurFullInfo->Length);
_tprintf(TEXT("Adapter.SlotNo :%u\n"), lurFullInfo->Adapter.SlotNo);
_tprintf(TEXT("Adapter.Length :%u\n"), lurFullInfo->Adapter.Length);
_tprintf(TEXT("Adapter.InitiatorId :%u\n"), (int)lurFullInfo->Adapter.InitiatorId);
_tprintf(TEXT("Adapter.NumberOfBuses :%u\n"), (int)lurFullInfo->Adapter.NumberOfBuses);
_tprintf(TEXT("Adapter.MaximumNumberOfTargets :%u\n"), (int)lurFullInfo->Adapter.MaximumNumberOfTargets);
_tprintf(TEXT("Adapter.MaximumNumberOfLogicalUnits :%u\n"), (int)lurFullInfo->Adapter.MaximumNumberOfLogicalUnits);
_tprintf(TEXT("Adapter.MaxBlocksPerRequest :%u\n"), lurFullInfo->Adapter.MaxBlocksPerRequest);
_tprintf(TEXT("Adapter.Status :%08lx\n"), lurFullInfo->Adapter.Status);
_tprintf(TEXT("Lur.Length :%u\n"), lurFullInfo->Lur.Length);
_tprintf(TEXT("Lur.DevType :%08lx\n"), lurFullInfo->Lur.DevType);
_tprintf(TEXT("Lur.TargetId :%u\n"), lurFullInfo->Lur.TargetId);
_tprintf(TEXT("Lur.Lun :%u\n"), lurFullInfo->Lur.Lun);
_tprintf(TEXT("Lur.DesiredAccess :%08lx\n"), lurFullInfo->Lur.DesiredAccess);
_tprintf(TEXT("Lur.GrantedAccess :%08lx\n"), lurFullInfo->Lur.GrantedAccess);
_tprintf(TEXT("Lur.LurnCnt :%u\n"), lurFullInfo->Lur.LurnCnt);
_tprintf(TEXT("EnableTime :%I64u\n"), lurFullInfo->EnabledTime.QuadPart);
_tprintf(TEXT("UnitDiskCnt :%u\n"), lurFullInfo->UnitDiskCnt);
for(idx_ud = 0; idx_ud < lurFullInfo->UnitDiskCnt; idx_ud++) {
unitDisk = lurFullInfo->UnitDisks + idx_ud;
_tprintf(TEXT("- LURN #%u :\n"), idx_ud);
_tprintf(TEXT("Length :%u\n"), unitDisk->Length);
_tprintf(TEXT("LurnId :%u\n"), unitDisk->LurnId);
_tprintf(TEXT("LurnType :%u\n"), unitDisk->LurnType);
_tprintf(TEXT("NetDiskAddress.TAAddressCount :%u\n"), unitDisk->NetDiskAddress.TAAddressCount);
_tprintf(TEXT("NetDiskAddress.Address[0].AddressType :%x\n"), unitDisk->NetDiskAddress.Address[0].AddressType);
_tprintf(TEXT("NetDiskAddress.Address[0].AddressLength :%x\n"), unitDisk->NetDiskAddress.Address[0].AddressLength);
_tprintf(TEXT("NetDiskAddress.Address[0].Address :%02X %02X | %02X %02X %02X %02X %02X %02X\n"),
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[0],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[1],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[2],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[3],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[4],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[5],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[6],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[7]
);
_tprintf(TEXT("BindingAddress.TAAddressCount :%u\n"), unitDisk->BindingAddress.TAAddressCount);
_tprintf(TEXT("BindingAddress.Address[0].AddressType :%x\n"), unitDisk->BindingAddress.Address[0].AddressType);
_tprintf(TEXT("BindingAddress.Address[0].AddressLength :%x\n"), unitDisk->BindingAddress.Address[0].AddressLength);
_tprintf(TEXT("BindingAddress.Address[0].Address :%02X %02X | %02X %02X %02X %02X %02X %02X\n"),
(int)unitDisk->BindingAddress.Address[0].Address.Address[0],
(int)unitDisk->BindingAddress.Address[0].Address.Address[1],
(int)unitDisk->BindingAddress.Address[0].Address.Address[2],
(int)unitDisk->BindingAddress.Address[0].Address.Address[3],
(int)unitDisk->BindingAddress.Address[0].Address.Address[4],
(int)unitDisk->BindingAddress.Address[0].Address.Address[5],
(int)unitDisk->BindingAddress.Address[0].Address.Address[6],
(int)unitDisk->BindingAddress.Address[0].Address.Address[7]
);
_tprintf(TEXT("UnitDiskId :%u\n"), (int)unitDisk->UnitDiskId);
_tprintf(TEXT("UserID :%02x %02x %02x %02x\n"),
(int)unitDisk->UserID[0],
(int)unitDisk->UserID[1],
(int)unitDisk->UserID[2],
(int)unitDisk->UserID[3]
);
_tprintf(TEXT("Password :%02x %02x %02x %02x %02x %02x\n"),
(int)unitDisk->Password[0],
(int)unitDisk->Password[1],
(int)unitDisk->Password[2],
(int)unitDisk->Password[3],
(int)unitDisk->Password[4],
(int)unitDisk->Password[5]
);
_tprintf(TEXT("AccessRight :%08lx\n"), unitDisk->AccessRight);
_tprintf(TEXT("UnitBlocks :%u\n"), unitDisk->UnitBlocks);
_tprintf(TEXT("StatusFlags :%u\n"), unitDisk->StatusFlags);
}
_tprintf(TEXT("\n"));
HeapFree(GetProcessHeap(), 0, lurFullInfo);
}
} else if(lstrcmpi(argv[1],TEXT("pdofile")) == 0) {
HANDLE pdoFileHandle;
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryPdoFileHandle(SlotNo, &pdoFileHandle);
if(bret == FALSE) {
_tprintf(TEXT("Querying PDO file handle failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("PDO file handle :%p\n"), pdoFileHandle);
ZwClose(pdoFileHandle);
}
} else {
usage();
}
return fSuccess ? 0 : 1;
}
