Index: Makefile =================================================================== --- Makefile +++ Makefile @@ -4,6 +4,7 @@ PROG= pciconf SRCS= pciconf.c cap.c err.c MAN= pciconf.8 +LIBADD= xo WARNS?= 3 Index: cap.c =================================================================== --- cap.c +++ cap.c @@ -39,6 +39,7 @@ #include #include #include +#include #include #include @@ -52,12 +53,16 @@ { uint16_t cap, status; + xo_emit("{e:capability-name/Power Management}"); cap = read_config(fd, &p->pc_sel, ptr + PCIR_POWER_CAP, 2); status = read_config(fd, &p->pc_sel, ptr + PCIR_POWER_STATUS, 2); - printf("powerspec %d supports D0%s%s D3 current D%d", - cap & PCIM_PCAP_SPEC, + //printf("powerspec %d supports D0%s%s D3 current D%d", + xo_emit("powerspec {:power-management-version/%d} ", + cap & PCIM_PCAP_SPEC); + xo_emit("supports {:supported-power-states/D0%s%s D3} ", cap & PCIM_PCAP_D1SUPP ? " D1" : "", - cap & PCIM_PCAP_D2SUPP ? " D2" : "", + cap & PCIM_PCAP_D2SUPP ? " D2" : ""); + xo_emit("current {q:current-power-state/D%d}", status & PCIM_PSTAT_DMASK); } @@ -68,58 +73,78 @@ status = read_config(fd, &p->pc_sel, ptr + AGP_STATUS, 4); command = read_config(fd, &p->pc_sel, ptr + AGP_CAPID, 4); - printf("AGP "); + //printf("AGP "); + xo_emit("{:capability-name/AGP} "); if (AGP_MODE_GET_MODE_3(status)) { - printf("v3 "); + //printf("v3 "); + xo_emit("v{:agp-version/%d} ", 3); if (AGP_MODE_GET_RATE(status) & AGP_MODE_V3_RATE_8x) - printf("8x "); + //printf("8x "); + xo_emit("{:agp-speed/8}x "); if (AGP_MODE_GET_RATE(status) & AGP_MODE_V3_RATE_4x) - printf("4x "); + //printf("4x "); + xo_emit("{:agp-speed/4}x "); } else { + //xo_emit("v{:agp-version/%d} ", 2); if (AGP_MODE_GET_RATE(status) & AGP_MODE_V2_RATE_4x) - printf("4x "); + //printf("4x "); + xo_emit("{:agp-speed/4}x "); if (AGP_MODE_GET_RATE(status) & AGP_MODE_V2_RATE_2x) - printf("2x "); + //printf("2x "); + xo_emit("{:agp-speed/2}x "); if (AGP_MODE_GET_RATE(status) & AGP_MODE_V2_RATE_1x) - printf("1x "); + //printf("1x "); + xo_emit("{:agp-speed/1}x "); } if (AGP_MODE_GET_SBA(status)) - printf("SBA "); + //printf("SBA "); + xo_emit("SBA "); if (AGP_MODE_GET_AGP(command)) { - printf("enabled at "); + //printf("enabled at "); + xo_emit("{:side-band-addressing/enabled} at "); if (AGP_MODE_GET_MODE_3(command)) { - printf("v3 "); + //printf("v3 "); + xo_emit("v{:agp-version/%d} ", 3); switch (AGP_MODE_GET_RATE(command)) { case AGP_MODE_V3_RATE_8x: - printf("8x "); + //printf("8x "); + xo_emit("{:side-band-addressing-speed/8}x "); break; case AGP_MODE_V3_RATE_4x: - printf("4x "); + //printf("4x "); + xo_emit("{:side-band-addressing-speed/4}x "); break; } } else switch (AGP_MODE_GET_RATE(command)) { case AGP_MODE_V2_RATE_4x: - printf("4x "); + //printf("4x "); + xo_emit("{:side-band-addressing-speed/4}x "); break; case AGP_MODE_V2_RATE_2x: - printf("2x "); + //printf("2x "); + xo_emit("{:side-band-addressing-speed/2}x "); break; case AGP_MODE_V2_RATE_1x: - printf("1x "); + //printf("1x "); + xo_emit("{:side-band-addressing-speed/1}x "); break; } if (AGP_MODE_GET_SBA(command)) - printf("SBA "); + //printf("SBA "); + xo_emit("SBA "); } else - printf("disabled"); + //printf("disabled"); + xo_emit("{:side-band-addressing/disabled}"); } static void cap_vpd(int fd, struct pci_conf *p, uint8_t ptr) { - printf("VPD"); + //printf("VPD"); + xo_emit("{:capability-name/VPD}"); + xo_emit("{q:vital-product-data/true}"); } static void @@ -130,14 +155,21 @@ ctrl = read_config(fd, &p->pc_sel, ptr + PCIR_MSI_CTRL, 2); msgnum = 1 << ((ctrl & PCIM_MSICTRL_MMC_MASK) >> 1); - printf("MSI supports %d message%s%s%s ", msgnum, - (msgnum == 1) ? "" : "s", + //printf("MSI supports %d message%s%s%s ", msgnum, + xo_emit("{:capability-name/MSI} "); + xo_emit("supports {:multi-message-capable/%d} message{d:/%s%s%s} ", + msgnum, (msgnum == 1) ? "" : "s", (ctrl & PCIM_MSICTRL_64BIT) ? ", 64 bit" : "", (ctrl & PCIM_MSICTRL_VECTOR) ? ", vector masks" : ""); + xo_emit("{e:capable-of-64-bits/%s}", + (ctrl & PCIM_MSICTRL_64BIT) ? "true" : "false"); + xo_emit("{e:per-vector-mask-capable/%s}", + (ctrl & PCIM_MSICTRL_VECTOR) ? "true" : "false"); if (ctrl & PCIM_MSICTRL_MSI_ENABLE) { msgnum = 1 << ((ctrl & PCIM_MSICTRL_MME_MASK) >> 4); - printf("enabled with %d message%s", msgnum, - (msgnum == 1) ? "" : "s"); + //printf("enabled with %d message%s", msgnum, + xo_emit("enabled with {:multiple-message-enable/%d} message{d:/%s}", + msgnum, (msgnum == 1) ? "" : "s"); } } @@ -148,25 +180,35 @@ int comma, max_splits, max_burst_read; status = read_config(fd, &p->pc_sel, ptr + PCIXR_STATUS, 4); - printf("PCI-X "); + //printf("PCI-X "); + xo_emit("{:capability-name/PCI-X} "); // XXX not yet ready if (status & PCIXM_STATUS_64BIT) - printf("64-bit "); + //printf("64-bit "); + xo_emit("{:pcix-feature/64-bit} "); if ((p->pc_hdr & PCIM_HDRTYPE) == 1) - printf("bridge "); + //printf("bridge "); + xo_emit("{:pcix-device-type/bridge} "); if ((p->pc_hdr & PCIM_HDRTYPE) != 1 || (status & (PCIXM_STATUS_133CAP | PCIXM_STATUS_266CAP | PCIXM_STATUS_533CAP)) != 0) - printf("supports"); + //printf("supports"); + xo_emit("supports"); comma = 0; if (status & PCIXM_STATUS_133CAP) { - printf("%s 133MHz", comma ? "," : ""); + //printf("%s 133MHz", comma ? "," : ""); + xo_emit("{:supported-bus-speed-133mhz/%s 133MHz/true}", + comma ? "," : ""); comma = 1; } if (status & PCIXM_STATUS_266CAP) { - printf("%s 266MHz", comma ? "," : ""); + //printf("%s 266MHz", comma ? "," : ""); + xo_emit("{:supported-bus-speed-266mhz/%s 266MHz/true}", + comma ? "," : ""); comma = 1; } if (status & PCIXM_STATUS_533CAP) { - printf("%s 533MHz", comma ? "," : ""); + //printf("%s 533MHz", comma ? "," : ""); + xo_emit("{:supported-bus-speed-533mhz/%s 533MHz/true}", + comma ? "," : ""); comma = 1; } if ((p->pc_hdr & PCIM_HDRTYPE) == 1) @@ -211,8 +253,11 @@ max_splits = 32; break; } - printf("%s %d burst read, %d split transaction%s", comma ? "," : "", - max_burst_read, max_splits, max_splits == 1 ? "" : "s"); + //printf("%s %d burst read, %d split transaction%s", comma ? "," : "", + xo_emit("{d:/%s }{:maximum-read-burst/%d} burst read, ", + comma ? "," : "", max_burst_read); + xo_emit("{:maximum-split-transactions/%d} split transaction{d:/%s}", + max_splits, max_splits == 1 ? "" : "s"); } static void @@ -222,74 +267,101 @@ uint16_t command; command = read_config(fd, &p->pc_sel, ptr + PCIR_HT_COMMAND, 2); - printf("HT "); + //printf("HT "); + xo_emit("HT {eq:capability-name/Hyper-Transport}"); if ((command & 0xe000) == PCIM_HTCAP_SLAVE) - printf("slave"); + //printf("slave"); + xo_emit("slave{eq:hyper-transport-mode/slave}"); else if ((command & 0xe000) == PCIM_HTCAP_HOST) - printf("host"); + //printf("host"); + xo_emit("host{eq:hyper-transport-mode/host}"); else switch (command & PCIM_HTCMD_CAP_MASK) { case PCIM_HTCAP_SWITCH: - printf("switch"); + //printf("switch"); + xo_emit("{q:hyper-transport-mode/switch}"); break; case PCIM_HTCAP_INTERRUPT: - printf("interrupt"); + //printf("interrupt"); + xo_emit("{q:hyper-transport-mode/interrupt}"); break; case PCIM_HTCAP_REVISION_ID: - printf("revision ID"); + //printf("revision ID"); + xo_emit("{q:hyper-transport-mode/revision ID}"); break; case PCIM_HTCAP_UNITID_CLUMPING: - printf("unit ID clumping"); + //printf("unit ID clumping"); + xo_emit("{q:hyper-tranport-mode/unit ID clumping}"); break; case PCIM_HTCAP_EXT_CONFIG_SPACE: - printf("extended config space"); + //printf("extended config space"); + xo_emit("{q:hyper-transport-mode/extended config space}"); break; case PCIM_HTCAP_ADDRESS_MAPPING: - printf("address mapping"); + //printf("address mapping"); + xo_emit("{q:hyper-transport-mode/address mapping}"); break; case PCIM_HTCAP_MSI_MAPPING: - printf("MSI %saddress window %s at 0x", + //printf("MSI %saddress window %s at 0x", + xo_emit("{d:/MSI %saddress window %s at }", command & PCIM_HTCMD_MSI_FIXED ? "fixed " : "", command & PCIM_HTCMD_MSI_ENABLE ? "enabled" : "disabled"); if (command & PCIM_HTCMD_MSI_FIXED) - printf("fee00000"); + //printf("fee00000"); + xo_emit("{:msi-window-address/0xfee00000}"); else { reg = read_config(fd, &p->pc_sel, ptr + PCIR_HTMSI_ADDRESS_HI, 4); + //if (reg != 0) + //printf("%08x", reg); if (reg != 0) - printf("%08x", reg); - reg = read_config(fd, &p->pc_sel, - ptr + PCIR_HTMSI_ADDRESS_LO, 4); - printf("%08x", reg); + xo_emit("{:msi-window-address/0x%08x%08x}", + reg, + read_config(fd, &p->pc_sel, + ptr + PCIR_HTMSI_ADDRESS_LO, 4)); + else + xo_emit("{:msi-window-address/0x%08x}", + read_config(fd, &p->pc_sel, + ptr + PCIR_HTMSI_ADDRESS_LO, 4)); } break; - case PCIM_HTCAP_DIRECT_ROUTE: - printf("direct route"); + case PCIM_HTCAP_DIRECT_ROUTE: // XXX not yet ready + //printf("direct route"); + xo_emit("{q:hyper-transport-mode/direct route}"); break; case PCIM_HTCAP_VCSET: - printf("VC set"); + //printf("VC set"); + xo_emit("{q:hyper-transport-mode/VC set}"); break; case PCIM_HTCAP_RETRY_MODE: - printf("retry mode"); + //printf("retry mode"); + xo_emit("{q:hyper-transport-mode/retry mode}"); break; case PCIM_HTCAP_X86_ENCODING: - printf("X86 encoding"); + //printf("X86 encoding"); + xo_emit("{q:hyper-transport-mode/X86 encoding}"); break; case PCIM_HTCAP_GEN3: - printf("Gen3"); + //printf("Gen3"); + xo_emit("{q:hyper-transport-mode/Gen3}"); break; case PCIM_HTCAP_FLE: - printf("function-level extension"); + //printf("function-level extension"); + xo_emit("{q:hyper-transport-mode/function-level extension}"); break; case PCIM_HTCAP_PM: - printf("power management"); + //printf("power management"); + xo_emit("{q:hyper-transport-mode/power management}"); break; case PCIM_HTCAP_HIGH_NODE_COUNT: - printf("high node count"); + //printf("high node count"); + xo_emit("{q:hyper-transport-mode/high node count}"); break; default: - printf("unknown %02x", command); + //printf("unknown %02x", command); + xo_emit("{q:hyper-transport-mode/unknown %02x{:/}", + command); break; } } @@ -300,14 +372,19 @@ uint8_t length; length = read_config(fd, &p->pc_sel, ptr + PCIR_VENDOR_LENGTH, 1); - printf("vendor (length %d)", length); + //printf("vendor (length %d)", length); + xo_emit("{eq:capability-name/Vendor Specific Information}"); + xo_emit("vendor (length {:vendor-specific-data-length/%d})", length); if (p->pc_vendor == 0x8086) { /* Intel */ uint8_t version; version = read_config(fd, &p->pc_sel, ptr + PCIR_VENDOR_DATA, 1); - printf(" Intel cap %d version %d", version >> 4, version & 0xf); + //printf(" Intel cap %d version %d", version >> 4, version & 0xf); + xo_emit(" {:vendor-name/Intel} cap {:intel-specific-capabilities/%d} " + "version {:version/%d}", + version >> 4, version & 0xf); if (version >> 4 == 1 && length == 12) { /* Feature Detection */ uint32_t fvec; @@ -316,38 +393,53 @@ comma = 0; fvec = read_config(fd, &p->pc_sel, ptr + PCIR_VENDOR_DATA + 5, 4); - printf("\n\t\t features:"); + //printf("\n\t\t features:"); + xo_emit("\n\t\t features:"); if (fvec & (1 << 0)) { - printf(" AMT"); + //printf(" AMT"); + xo_emit(" AMT{eq:feature-amt/true}"); comma = 1; } fvec = read_config(fd, &p->pc_sel, ptr + PCIR_VENDOR_DATA + 1, 4); if (fvec & (1 << 21)) { - printf("%s Quick Resume", comma ? "," : ""); + //printf("%s Quick Resume", comma ? "," : ""); + xo_emit("{d:/%s} Quick Resume{eq:feature-quick-resume/true}", + comma ? "," : ""); comma = 1; } if (fvec & (1 << 18)) { - printf("%s SATA RAID-5", comma ? "," : ""); + //printf("%s SATA RAID-5", comma ? "," : ""); + xo_emit("{d:/%s} SATA RAID-5{eq:feature-raid-5/true}", + comma ? "," : ""); comma = 1; } if (fvec & (1 << 9)) { - printf("%s Mobile", comma ? "," : ""); + //printf("%s Mobile", comma ? "," : ""); + xo_emit("{d:/%s} Mobile{eq:feature-mobile/true}", comma ? "," : ""); comma = 1; } if (fvec & (1 << 7)) { - printf("%s 6 PCI-e x1 slots", comma ? "," : ""); + //printf("%s 6 PCI-e x1 slots", comma ? "," : ""); + xo_emit("{d:/%s} 6 PCI-e x1 slots{e:pci-express-slots/6}", + comma ? "," : ""); comma = 1; } else { - printf("%s 4 PCI-e x1 slots", comma ? "," : ""); + //printf("%s 4 PCI-e x1 slots", comma ? "," : ""); + xo_emit("{d:/%s} 4 PCI-e x1 slots{e:pci-express-slots/4}", + comma ? "," : ""); comma = 1; } if (fvec & (1 << 5)) { - printf("%s SATA RAID-0/1/10", comma ? "," : ""); + //printf("%s SATA RAID-0/1/10", comma ? "," : ""); + xo_emit("{d:/%s} SATA RAID-0/1/10{eq:feature-raid-0-1-10/true}", + comma ? "," : ""); comma = 1; } if (fvec & (1 << 3)) { - printf("%s SATA AHCI", comma ? "," : ""); + //printf("%s SATA AHCI", comma ? "," : ""); + xo_emit("{d:/%s} SATA AHCI{eq:feature-sata-ahci/true}", + comma ? "," : ""); comma = 1; } } @@ -359,8 +451,11 @@ { uint16_t debug_port; + xo_emit("{e:capability-name/Debug}"); debug_port = read_config(fd, &p->pc_sel, ptr + PCIR_DEBUG_PORT, 2); - printf("EHCI Debug Port at offset 0x%x in map 0x%x", debug_port & + //printf("EHCI Debug Port at offset 0x%x in map 0x%x", debug_port & + xo_emit("EHCI Debug Port at offset {:ehci-debug-port-offset/0x%x}" + " in map {:ehci-debug-port-map/0x%x}", debug_port & PCIM_DEBUG_PORT_OFFSET, PCIR_BAR(debug_port >> 13)); } @@ -369,8 +464,13 @@ { uint32_t id; + xo_emit("{eq:capability-name/Subvendor}"); id = read_config(fd, &p->pc_sel, ptr + PCIR_SUBVENDCAP_ID, 4); - printf("PCI Bridge card=0x%08x", id); + //printf("PCI Bridge card=0x%08x", id); + xo_emit("PCI Bridge card={:pci-bridge-subdevice-id/0x%04x}", + (id >> 16) & 0xffff); + xo_emit("{:pci-bridge-subvendor-id/%04x/0x%04x}", + id & 0xffff); } #define MAX_PAYLOAD(field) (128 << (field)) @@ -414,70 +514,97 @@ uint16_t ctl, flags, sta; flags = read_config(fd, &p->pc_sel, ptr + PCIER_FLAGS, 2); - printf("PCI-Express %d ", flags & PCIEM_FLAGS_VERSION); + //printf("PCI-Express %d ", flags & PCIEM_FLAGS_VERSION); + xo_emit("{:capability-name/PCI-Express} "); + xo_emit("{:pci-express-version/%d} ", flags & PCIEM_FLAGS_VERSION); switch (flags & PCIEM_FLAGS_TYPE) { case PCIEM_TYPE_ENDPOINT: - printf("endpoint"); + //printf("endpoint"); + xo_emit("{:device-type/endpoint}"); break; case PCIEM_TYPE_LEGACY_ENDPOINT: - printf("legacy endpoint"); + //printf("legacy endpoint"); + xo_emit("{:device-type/legacy endpoint}"); break; case PCIEM_TYPE_ROOT_PORT: - printf("root port"); + //printf("root port"); + xo_emit("{:device-type/root port}"); break; case PCIEM_TYPE_UPSTREAM_PORT: - printf("upstream port"); + //printf("upstream port"); + xo_emit("{:device-type/upstream port}"); break; case PCIEM_TYPE_DOWNSTREAM_PORT: - printf("downstream port"); + //printf("downstream port"); + xo_emit("{:device-type/downstream port}"); break; case PCIEM_TYPE_PCI_BRIDGE: - printf("PCI bridge"); + //printf("PCI bridge"); + xo_emit("{:device-type/PCI bridge}"); break; case PCIEM_TYPE_PCIE_BRIDGE: - printf("PCI to PCIe bridge"); + //printf("PCI to PCIe bridge"); + xo_emit("{:device-type/PCI to PCIe bridge}"); break; case PCIEM_TYPE_ROOT_INT_EP: - printf("root endpoint"); + //printf("root endpoint"); + xo_emit("{:device-type/root endpoint}"); break; case PCIEM_TYPE_ROOT_EC: - printf("event collector"); + //printf("event collector"); + xo_emit("{:device-type/event collector}"); break; default: - printf("type %d", (flags & PCIEM_FLAGS_TYPE) >> 4); + //printf("type %d", (flags & PCIEM_FLAGS_TYPE) >> 4); + xo_emit("type {:device-type/%d}", (flags & PCIEM_FLAGS_TYPE) >> 4); break; } if (flags & PCIEM_FLAGS_SLOT) - printf(" slot"); + //printf(" slot"); + xo_emit(" slot{eq:slot-implemented/true}"); if (flags & PCIEM_FLAGS_IRQ) - printf(" IRQ %d", (flags & PCIEM_FLAGS_IRQ) >> 9); + //printf(" IRQ %d", (flags & PCIEM_FLAGS_IRQ) >> 9); + xo_emit(" IRQ {:interrupt-message-number/%d}", + (flags & PCIEM_FLAGS_IRQ) >> 9); cap = read_config(fd, &p->pc_sel, ptr + PCIER_DEVICE_CAP, 4); cap2 = read_config(fd, &p->pc_sel, ptr + PCIER_DEVICE_CAP2, 4); ctl = read_config(fd, &p->pc_sel, ptr + PCIER_DEVICE_CTL, 2); - printf(" max data %d(%d)", + //printf(" max data %d(%d)", + xo_emit(" max data {:controller-maximum-payload/%d}" + "({:capability-maximum-payload/%d})", MAX_PAYLOAD((ctl & PCIEM_CTL_MAX_PAYLOAD) >> 5), MAX_PAYLOAD(cap & PCIEM_CAP_MAX_PAYLOAD)); if ((cap & PCIEM_CAP_FLR) != 0) - printf(" FLR"); + //printf(" FLR"); + xo_emit(" FLR{eq:pci-express-capability-flr/true}"); cap = read_config(fd, &p->pc_sel, ptr + PCIER_LINK_CAP, 4); sta = read_config(fd, &p->pc_sel, ptr + PCIER_LINK_STA, 2); - printf(" link x%d(x%d)", (sta & PCIEM_LINK_STA_WIDTH) >> 4, + //printf(" link x%d(x%d)", (sta & PCIEM_LINK_STA_WIDTH) >> 4, + xo_emit(" link x{:link-width/%d}(x{:link-max-width/%d})", + (sta & PCIEM_LINK_STA_WIDTH) >> 4, (cap & PCIEM_LINK_CAP_MAX_WIDTH) >> 4); if ((cap & (PCIEM_LINK_CAP_MAX_WIDTH | PCIEM_LINK_CAP_ASPM)) != 0) - printf("\n "); + //printf("\n "); + xo_emit("\n "); if ((cap & PCIEM_LINK_CAP_MAX_WIDTH) != 0) { - printf(" speed %s(%s)", (sta & PCIEM_LINK_STA_WIDTH) == 0 ? + //printf(" speed %s(%s)", (sta & PCIEM_LINK_STA_WIDTH) == 0 ? + xo_emit(" speed {n:link-speed/%s}({n:link-max-speed/%s})", + (sta & PCIEM_LINK_STA_WIDTH) == 0 ? "0.0" : link_speed_string(sta & PCIEM_LINK_STA_SPEED), link_speed_string(cap & PCIEM_LINK_CAP_MAX_SPEED)); } if ((cap & PCIEM_LINK_CAP_ASPM) != 0) { ctl = read_config(fd, &p->pc_sel, ptr + PCIER_LINK_CTL, 2); - printf(" ASPM %s(%s)", aspm_string(ctl & PCIEM_LINK_CTL_ASPMC), + //printf(" ASPM %s(%s)", aspm_string(ctl & PCIEM_LINK_CTL_ASPMC), + xo_emit(" ASPM {:controller-active-state-power-management/%s}" + "({:capability-active-state-power-management/%s})", + aspm_string(ctl & PCIEM_LINK_CTL_ASPMC), aspm_string((cap & PCIEM_LINK_CAP_ASPM) >> 10)); } if ((cap2 & PCIEM_CAP2_ARI) != 0) { ctl = read_config(fd, &p->pc_sel, ptr + PCIER_DEVICE_CTL2, 4); - printf(" ARI %s", + //printf(" ARI %s", + xo_emit(" ARI {:pci-express-alternate-requester-id/%s}}", (ctl & PCIEM_CTL2_ARI) ? "enabled" : "disabled"); } } @@ -500,12 +627,21 @@ pba_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK); pba_offset = val & ~PCIM_MSIX_BIR_MASK; - printf("MSI-X supports %d message%s%s\n", msgnum, - (msgnum == 1) ? "" : "s", + //printf("MSI-X supports %d message%s%s\n", msgnum, + xo_emit("{:capability-name/MSI-X} "); + xo_emit("supports {:tyble-size/%d} message{d:/%s%s}\n", + msgnum, (msgnum == 1) ? "" : "s", (ctrl & PCIM_MSIXCTRL_MSIX_ENABLE) ? ", enabled" : ""); + xo_emit("{e:msix-enable/%s}", + (ctrl & PCIM_MSIXCTRL_MSIX_ENABLE) ? "true" : "false"); - printf(" "); - printf("Table in map 0x%x[0x%x], PBA in map 0x%x[0x%x]", + //printf(" "); + xo_emit(" "); + //printf("Table in map 0x%x[0x%x], PBA in map 0x%x[0x%x]", + xo_emit("Table in map {:base-index-register/0x%x}" + "[{:table-offset/0x%x}], " + "PBA in map {:pba-index-register/0x%x}" + "[{:pba-offset/0x%x}]", table_bar, table_offset, pba_bar, pba_offset); } @@ -513,7 +649,9 @@ cap_sata(int fd, struct pci_conf *p, uint8_t ptr) { - printf("SATA Index-Data Pair"); + //printf("SATA Index-Data Pair"); + xo_emit("{:capability-name/SATA} "); + xo_emit("Index-Data Pair{eq:sata-index-data-pair/true}"); } static void @@ -522,9 +660,15 @@ uint8_t cap; cap = read_config(fd, &p->pc_sel, ptr + PCIR_PCIAF_CAP, 1); - printf("PCI Advanced Features:%s%s", + //printf("PCI Advanced Features:%s%s", + xo_emit("{:capability-name/PCI Advanced Features}:"); + xo_emit("{d:/%s%s}", cap & PCIM_PCIAFCAP_FLR ? " FLR" : "", cap & PCIM_PCIAFCAP_TP ? " TP" : ""); + xo_emit("{e:pci-avanced-feature-flr/%s}" + "{e:pci-advance-feature-tp/%s}", + cap & PCIM_PCIAFCAP_FLR ? "true" : "false", + cap & PCIM_PCIAFCAP_TP ? "true" : "false"); } void @@ -554,9 +698,14 @@ /* Walk the capability list. */ express = 0; ptr = read_config(fd, &p->pc_sel, ptr, 1); + xo_open_list("capability"); while (ptr != 0 && ptr != 0xff) { cap = read_config(fd, &p->pc_sel, ptr + PCICAP_ID, 1); - printf(" cap %02x[%02x] = ", cap, ptr); + //printf(" cap %02x[%02x] = ", cap, ptr); + xo_open_instance("capability"); + xo_emit(" cap {:capability-number/%02x/0x%x}" + "[{:capability-pointer/%02x/0x%x}] = ", + cap, ptr); switch (cap) { case PCIY_PMG: cap_power(fd, p, ptr); @@ -599,12 +748,15 @@ cap_pciaf(fd, p, ptr); break; default: - printf("unknown"); + //printf("unknown"); + xo_emit("{:capability-name/unknown}"); break; } - printf("\n"); + xo_emit("\n"); + xo_close_instance("capability"); ptr = read_config(fd, &p->pc_sel, ptr + PCICAP_NEXTPTR, 1); } + xo_close_list("capability"); if (express) list_ecaps(fd, p); @@ -628,15 +780,20 @@ { uint32_t sta, mask; - printf("AER %d", ver); + //printf("AER %d", ver); + xo_emit("AER {eq:capability-name/Advanced Error Reporting}"); + xo_emit("{:advanced-error-reporting-version/%d}", ver); if (ver < 1) return; sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_STATUS, 4); mask = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_SEVERITY, 4); - printf(" %d fatal", bitcount32(sta & mask)); - printf(" %d non-fatal", bitcount32(sta & ~mask)); + //printf(" %d fatal", bitcount32(sta & mask)); + xo_emit(" {:fatal-errors/%d} fatal", bitcount32(sta & mask)); + //printf(" %d non-fatal", bitcount32(sta & ~mask)); + xo_emit(" {:non-fatal-errors/%d} non-fatal", bitcount32(sta & ~mask)); sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_COR_STATUS, 4); - printf(" %d corrected", bitcount32(sta)); + //printf(" %d corrected", bitcount32(sta)); + xo_emit(" {:corrected-errors/%d} corrected", bitcount32(sta)); } static void @@ -644,13 +801,17 @@ { uint32_t cap1; - printf("VC %d", ver); + //printf("VC %d", ver); + xo_emit("VC {eq:capability-name/Virtual Channels}"); + xo_emit("{:virtual-channel-version/%d}", ver); if (ver < 1) return; cap1 = read_config(fd, &p->pc_sel, ptr + PCIR_VC_CAP1, 4); - printf(" max VC%d", cap1 & PCIM_VC_CAP1_EXT_COUNT); + //printf(" max VC%d", cap1 & PCIM_VC_CAP1_EXT_COUNT); + xo_emit(" max VC{:highest-virtual-channel-number/%d}", cap1 & PCIM_VC_CAP1_EXT_COUNT); if ((cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) != 0) - printf(" lowpri VC0-VC%d", + //printf(" lowpri VC0-VC%d", + xo_emit(" lowpri VC0-VC{:highest-low-priority-virtual-channel-number/%d}", (cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) >> 4); } @@ -659,12 +820,15 @@ { uint32_t high, low; - printf("Serial %d", ver); + //printf("Serial %d", ver); + xo_emit("Serial {eq:capability-name/Serial Number}"); + xo_emit("{:serial-number-version/%d}", ver); if (ver < 1) return; low = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_LOW, 4); high = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_HIGH, 4); - printf(" %08x%08x", high, low); + //printf(" %08x%08x", high, low); + xo_emit(" {:serial-number/%08x%08x/0x%x%08x}", high, low); } static void @@ -672,11 +836,14 @@ { uint32_t val; - printf("Vendor %d", ver); + //printf("Vendor %d", ver); + xo_emit("{:capability-name/Vendor} "); + xo_emit("{:vendor-version/%d}", ver); if (ver < 1) return; val = read_config(fd, &p->pc_sel, ptr + 4, 4); - printf(" ID %d", val & 0xffff); + //printf(" ID %d", val & 0xffff); + xo_emit(" ID {:vendor-id/%d}", val & 0xffff); } static void @@ -684,11 +851,14 @@ { uint32_t val; - printf("PCIe Sec %d", ver); + //printf("PCIe Sec %d", ver); + xo_emit("{eq:capability-name/Secondary Uncorrectable Errors}"); + xo_emit("PCIe Sec {:version/%d}", ver); if (ver < 1) return; val = read_config(fd, &p->pc_sel, ptr + 8, 4); - printf(" lane errors %#x", val); + //printf(" lane errors %#x", val); + xo_emit(" lane errors {:lane-errors/%#x}", val); } struct { @@ -725,8 +895,13 @@ ecap = read_config(fd, &p->pc_sel, ptr, 4); if (ecap == 0xffffffff || ecap == 0) return; + xo_open_list("extended-capability"); for (;;) { - printf(" ecap %04x[%03x] = ", PCI_EXTCAP_ID(ecap), ptr); + xo_open_instance("extended-capability"); + //printf(" ecap %04x[%03x] = ", PCI_EXTCAP_ID(ecap), ptr); + xo_emit(" ecap {:extended-capability-number/%04x/0x%x}" + "[{:capability-pointer/%03x/0x%x}] = ", + PCI_EXTCAP_ID(ecap), ptr); switch (PCI_EXTCAP_ID(ecap)) { case PCIZ_AER: ecap_aer(fd, p, ptr, PCI_EXTCAP_VER(ecap)); @@ -750,15 +925,21 @@ name = ecap_names[i].name; break; } - printf("%s %d", name, PCI_EXTCAP_VER(ecap)); + //printf("%s %d", name, PCI_EXTCAP_VER(ecap)); + xo_emit("{:extended-capability-type/%s} " + "{:extended-capability-version/%d}", + name, PCI_EXTCAP_VER(ecap)); break; } - printf("\n"); + //printf("\n"); + xo_emit("\n"); + xo_close_instance("extended-capability"); ptr = PCI_EXTCAP_NEXTPTR(ecap); if (ptr == 0) break; ecap = read_config(fd, &p->pc_sel, ptr, 4); } + xo_close_list("extended-capability"); } /* Find offset of a specific capability. Returns 0 on failure. */ Index: err.c =================================================================== --- err.c +++ err.c @@ -35,6 +35,7 @@ #include #include +#include #include @@ -111,6 +112,17 @@ { 0, NULL }, }; +static int errors; + +static void +print_header(const char *header) +{ + if (errors++ == 0) + xo_open_list("error-category"); + xo_open_instance("error-category"); + xo_emit("{:category/%14s} = ", header); +} + static void print_bits(const char *header, struct bit_table *table, uint32_t mask) { @@ -120,20 +132,28 @@ for (; table->desc != NULL; table++) if (mask & table->mask) { if (first) { - printf("%14s = ", header); + print_header(header); + xo_open_list("detected-error"); first = 0; } else - printf(" "); - printf("%s\n", table->desc); + xo_emit(" "); + xo_open_instance("detected-error"); + xo_emit("{:description/%s}\n", table->desc); + xo_close_instance("detected-error"); mask &= ~table->mask; } + if (!first) + xo_close_list("detected-error"); if (mask != 0) { - if (first) - printf("%14s = ", header); - else - printf(" "); - printf("Unknown: 0x%08x\n", mask); + if (first) { + print_header(header); + first = 0; + } else + xo_emit(" "); + xo_emit("Unknown: {:unknown-errors-bitmask/0x%08x}\n", mask); } + if (!first) + xo_close_instance("error-category"); } void @@ -143,6 +163,8 @@ uint16_t sta, aer; uint8_t pcie; + errors = 0; + /* First check for standard PCI errors. */ sta = read_config(fd, &p->pc_sel, PCIR_STATUS, 2); print_bits("PCI errors", pci_status, sta & PCI_ERRORS); @@ -150,7 +172,7 @@ /* See if this is a PCI-express device. */ pcie = pci_find_cap(fd, p, PCIY_EXPRESS); if (pcie == 0) - return; + goto done; /* Check for PCI-e errors. */ sta = read_config(fd, &p->pc_sel, pcie + PCIER_DEVICE_STA, 2); @@ -159,7 +181,7 @@ /* See if this device supports AER. */ aer = pcie_find_cap(fd, p, PCIZ_AER); if (aer == 0) - return; + goto done; /* Check for uncorrected errors. */ mask = read_config(fd, &p->pc_sel, aer + PCIR_AER_UC_STATUS, 4); @@ -170,4 +192,7 @@ /* Check for corrected errors. */ mask = read_config(fd, &p->pc_sel, aer + PCIR_AER_COR_STATUS, 4); print_bits("Corrected", aer_cor, mask); + done: + if (errors != 0) + xo_close_list("error-category"); } Index: pciconf.c =================================================================== --- pciconf.c +++ pciconf.c @@ -45,6 +45,7 @@ #include #include #include +#include #include @@ -86,7 +87,8 @@ static void usage(void) { - fprintf(stderr, "%s\n%s\n%s\n%s\n", + + xo_error("%s\n%s\n%s\n%s\n", "usage: pciconf -l [-bcevV] [device]", " pciconf -a device", " pciconf -r [-b | -h] device addr[:addr2]", @@ -105,6 +107,10 @@ listmode = readmode = writemode = attachedmode = 0; bars = caps = errors = verbose = vpd = byte = isshort = 0; + argc = xo_parse_args(argc, argv); + if (argc < 0) + usage(); + while ((c = getopt(argc, argv, "abcehlrwvV")) != -1) { switch(c) { case 'a': @@ -173,7 +179,7 @@ } else { usage(); } - + xo_finish(); return exitstatus; } @@ -192,7 +198,7 @@ fd = open(_PATH_DEVPCI, (caps || errors) ? O_RDWR : O_RDONLY, 0); if (fd < 0) - err(1, "%s", _PATH_DEVPCI); + xo_err(1, "%s", _PATH_DEVPCI); bzero(&pc, sizeof(struct pci_conf_io)); pc.match_buf_len = sizeof(conf); @@ -210,7 +216,7 @@ do { if (ioctl(fd, PCIOCGETCONF, &pc) == -1) - err(1, "ioctl(PCIOCGETCONF)"); + xo_err(1, "ioctl(PCIOCGETCONF)"); /* * 255 entries should be more than enough for most people, @@ -221,28 +227,42 @@ * not be desirable. */ if (pc.status == PCI_GETCONF_LIST_CHANGED) { - warnx("PCI device list changed, please try again"); + xo_warnx("PCI device list changed, please try again"); exitstatus = 1; close(fd); return; } else if (pc.status == PCI_GETCONF_ERROR) { - warnx("error returned from PCIOCGETCONF ioctl"); + xo_warnx("error returned from PCIOCGETCONF ioctl"); exitstatus = 1; close(fd); return; } + xo_open_list("pci-device"); for (p = conf; p < &conf[pc.num_matches]; p++) { - printf("%s%d@pci%d:%d:%d:%d:\tclass=0x%06x card=0x%08x " - "chip=0x%08x rev=0x%02x hdr=0x%02x\n", + xo_open_instance("pci-device"); + xo_emit("{kq:device/%s%d}", (p->pd_name && *p->pd_name) ? p->pd_name : "none", (p->pd_name && *p->pd_name) ? (int)p->pd_unit : - none_count++, p->pc_sel.pc_domain, - p->pc_sel.pc_bus, p->pc_sel.pc_dev, - p->pc_sel.pc_func, (p->pc_class << 16) | - (p->pc_subclass << 8) | p->pc_progif, - (p->pc_subdevice << 16) | p->pc_subvendor, - (p->pc_device << 16) | p->pc_vendor, + none_count++); + xo_emit("@pci{:domain-number/%d}:" + "{:bus-number/%d}:" + "{:device-number/%d}:" + "{:function-number/%d}:\t", + p->pc_sel.pc_domain, p->pc_sel.pc_bus, + p->pc_sel.pc_dev, p->pc_sel.pc_func); + xo_emit("class={:base-class/0x%02x}" + "{:sub-class/%02x/0x%02x}" + "{:programming-interface/%02x/0x%02x} ", + p->pc_class, p->pc_subclass, p->pc_progif); + xo_emit("card={:card-device-id/0x%04x}" + "{:card-vendor-id/%04x/0x%04x} ", + p->pc_subdevice, p->pc_subvendor); + xo_emit("chip={:chip-device-id/0x%04x}" + "{:chip-vendor-id/%4x/0x%04x} ", + p->pc_device, p->pc_vendor); + xo_emit("rev={:chip-revision/0x%02x} " + "hdr={:header-type/0x%02x}\n", p->pc_revid, p->pc_hdr); if (verbose) list_verbose(p); @@ -254,7 +274,9 @@ list_errors(fd, p); if (vpd) list_vpd(fd, p); + xo_close_instance("pci-device"); } + xo_close_list("pci-device"); } while (pc.status == PCI_GETCONF_MORE_DEVS); close(fd); @@ -282,6 +304,7 @@ return; } + xo_open_list("base-address"); for (i = 0; i <= max; i++) { bar.pbi_sel = p->pc_sel; bar.pbi_reg = PCIR_BAR(i); @@ -311,11 +334,14 @@ } base = bar.pbi_base & ~((uint64_t)0xf); } - printf(" bar [%02x] = type %s, range %2d, base %#jx, ", + xo_open_instance("base-address"); + xo_emit(" bar [{:register-offset/%#02x}] = type {:type/%s}, range {:address-bits/%2d}, base {:base-address/%#jx}, ", PCIR_BAR(i), type, range, (uintmax_t)base); - printf("size %ju, %s\n", (uintmax_t)bar.pbi_length, + xo_emit("size {:size/%ju}, {:state/%s}\n", (uintmax_t)bar.pbi_length, bar.pbi_enabled ? "enabled" : "disabled"); + xo_close_instance("base-address"); } + xo_close_list("base-address"); } static void @@ -327,7 +353,7 @@ TAILQ_FOREACH(vi, &pci_vendors, link) { if (vi->id == p->pc_vendor) { - printf(" vendor = '%s'\n", vi->desc); + xo_emit(" vendor = '{:vendor-name/%s}'\n", vi->desc); break; } } @@ -336,15 +362,15 @@ } else { TAILQ_FOREACH(di, &vi->devs, link) { if (di->id == p->pc_device) { - printf(" device = '%s'\n", di->desc); + xo_emit(" device = '{:device-name/%s}'\n", di->desc); break; } } } if ((dp = guess_class(p)) != NULL) - printf(" class = %s\n", dp); + xo_emit(" class = {:class-name/%s}\n", dp); if ((dp = guess_subclass(p)) != NULL) - printf(" subclass = %s\n", dp); + xo_emit(" subclass = {:subclass-name/%s}\n", dp); } static void @@ -352,6 +378,9 @@ { struct pci_list_vpd_io list; struct pci_vpd_element *vpd, *end; + int cap_printed; // XXX: This function assumes that "capabilities" + int item_printed; // and "items" are grouped together in the VPD + int vpd_printed; // and that all "items" come at the end of VPD list.plvi_sel = p->pc_sel; list.plvi_len = 0; @@ -367,13 +396,11 @@ vpd = list.plvi_data; end = (struct pci_vpd_element *)((char *)vpd + list.plvi_len); - for (; vpd < end; vpd = PVE_NEXT(vpd)) { - if (vpd->pve_flags == PVE_FLAG_IDENT) { - printf(" VPD ident = '%.*s'\n", - (int)vpd->pve_datalen, vpd->pve_data); - continue; - } + cap_printed = 0; + item_printed = 0; + vpd_printed = 0; + for (; vpd < end; vpd = PVE_NEXT(vpd)) { /* Ignore the checksum keyword. */ if (!(vpd->pve_flags & PVE_FLAG_RW) && memcmp(vpd->pve_keyword, "RV", 2) == 0) @@ -384,23 +411,55 @@ memcmp(vpd->pve_keyword, "RW", 2) == 0) continue; + if (!vpd_printed) { + xo_open_container("vital-product-data"); + vpd_printed = 1; + } + + if (vpd->pve_flags == PVE_FLAG_IDENT) { + xo_emit(" VPD ident = '{:ident/%*s}'\n", + vpd->pve_datalen, (void*)&vpd->pve_data); + continue; + } + /* Handle extended capability keyword. */ if (!(vpd->pve_flags & PVE_FLAG_RW) && memcmp(vpd->pve_keyword, "CP", 2) == 0) { - printf(" VPD ro CP = ID %02x in map 0x%x[0x%x]\n", + if (!cap_printed) { + xo_open_list("capability"); + cap_printed = 1; + } + xo_open_instance("capability"); + xo_emit(" VPD {:mode/ro} {:keyword/CP} = ID {:ident-number/%02x} in map {:base-address/%#x}[{:data/%#x}]\n", (unsigned int)vpd->pve_data[0], PCIR_BAR((unsigned int)vpd->pve_data[1]), - (unsigned int)vpd->pve_data[3] << 8 | - (unsigned int)vpd->pve_data[2]); + (unsigned int)vpd->pve_data[3] << 8 | (unsigned int)vpd->pve_data[2]); + xo_close_instance("capability"); continue; } + if (cap_printed) { + xo_close_list("capability"); + } /* Remaining keywords should all have ASCII values. */ - printf(" VPD %s %c%c = '%.*s'\n", + if (!item_printed) { + xo_open_list("item"); + item_printed = 1; + } + xo_open_instance("item"); + xo_emit(" VPD {:read-write-mode/%s} {:keyword/%c%c} = '{:value/%*s}'\n", vpd->pve_flags & PVE_FLAG_RW ? "rw" : "ro", - vpd->pve_keyword[0], vpd->pve_keyword[1], - (int)vpd->pve_datalen, vpd->pve_data); + vpd->pve_keyword[0], vpd->pve_keyword[1], + vpd->pve_datalen, (void*)&vpd->pve_data); + xo_close_instance("item"); } + if (item_printed) { + xo_close_list("item"); + } + if (vpd_printed) { + xo_close_container("vital-product-data"); + } + xo_finish(); free(list.plvi_data); } @@ -573,13 +632,13 @@ if ((id == 0) || (strlen(str) < 1)) continue; if ((cv = malloc(sizeof(struct pci_vendor_info))) == NULL) { - warn("allocating vendor entry"); + xo_warn("allocating vendor entry"); error = 1; break; } if ((cv->desc = strdup(str)) == NULL) { free(cv); - warn("allocating vendor description"); + xo_warn("allocating vendor description"); error = 1; break; } @@ -594,17 +653,17 @@ if ((id == 0) || (strlen(str) < 1)) continue; if (cv == NULL) { - warnx("device entry with no vendor!"); + xo_warnx("device entry with no vendor!"); continue; } if ((cd = malloc(sizeof(struct pci_device_info))) == NULL) { - warn("allocating device entry"); + xo_warn("allocating device entry"); error = 1; break; } if ((cd->desc = strdup(str)) == NULL) { free(cd); - warn("allocating device description"); + xo_warn("allocating device description"); error = 1; break; } @@ -632,7 +691,7 @@ pi.pi_width = width; if (ioctl(fd, PCIOCREAD, &pi) < 0) - err(1, "ioctl(PCIOCREAD)"); + xo_err(1, "ioctl(PCIOCREAD)"); return (pi.pi_data); } @@ -648,7 +707,7 @@ fd = open(_PATH_DEVPCI, O_RDONLY, 0); if (fd < 0) - err(1, "%s", _PATH_DEVPCI); + xo_err(1, "%s", _PATH_DEVPCI); bzero(&pc, sizeof(struct pci_conf_io)); pc.match_buf_len = sizeof(conf); @@ -662,16 +721,16 @@ * find the start of the unit. */ if (name[0] == '\0') - errx(1, "Empty device name"); + xo_errx(1, "Empty device name"); cp = strchr(name, '\0'); assert(cp != NULL && cp != name); cp--; while (cp != name && isdigit(cp[-1])) cp--; if (cp == name || !isdigit(*cp)) - errx(1, "Invalid device name"); + xo_errx(1, "Invalid device name"); if ((size_t)(cp - name) + 1 > sizeof(patterns[0].pd_name)) - errx(1, "Device name is too long"); + xo_errx(1, "Device name is too long"); memcpy(patterns[0].pd_name, name, cp - name); patterns[0].pd_unit = strtol(cp, &cp, 10); assert(*cp == '\0'); @@ -681,13 +740,13 @@ pc.patterns = patterns; if (ioctl(fd, PCIOCGETCONF, &pc) == -1) - err(1, "ioctl(PCIOCGETCONF)"); + xo_err(1, "ioctl(PCIOCGETCONF)"); if (pc.status != PCI_GETCONF_LAST_DEVICE && pc.status != PCI_GETCONF_MORE_DEVS) - errx(1, "error returned from PCIOCGETCONF ioctl"); + xo_errx(1, "error returned from PCIOCGETCONF ioctl"); close(fd); if (pc.num_matches == 0) - errx(1, "Device not found"); + xo_errx(1, "Device not found"); return (conf[0].pc_sel); } @@ -726,7 +785,7 @@ sel.pc_domain = 0; } if (*ep != '\x0' || ep == epbase) - errx(1, "cannot parse selector %s", str); + xo_errx(1, "cannot parse selector %s", str); return sel; } @@ -747,8 +806,10 @@ static void readone(int fd, struct pcisel *sel, long reg, int width) { - - printf("%0*x", width*2, read_config(fd, sel, reg, width)); + xo_open_instance("config-register"); + xo_emit("{ke:offset/0x%02x}{:data/0x%0*x}{e:width/%d}", + reg, width*2, read_config(fd, sel, reg, width), width); + xo_close_instance("config-register"); } static void @@ -764,7 +825,7 @@ fd = open(_PATH_DEVPCI, O_RDWR, 0); if (fd < 0) - err(1, "%s", _PATH_DEVPCI); + xo_err(1, "%s", _PATH_DEVPCI); rend = rstart = strtol(reg, &end, 0); if (end && *end == ':') { @@ -772,14 +833,20 @@ rend = strtol(end, (char **) 0, 0); } sel = getsel(name); + xo_open_list("config-register"); for (i = 1, r = rstart; r <= rend; i++, r += width) { readone(fd, &sel, r, width); if (i && !(i % 8)) - putchar(' '); - putchar(i % (16/width) ? ' ' : '\n'); + xo_emit(" "); + if (i % (16/width)) { + xo_emit(" "); + } else { + xo_emit("\n"); + } } if (i % (16/width) != 1) - putchar('\n'); + xo_emit("\n"); + xo_close_list("config-register"); close(fd); } @@ -796,10 +863,10 @@ fd = open(_PATH_DEVPCI, O_RDWR, 0); if (fd < 0) - err(1, "%s", _PATH_DEVPCI); + xo_err(1, "%s", _PATH_DEVPCI); if (ioctl(fd, PCIOCWRITE, &pi) < 0) - err(1, "ioctl(PCIOCWRITE)"); + xo_err(1, "ioctl(PCIOCWRITE)"); } static void @@ -812,11 +879,13 @@ fd = open(_PATH_DEVPCI, O_RDWR, 0); if (fd < 0) - err(1, "%s", _PATH_DEVPCI); + xo_err(1, "%s", _PATH_DEVPCI); if (ioctl(fd, PCIOCATTACHED, &pi) < 0) - err(1, "ioctl(PCIOCATTACHED)"); + xo_err(1, "ioctl(PCIOCATTACHED)"); + xo_open_container("device-status"); + xo_emit("{:name/%s}: {:status/%s%s}\n", name, pi.pi_data == 0 ? "not " : "", "attached"); + xo_close_container("device-status"); exitstatus = pi.pi_data ? 0 : 2; /* exit(2), if NOT attached */ - printf("%s: %s%s\n", name, pi.pi_data == 0 ? "not " : "", "attached"); }