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; }