Page MenuHomeFreeBSD
Files F110619953

D1206.id2680.vs2617.diff
No OneTemporary
Actions

D1206.id2680.vs2617.diff
View Options

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 <stdio.h>
#include <sys/agpio.h>
#include <sys/pciio.h>
+#include <libxo/xo.h>
#include <dev/agp/agpreg.h>
#include <dev/pci/pcireg.h>
@@ -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("{e:capability-name/VPD}");
+ xo_emit("VPD{eq: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("%s {:supported-bus-speed-133mhz/133MHz/true}",
+ comma ? "," : "");
comma = 1;
}
if (status & PCIXM_STATUS_266CAP) {
- printf("%s 266MHz", comma ? "," : "");
+ //printf("%s 266MHz", comma ? "," : "");
+ xo_emit("%s {:supported-bus-speed-266mhz/266MHz/true}",
+ comma ? "," : "");
comma = 1;
}
if (status & PCIXM_STATUS_533CAP) {
- printf("%s 533MHz", comma ? "," : "");
+ //printf("%s 533MHz", comma ? "," : "");
+ xo_emit("%s {:supported-bus-speed-533mhz/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("%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("capabilities");
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("{: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("capabilities");
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-capabilities");
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-capabilities");
}
/* Find offset of a specific capability. Returns 0 on failure. */
Index: err.c
===================================================================
--- err.c
+++ err.c
@@ -35,6 +35,7 @@
#include <err.h>
#include <stdio.h>
+#include <libxo/xo.h>
#include <dev/pci/pcireg.h>
@@ -111,6 +112,17 @@
{ 0, NULL },
};
+static int errors;
+
+static void
+print_header(const char *header)
+{
+ if (errors++ == 0)
+ xo_open_list("error-categories");
+ 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,30 @@
for (; table->desc != NULL; table++)
if (mask & table->mask) {
if (first) {
- printf("%14s = ", header);
+ print_header(header);
+ xo_open_list("detected-errors");
first = 0;
} else
- printf(" ");
- printf("%s\n", table->desc);
+ xo_emit(" ");
+ xo_open_instance("detected");
+ xo_emit("{:error/%s}\n", table->desc);
+ xo_close_instance("detected");
mask &= ~table->mask;
}
+ if (!first)
+ xo_close_list("detected-errors");
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");
+ if (errors != 0)
+ xo_close_list("error-categories");
}
void
@@ -143,6 +165,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);
Index: pciconf.c
===================================================================
--- pciconf.c
+++ pciconf.c
@@ -45,6 +45,7 @@
#include <unistd.h>
#include <sys/pciio.h>
#include <sys/queue.h>
+#include <libxo/xo.h>
#include <dev/pci/pcireg.h>
@@ -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-devices");
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-devices");
} while (pc.status == PCI_GETCONF_MORE_DEVS);
close(fd);
@@ -282,6 +304,7 @@
return;
}
+ xo_open_list("base-addresses");
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-addresses");
}
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("capabilities");
+ 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("capabilities");
+ }
/* Remaining keywords should all have ASCII values. */
- printf(" VPD %s %c%c = '%.*s'\n",
+ if (!item_printed) {
+ xo_open_list("items");
+ 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("items");
+ }
+ 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-space");
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-space");
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");
}

File Metadata

Mime Type
text/plain
Expires
Sat, Feb 22, 12:23 AM (3 h, 4 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
16763333
Default Alt Text
D1206.id2680.vs2617.diff (39 KB)

Event Timeline