#include <u.h>
#include <libc.h>
enum {
Dmistart = 0x000F0000,
Dmiend = 0x000FFFFF,
Dmisz = Dmiend+1 - Dmistart,
};
typedef struct Enum Enum;
typedef struct Item Item;
typedef struct Itemv Itemv;
typedef struct Smbuf Smbuf;
typedef struct Sm Sm;
typedef uvlong uintmem; /* wierd */
struct Enum {
uint v;
char *s;
};
struct Smbuf {
uchar sig[4];
uchar cksum;
uchar len;
uchar vers[2];
uchar maxss[2]; /* maximum structure size */
uchar eprev; /* entry point revision */
uchar fma[5]; /* formatted area */
uchar dmi[5]; /* _DMI_ */
uchar dmicksum;
uchar stlen[2];
uchar stpa[4]; /* structure table pa */
uchar nstrut[2];
uchar bcdrev;
};
struct Sm {
Smbuf raw;
uintmem stpa;
uint stlen;
};
struct Item{
char *name;
int nbytes;
int type;
int offset;
char *fmt;
Enum *tab;
};
struct Itemv{
union {
char *s;
uvlong i;
uchar uuid[16];
};
};
enum {
Biosinfo = 0,
Sysinfo = 1,
Module = 2,
Chassis = 3,
Cpu = 4,
Memctlr = 5, /* obs. */
Memstk = 6, /* obs. */
Cache = 7,
Conn = 8,
Slot = 9,
Oemstr = 11,
Bioslang = 13,
Groupa = 14,
Syslog = 15, /* requires extra poking around */
Pmem = 16,
Mdev = 17,
Merror = 18,
Mmap = 19,
Mmdev = 20,
Pointer = 21,
Battery = 22,
Wdog = 23,
Hwsec = 24,
Syspwr = 25,
Vprobe = 26,
Fan = 27,
Tprobe = 28,
Cprobe = 29,
Bootinfo = 32,
Merror64 = 33,
Mgmt = 34,
Mgmtc = 35,
Mgmtdt = 36,
Memch = 37,
Ipmi = 38,
Ps = 39,
Obd = 41,
};
Enum tabletab[] = {
0, "biosinfo",
1, "sysinfo",
2, "module",
3, "chassis",
4, "cpu",
5, "memctlr",
6, "memstk",
7, "cache",
8, "conn",
9, "slot",
11, "oemstr",
13, "bioslang",
14, "groupa",
15, "syslog",
16, "pmem",
17, "mdev",
18, "merror",
19, "mmap",
20, "mmdev",
21, "pointer",
22, "battery",
23, "wdog",
24, "hwsec",
25, "syspwr",
26, "vprobe",
27, "fan",
28, "tprobe",
29, "cprobe",
32, "bootinfo",
33, "merror64",
34, "mgmt",
35, "mgmtc",
36, "mgmtdt",
37, "memch",
38, "ipmi",
39, "ps",
41, "obd",
0, nil,
};
uchar *dmianchor[0x20];
int rfd = -1;
int prtype = -1;
int prhand = -1;
void
realmodefd(void)
{
if(rfd != -1)
return;
rfd = open("/dev/realmodemem", OREAD);
if(rfd == -1)
sysfatal("open: %r");
}
void*
emalloc(usize sz)
{
void *v;
v = malloc(sz);
if(v == nil)
sysfatal("malloc: %r");
memset(v, 0, sz);
setmalloctag(v, getcallerpc(&sz));
return v;
}
enum {
String,
Integer,
Uchar,
Enumf,
Enumbv,
};
Item biositems[] = {
"vendor", 1, String, -1, "%s", nil,
"version", 1, String, -1, "%s", nil,
"biosstartseg", 2, Integer, -1, "%#.4llux", nil,
"biosdate", 1, String, -1, "%s", nil,
"biosromsz", 1, Integer, -1, "%#.4llux", nil, // _+1<<16
"biosflags", 8, Uchar, -1, "%.8H", nil,
"extflags0", 1, Integer, -1, "%.2llux", nil,
"extflags1", 1, Integer, -1, "%.2llux", nil,
"release0", 1, Integer, -1, "%.2llux", nil,
"release1", 1, Integer, -1, "%.2llux", nil,
"embedrelease0", 1, Integer, -1, "%.2llux", nil,
"embedrelease1", 1, Integer, -1, "%.2llux", nil,
};
Enum waketype[] = {
0, "reserved",
1, "other",
2, "unknown",
3, "apmtimer",
4, "modem",
5, "lan",
6, "powersw",
7, "pcipme",
8, "powerrestored",
0, nil,
};
Item sysitems[] = {
"mfg", 1, String, -1, "%s", nil,
"product", 1, String, -1, "%s", nil,
"version", 1, String, -1, "%s", nil,
"uuid", 16, Uchar, -1, "%.16H", nil,
"waketype", 1, Integer, -1, "%lld", nil,
"sku", 1, String, -1, "%s", nil,
"family", 1, String, -1, "%s", nil,
};
Item moditems[] = {
"bbmfg", 1, String, -1, "%s", nil,
"product", 1, String, -1, "%s", nil,
"bbversion", 1, String, -1, "%s", nil,
"bbserial", 1, String, -1, "%s", nil,
"assettag", 1, String, -1, "%s", nil,
"features", 1, Integer, -1, "%#.2llux", nil,
"chassisloc", 1, String, -1, "%s", nil,
"chassishand", 2, Integer, -1, "%#.4llux", nil,
"bbtype", 1, Integer, -1, "%lld", nil,
/* continued object handles; 2 bytes each */
};
Item chassisitems[] = {
"chassismfg", 1, String, -1, "%s", nil,
"chassistype", 1, Integer, -1, "%lld", nil,
"chassisver", 1, String, -1, "%s", nil,
"chassisserial", 1, String, -1, "%s", nil,
"chassisassettag", 1, String, -1, "%s", nil,
"bootstate", 1, Integer, -1, "%lld", nil,
"powerst", 1, Integer, -1, "%lld", nil,
"thermalst", 1, Integer, -1, "%lld", nil,
"securityst", 1, Integer, -1, "%lld", nil,
"height", 1, Integer, -1, "%lld", nil,
"powercord#", 1, Integer, -1, "%lld", nil,
"elementcnt", 1, Integer, -1, "%lld", nil,
/* containted elements & sku number */
};
Enum sockettype[] = {
1, "other",
2, "unknown",
3, "daughter board",
4, "zif socet",
5, "replacable piggy back",
6, "none",
7, "lif socket",
8, "slot 1",
9, "slot 2",
0xa, "370-pin socket",
0xb, "slot a",
0xc, "slot m",
0xd, "socket 423",
0xe, "socket a (socket 462)",
0xf, "socket 478",
0x10, "socket 754",
0x11, "socket 940",
0x12, "socket 939",
0x13, "socket mPGA604",
0x14, "socket lga771",
0x15, "socket lga775",
0x16, "socket s1",
0x17, "socket am2",
0x18, "socket f",
0x19, "socket lga1366",
0x1a, "socket g34",
0x1b, "socket am3",
0x1c, "socket c32",
0x1d, "socket lga1156",
0x1d, "socket lga1567",
0x1f, "socket pga988a",
0x20, "socket bg1288",
0x21, "socket rpga988b",
0x22, "socket bga1023",
0x23, "socket bga1224",
0x24, "socket bga1155",
0x25, "socket bga1356",
0x26, "socket lga2011",
0x27, "socket fs1",
0x28, "socket fs2",
0x29, "socket fm1",
0x2a, "socket fm2",
};
Item cpuitems[] = {
"socket", 1, String, -1, "%s", nil,
"cputype", 1, Integer, -1, "%lld", nil,
"cpufamily", 1, Integer, -1, "%lld", nil,
"cpumfg", 1, String, -1, "%s", nil,
"cpuid", 8, Integer, -1, "%llux", nil,
"cpuvers", 1, String, -1, "%s", nil,
"cpuvolt", 1, Integer, -1, "%lld", nil,
"clockmhz", 2, Integer, -1, "%lld", nil,
"cpuspeed", 2, Integer, -1, "%lld", nil,
"cpuspeed (now)", 2, Integer, -1, "%lld", nil,
"cpustatus", 1, Integer, -1, "%lld", nil,
"cpuupgrade", 1, Enumf, -1, "%s", sockettype,
"cpul1", 2, Integer, -1, "%.2llux", nil,
"cpul2", 2, Integer, -1, "%.2llux", nil,
"cpul3", 2, Integer, -1, "%.2llux", nil,
"cpuserial", 1, String, -1, "%s", nil,
"cpuassettag", 1, String, -1, "%s", nil,
"cpupart#", 1, String, -1, "%s", nil,
"cpucore#", 1, Integer, -1, "%lld", nil,
"cpucoreen", 1, Integer, -1, "%lld", nil,
"cputhreadcnt", 1, Integer, -1, "%lld", nil,
"cpuenum", 2, Integer, -1, "%#.4llux", nil,
"cpufamily2", 2, Integer, -1, "%#.4llux", nil,
};
Enum ecctypetab[] = {
1, "other",
2, "unknown",
3, "none",
4, "8-bit parity",
5, "32-bit ecc",
6, "32-bit ecc",
7, "32-bit ecc",
8, "crc",
0, nil,
};
/* bitfield */
Enum ecccap[] = {
1<<0, "other",
1<<1, "unknown",
1<<2, "none",
1<<3, "single-bit",
1<<4, "double-bit",
1<<5, "error scrubbing",
0, nil,
};
Enum interleave[] = {
1, "other",
2, "unknown",
3, "one-way",
4, "two-way",
5, "four-way",
6, "eight-way",
7, "sixteen-way",
0, nil,
};
Item memctlritems[] = {
"ecctype", 1, Enumf, -1, "%s", ecctypetab,
"ecccap", 1, Enumbv, -1, "%s", ecccap,
"interleavesupp", 1, Enumf, -1, "%s", interleave,
"interleavecurr", 1, Enumf, -1, "%s", interleave,
"maxmodsz", 1, Integer, -1, "%ℛ", nil,
"speedsupp", 2, Integer, -1, "%#.4llux", nil,
"typessupp", 2, Integer, -1, "%#.4llux", nil,
"voltages", 1, Integer, -1, "%#.2llux", nil,
"memslots", 1, Integer, -1, "%lld", nil,
/* "handles" 2*memslots, Integer, -1, "%#.4llux", nil, */
/* "eccenabled" 1, Integer, -1, "%.2llux", nil, */
};
int
fmtℛ(Fmt *f)
{
char *prefix;
uint code;
prefix = "";
code = va_arg(f->args, uvlong);
if(f->flags & FmtSharp){
switch(code){
case 0x7d:
return fmtprint(f, "not determinable");
case 0x7e:
return fmtprint(f, "installed but disabled");
case 0x7f:
return fmtprint(f, "not installed");
}
if(code & 0x80)
prefix = "dual-port ";
code &= ~0x80;
}
return fmtprint(f, "%s%dMB", prefix, 1<<code);
}
Enum moduletype[] = {
1<<0, "other",
1<<1, "unknown",
1<<2, "standard",
1<<3, "fast page mode",
1<<4, "edo",
1<<5, "parity",
1<<6, "ecc",
1<<7, "simm",
1<<8, "dimm",
1<<9, "burst edo",
1<<10, "sdram",
};
Item memstkitems[] = {
"memsocket", 1, String, -1, "%s", nil,
"bankconn", 1, Integer, -1, "%#.2llux", nil, /* nybble-encoding */
"currspeed (ns)", 1, Integer, -1, "%lld", nil,
"memtype", 2, Integer, -1, "%#.4llux", nil,
"installsz", 1, Integer, -1, "%#ℛ", nil,
"enablesz", 1, Integer, -1, "%#ℛ", nil,
"errorsts", 1, Integer, -1, "%.2llux", nil,
};
Enum sramtype[] = {
1<<0, "other",
1<<1, "unknown",
1<<2, "non-burst",
1<<3, "pipeline burst",
1<<4, "sync",
1<<5, "async",
0, nil,
};
Enum cachetype[] = {
1, "other",
2, "unknown",
3, "instruction",
4, "data",
5, "unified",
0, nil,
};
Enum assoctype[] = {
1, "other",
2, "unknown",
3, "direct mapped",
4, "2-way set-associative",
5, "4-way set-associative",
6, "fully associative",
7, "8-way set-associative",
8, "16-way set-associative",
9, "12-way set-associative",
10, "24-way set-associative",
11, "32-way set-associative",
12, "48-way set-associative",
13, "64-way set-associative",
14, "20-way set-associative",
0, nil,
};
Item cacheitems[] = {
"socket", 1, String, -1, "%s", nil,
"config", 2, Integer, -1, "%#.4llux", nil,
"maxsize", 2, Integer, -1, "%#.4llux", nil,
"instalsz", 2, Integer, -1, "%#.4llux", nil,
"sramtype", 2, Enumf, -1, "%s", sramtype,
"installtype", 2, Integer, -1, "%#.4llux", nil,
"speed (ns)", 1, Integer, -1, "%lld", nil,
"ecctype", 1, Integer, -1, "%#.2llux", nil,
"logicaltype", 1, Enumf, -1, "%s", cachetype,
"assoc", 1, Enumf, -1, "%s", assoctype,
};
Item connitems[] = {
"intrefdes", 1, String, -1, "%s", nil,
"intconntype", 1, Integer, -1, "%#.2llux", nil,
"extrefdes", 1, String, -1, "%s", nil,
"intconntype", 1, Integer, -1, "%#.2llux", nil,
"porttype", 1, Integer, -1, "%#.2llux", nil,
};
Enum slottype[] = {
1, "other",
2, "unknown",
3, "isa",
4, "mca",
5, "eisa",
6, "pci",
7, "pcmcia",
8, "vl-vesa",
9, "propoetart",
0xa, "processor card slot",
0xb, "propietary memory card slot",
0xc, "i/o reiser card slot",
0xd, "nubus",
0xe, "pci66mhz",
0xf, "agp",
0x10, "agp2x",
0x11, "agp4x",
0x12, "pci-x",
0x13, "agp8x",
0xa0, "pc-98/c20",
0xa1, "pc-98/c24",
0xa2, "pc-98/e",
0xa3, "pc-98/localbus",
0xa4, "pc-98/card",
0xa5, "pcie",
0xa6, "pcie x1",
0xa7, "pcie x2",
0xa8, "pcie x4",
0xa9, "pcie x8",
0xaa, "pcie x16",
0xab, "pcie gen2",
0xac, "pcie gen2 x1",
0xad, "pcie gen2 x2",
0xae, "pcie gen2 x4",
0xaf, "pcie gen2 x8",
0xb0, "pcie gen2 x16",
0xb1, "pcie gen3",
0xb2, "pcie gen3 x1",
0xb3, "pcie gen3 x2",
0xb4, "pcie gen3 x4",
0xb5, "pcie gen3 x8",
0xb6, "pcie gen3 x16",
0, nil,
};
Enum slotwidth[] = {
1, "other",
2, "unknown",
3, "8bit",
4, "16bit",
5, "32bit",
6, "64bit",
7, "128bit",
8, "1x",
9, "2x",
0xa, "4x",
0xb, "8x",
0xc, "12x",
0xd, "16x",
0xe, "32x",
0, nil,
};
Enum slotuse[] = {
1, "other",
2, "unknown",
3, "available",
4, "inuse",
0, nil,
};
Enum slotlength[] = {
1, "other",
2, "unknown",
3, "short",
4, "long",
0, nil,
};
Item slotitems[] = {
"slotname", 1, String, -1, "%s", nil,
"slottype", 1, Enumf, -1, "%s", slottype,
"datawidth", 1, Enumf, -1, "%s", slotwidth,
"use", 1, Enumf, -1, "%s", slotuse,
"slotlen", 1, Enumf, -1, "%s", slotlength,
"slotid", 2, Integer, -1, "%lld", nil,
"slotbits0", 1, Integer, -1, "%.2llux", nil,
"slotbits1", 1, Integer, -1, "%.2llux", nil,
"segment", 1, Integer, -1, "%.2llux", nil,
"bus", 1, Integer, -1, "%.2llux", nil,
"devfn", 1, Integer, -1, "%.2llux", nil,
};
Item bioslangitems[] = {
"installable", 1, String, -1, "%lld", nil,
"flags", 1, Integer, -1, "%lld", nil,
"reserved", 15, Uchar, -1, "%.15H", nil,
"currlang", 1, String, -1, "%s", nil,
};
Enum accesstab[] = {
0, "i/o indexed 1x 8-bit index/1x 8-bit data",
1, "i/o indexed 2x 8-bit index/2x 8-bit data",
2, "i/o indexed 1x 16-bit index/1x 8-bit data",
3, "32-bit mmio",
4, "general purpose nv data access method",
};
Item syslogitems[] = {
"loglength", 2, Integer, -1, "%#.4llux", nil,
"hdroffset", 2, Integer, -1, "%#.4llux", nil,
"dataoffset", 2, Integer, -1, "%#.4llux", nil,
"access", 1, Enumf, -1, "%s", accesstab,
"status", 1, Integer, -1, "%#.2llux", nil,
"token", 4, Integer, -1, "%#.8llux", nil,
"pa", 4, Integer, -1, "%#.8llux", nil,
"format", 1, Integer, -1, "%lld", nil,
"ndesc", 1, Integer, -1, "%lld", nil,
"desclen", 1, Integer, -1, "%lld", nil,
/* list goes here */
};
Enum memuse[] = {
1, "other",
2, "unknown",
3, "system memory",
4, "video memory",
5, "flash memory",
6, "nvram",
7, "cache",
0, nil,
};
Item pmemitems[] = {
"loc", 1, Integer, -1, "%lld", nil,
"use", 1, Enumf, -1, "%s", memuse,
"ecc", 1, Integer, -1, "%lld", nil,
"capacity", 4, Integer, -1, "%lld kb", nil,
"errhandle", 2, Integer, -1, "%.4llux", nil,
"#devices", 2, Integer, -1, "%lld", nil,
"ecapacity", 8, Integer, -1, "%lld bytes", nil,
};
Enum formfactor[] = {
1, "other",
2, "unknown",
3, "simm",
4, "sip",
5, "chip",
6, "dip",
7, "zip",
8, "proprietary card",
9, "dimm",
0xa, "tsop",
0xb, "row of chips",
0xc, "rimm",
0xd, "sodimm",
0xe, "srimm",
0xf, "fb-dimm",
0, nil,
};
Enum mdevmemtype[] = {
1, "other",
2, "unknown",
3, "dram",
4, "edram",
5, "vram",
6, "sram",
7, "ram",
8, "rom",
9, "flash",
0xa, "eeprom",
0xb, "feprom",
0xc, "eprom",
0xd, "cdram",
0xe, "3dram",
0xf, "sdram",
0x10, "sgram",
0x11, "rdram",
0x12, "ddr",
0x13, "ddr2",
0x14, "ddr2 fb-dimm",
0x18, "ddr3",
0x19, "fbd2",
0, nil,
};
Enum typedetail[] = {
1<<1, "other",
1<<2, "unknown",
1<<3, "fast-paged",
1<<4, "static- column",
1<<5, "pseudo-static",
1<<6, "rambus",
1<<7, "synchronous",
1<<8, "cmos",
1<<9, "edo",
1<<10, "window dram",
1<<11, "cache dram",
1<<12, "non-volatile",
1<<13, "registered (buffered)",
1<<14, "unregistered (unbuffered)",
0, nil,
};
int
fmt𝒮(Fmt *f)
{
uint u;
u = va_arg(f->args, uvlong);
if(u & 0x8000)
return fmtprint(f, "%d kb", u&~0x8000);
return fmtprint(f, "%d mb", u);
}
Item mdevitems[] = {
"paryhnd", 2, Integer, -1, "%#.4llux", nil,
"errhnd", 2, Integer, -1, "%#.4llux", nil,
"twidth", 2, Integer, -1, "%llud", nil,
"width", 2, Integer, -1, "%llud", nil,
"size", 2, Integer, -1, "%𝒮", nil,
"formfactor", 1, Enumf, -1, "%s", formfactor,
"deviceset", 1, Integer, -1, "%llud", nil,
"locator", 1, String, -1, "%s", nil,
"bankloc", 1, String, -1, "%s", nil,
"memtype", 1, Enumf, -1, "%s", mdevmemtype,
"typedetail", 2, Enumf, -1, "%s", typedetail,
"speed", 2, Integer, -1, "%llud Mhz", nil,
"mfgr", 1, String, -1, "%s", nil,
"serial", 1, String, -1, "%s", nil,
"assettag", 1, String, -1, "%s", nil,
"part#", 1, String, -1, "%s", nil,
"attr", 1, Integer, -1, "%.2llux", nil,
"xsize", 4, Integer, -1, "%#.4llud MB", nil,
"cfgspeed", 2, Integer, -1, "%llud Mhz", nil,
};
Enum errortype[] = {
1, "other",
2, "unknown",
3, "ok",
4, "bad read",
5, "parity error",
6, "single-bit error",
7, "double-bit error",
8, "muti-bit error",
9, "nybble error",
0xa, "cksum error",
0xb, "crc error",
0xc, "corrected single-bit error",
0xd, "corrected error",
0xe, "uncorrectable error",
0, nil,
};
Enum errorgran[] = {
1, "other",
2, "unknown",
3, "device",
4, "memory partition",
0, nil,
};
Enum memoryop[] = {
1, "other",
2, "unknown",
3, "read",
4, "write",
0, nil,
};
Item merroritems[] = {
"errortype", 1, Enumf, -1, "%s", errortype,
"errorgran", 1, Enumf, -1, "%s", errorgran,
"errorop", 1, Enumf, -1, "%s", memoryop,
"syndrome", 4, Integer, -1, "%#.8llux", nil,
"physaddr", 4, Integer, -1, "%#.8llux", nil,
"devaddr", 4, Integer, -1, "%#.8llux", nil,
"resolution", 4, Integer, -1, "%#.8llux", nil,
};
Item mmapitems[] = {
"start", 4, Integer, -1, "%#.8llux kb", nil,
"end", 4, Integer, -1, "%#.8llux kb", nil,
"ahand", 2, Integer, -1, "%#.4llux", nil,
"partwidth", 1, Integer, -1, "%lld", nil,
"xstart", 8, Integer, -1, "%#.16llux", nil,
"xend", 8, Integer, -1, "%#.16llux", nil,
};
/* prec→multiplier, width→prec */
int
fmt×(Fmt *f)
{
uvlong kb, m;
kb = va_arg(f->args, uvlong);
m = 1024;
if(f->flags & FmtPrec){
f->flags &= ~FmtPrec;
m = f->prec;
}
if(f->flags & FmtWidth)
return fmtprint(f, "%#.*llux", f->width, kb*m);
return fmtprint(f, "%#.8llux", kb*m);
}
Item mmdevitems[] = {
"start", 4, Integer, -1, "%8.1024×", nil,
"end", 4, Integer, -1, "%8.1024×", nil,
"dhand", 2, Integer, -1, "%#.4llux", nil,
"ahand", 2, Integer, -1, "%#.4llux", nil,
"row", 1, Integer, -1, "%lld", nil,
"interleave", 1, Integer, -1, "%lld", nil,
"idepth", 1, Integer, -1, "%lld", nil,
"xstart", 8, Integer, -1, "%#.16llux", nil,
"xend", 8, Integer, -1, "%#.16llux", nil,
};
Item ptritems[] = {
"type", 1, Integer, -1, "%lld", nil,
"interface", 1, Integer, -1, "%lld", nil,
"buttons", 1, Integer, -1, "%lld", nil,
};
Enum batterychemistry[] = {
1, "other",
2, "unknown",
3, "lead acid",
4, "nicad",
5, "nimh",
6, "lion",
7, "zincair",
8, "li polymer",
0, nil,
};
Item batteryitems[] = {
"location", 1, String, -1, "%s", nil,
"mfgr", 1, String, -1, "%s", nil,
"mfgr date", 1, String, -1, "%s", nil,
"serial", 1, String, -1, "%s", nil,
"devname", 1, String, -1, "%s", nil,
"chemistry", 1, Enumf, -1, "%s", batterychemistry,
"capacity", 2, Integer, -1, "%lld mWh", nil,
"voltage", 2, Integer, -1, "%lld mV", nil,
"sbds vers", 1, Integer, -1, "%lld", nil,
"maxerror%", 1, Integer, -1, "%lld", nil,
"sbds serial", 2, Integer, -1, "%.4llux", nil,
"sbds mfgdate", 2, Integer, -1, "%.4llux", nil,
"sbds chem", 1, String, -1, "%s", nil,
"capacity ×", 1, Integer, -1, "%lld", nil,
"oemword", 2, Integer, -1, "%llux", nil,
};
Item wdogitems[] = {
"cap", 1, Integer, -1, "%.2llux", nil,
"rstcount", 2, Integer, -1, "%lld", nil,
"rstlim", 2, Integer, -1, "%lld", nil,
"interval", 2, Integer, -1, "%lld min", nil,
"timeout", 2, Integer, -1, "%lld min", nil,
};
Item hwsecitems[] = {
"settings", 1, Integer, -1, "%.2llux", nil,
};
Item syspwritems[] = {
"month", 1, Integer, -1, "%.2llux", nil,
"mday", 1, Integer, -1, "%.2llux", nil,
"day", 1, Integer, -1, "%.2llux", nil,
"min", 1, Integer, -1, "%.2llux", nil,
"osec", 1, Integer, -1, "%.2llux", nil,
};
Item vprobeitems[] = {
"desc", 1, String, -1, "%s", nil,
"locstat", 1, Integer, -1, "%.2llux", nil,
"max", 2, Integer, -1, "%.2llud mV", nil,
"min", 2, Integer, -1, "%.2llud mV", nil,
"res", 2, Integer, -1, "%.2llud mV", nil,
"tolerance", 2, Integer, -1, "%.2llud mV", nil,
"accuracy", 2, Integer, -1, "%.2llud mV", nil,
"oem", 4, Integer, -1, "%.8llux", nil,
"nominal", 2, Integer, -1, "%.2llud mV", nil,
};
Enum fantypestat[] = {
1<<5, "other",
2<<5, "unknown",
3<<5, "ok",
4<<5, "non-critical",
5<<5, "critical",
6<<5, "non-recoverable",
1, "other",
2, "unknown",
3, "fan",
4, "centrifugal blower",
5, "chip fan",
6, "cabinet fan",
7, "powersupply fan",
8, "heat pipe",
9, "integrated refrig",
0xa, "active cooling",
0xb, "passive cooling",
0, nil,
};
Item fanitems[] = {
"tprobhnd", 2, Integer, -1, "%.4llux", nil,
"typestat", 1, Integer, -1, "%.2llux", nil,
"coolgroup", 1, Integer, -1, "%.2llux", nil,
"oem", 4, Integer, -1, "%.8llux", nil,
"nominalspd", 2, Integer, -1, "%.4lld", nil,
"description", 1, String, -1, "%s", nil,
};
Item tprobeitems[] = {
"desc", 1, String, -1, "%s", nil,
"locstat", 1, Integer, -1, "%.2llux", nil,
"max", 2, Integer, -1, "%.llud 1/10th °C", nil,
"min", 2, Integer, -1, "%.llud 1/10th °C", nil,
"res", 2, Integer, -1, "%.llud 1/10th °C", nil,
"tolerance", 2, Integer, -1, "%.llud 1/10th °C", nil,
"accuracy", 2, Integer, -1, "%.llud 1/10th °C", nil,
"oem", 4, Integer, -1, "%.8llux", nil,
"nominal", 2, Integer, -1, "%.llud 1/10th °C", nil,
};
Item cprobeitems[] = {
"desc", 1, String, -1, "%s", nil,
"locstat", 1, Integer, -1, "%.2llux", nil,
"max", 2, Integer, -1, "%.llud mA", nil,
"min", 2, Integer, -1, "%.llud mA", nil,
"res", 2, Integer, -1, "%.llud mA", nil,
"tolerance", 2, Integer, -1, "%.llud mA", nil,
"accuracy", 2, Integer, -1, "%.llud mA", nil,
"oem", 4, Integer, -1, "%.8llux", nil,
"nominal", 2, Integer, -1, "%.llud mA", nil,
};
Item bootinfoitems[] = {
"undefined", 6, Integer, -1, "%llux", nil,
"status", 10, Uchar, -1, "%.10H", nil,
};
Item memerr64items[] = {
"type", 1, Integer, -1, "%llud", nil,
"gran", 1, Integer, -1, "%llud", nil,
"operation", 1, Integer, -1, "%llud", nil,
"synrdome", 4, Integer, -1, "%.8llux", nil,
"addr", 8, Integer, -1, "%.16llux", nil,
"devaddr", 8, Integer, -1, "%.16llux", nil,
"resolution", 4, Integer, -1, "%.8llux", nil,
};
Enum mgmtaddrtype[] = {
1, "other",
2, "unknown",
3, "i/o port",
4, "memory",
5, "smbus",
0, nil,
};
Item mgmtitems[] = {
"desc", 1, String, -1, "%s", nil,
"type", 1, Integer, -1, "%lld", nil,
"addr", 4, Integer, -1, "%#.8llx", nil,
"addrtype", 1, Enumf, -1, "%s", mgmtaddrtype,
};
Item mgmtcitems[] = {
"desc", 1, String, -1, "%s", nil,
"devhand", 2, Integer, -1, "%.4llux", nil,
"cmphand", 2, Integer, -1, "%.4llux", nil,
"thand", 2, Integer, -1, "%.4llux", nil,
};
Item mgmtdtitems[] = {
"low thresh", 2, Integer, -1, "%.4llud", nil,
"hi thresh", 2, Integer, -1, "%.4llud", nil,
"low crit thresh", 2, Integer, -1, "%.4llud", nil,
"hi crit thresh", 2, Integer, -1, "%.4llud", nil,
"low nr thresh", 2, Integer, -1, "%.4llud", nil,
"hi nr thresh", 2, Integer, -1, "%.4llud", nil,
};
Item memchanitems[] = {
"type", 1, Integer, -1, "%llud", nil,
"maxload", 1, Integer, -1, "%llud", nil,
"devcnt", 1, Integer, -1, "%llud", nil,
"load1", 1, Integer, -1, "%llud", nil,
"hndl1", 2, Integer, -1, "%.4llux", nil,
};
Item ipmiitems[] = {
"type", 1, Integer, -1, "%llud", nil,
"version", 1, Integer, -1, "%#.2llux", nil,
"i²c slaveaddr", 1, Integer, -1, "%#.2llux", nil,
"nvstoraddr", 1, Integer, -1, "%#.2llux", nil,
"pa", 8, Integer, -1, "%#.16llux", nil,
"pa modify", 1, Integer, -1, "%#.2llux", nil,
"irq#", 1, Integer, -1, "%#.2llux", nil,
};
Item psitems[] = {
"pwrgrp", 1, Integer, -1, "%llud", nil,
"loc", 1, String, -1, "%s", nil,
"name", 1, String, -1, "%s", nil,
"mfg", 1, String, -1, "%s", nil,
"serial", 1, String, -1, "%s", nil,
"assetag", 1, String, -1, "%s", nil,
"part#", 1, String, -1, "%s", nil,
"rev", 1, String, -1, "%s", nil,
"pwrecap", 2, Integer, -1, "%llud mW", nil,
"flags", 2, Integer, -1, "%.4llux", nil,
"input v hdl", 2, Integer, -1, "%.4llux", nil,
"fan hdl", 2, Integer, -1, "%.4llux", nil,
"current hdl", 2, Integer, -1, "%.4llux", nil,
};
Item obditems[] = {
"name", 1, String, -1, "%s", nil,
"type", 1, Integer, -1, "%.2llux", nil,
"inst", 1, Integer, -1, "%.2llux", nil,
"segment", 1, Integer, -1, "%.2llux", nil,
"bus", 1, Integer, -1, "%.2llux", nil,
"devfn", 1, Integer, -1, "%.2llux", nil,
};
typedef struct Itemtab Itemtab;
struct Itemtab {
Item *tab;
int n;
};
Itemtab itemtab[] = {
[Biosinfo] biositems, nelem(biositems),
[Sysinfo] sysitems, nelem(sysitems),
[Module] moditems, nelem(moditems),
[Chassis] chassisitems, nelem(chassisitems),
[Cpu] cpuitems, nelem(cpuitems),
[Memctlr] memctlritems, nelem(memctlritems),
[Memstk] memstkitems, nelem(memstkitems),
[Cache] cacheitems, nelem(cacheitems),
[Conn] connitems, nelem(connitems),
[Slot] slotitems, nelem(slotitems),
[Bioslang] bioslangitems, nelem(bioslangitems),
[Syslog] syslogitems, nelem(syslogitems),
[Pmem] pmemitems, nelem(pmemitems),
[Mdev] mdevitems, nelem(mdevitems),
[Merror] merroritems, nelem(merroritems),
[Mmap] mmapitems, nelem(mmapitems),
[Mmdev] mmdevitems, nelem(mmdevitems),
[Pointer] ptritems, nelem(ptritems),
[Battery] batteryitems, nelem(batteryitems),
[Wdog] wdogitems, nelem(wdogitems),
[Hwsec] hwsecitems, nelem(hwsecitems),
[Syspwr] syspwritems, nelem(syspwritems),
[Vprobe] vprobeitems, nelem(vprobeitems),
[Fan] fanitems, nelem(fanitems),
[Tprobe] tprobeitems, nelem(tprobeitems),
[Cprobe] cprobeitems, nelem(cprobeitems),
[Bootinfo] bootinfoitems, nelem(bootinfoitems),
[Merror64] memerr64items, nelem(memerr64items),
[Mgmt] mgmtitems, nelem(mgmtitems),
[Mgmtc] mgmtcitems, nelem(mgmtcitems),
[Mgmtdt] mgmtdtitems, nelem(mgmtdtitems),
[Memch] memchanitems, nelem(memchanitems),
[Ipmi] ipmiitems, nelem(ipmiitems),
[Ps] psitems, nelem(psitems),
[Obd] obditems, nelem(obditems),
};
void
setoffsets(Item *tab, int n)
{
int i, o;
o = 4;
for(i = 0; i < n; i++){
tab[i].offset = o;
o += tab[i].nbytes;
}
}
void
tabinit(void)
{
int i;
for(i = 0; i < nelem(itemtab); i++)
setoffsets(itemtab[i].tab, itemtab[i].n);
}
char*
getstring(uchar *p, int i, uchar *e)
{
uchar *q;
if(i == 0)
return nil;
for(;; i--){
if(i == 1)
break;
p = memchr(p, 0, e - p - 1);
if(p == nil)
sysfatal("bad strings"); // return nil;
p++;
}
q = memchr(p, 0, e - p - 1);
if(q == nil || q-p == 0)
return nil;
return strdup((char*)p);
}
void
crack(uchar *p, uchar *e, Item *tabi, Itemv *tabv, int n)
{
int i, len;
Item *t;
Itemv *v;
len = p[1];
for(i = 0; i < n; i++){
t = tabi + i;
v = tabv + i;
if(p + t->offset + t->nbytes >= p+len){
/* cheater way to protect against new std. versions */
continue;
}
switch(t->type){
default:
sysfatal("bad type");
case String:
v->s = getstring(p + len, p[t->offset], e);
break;
case Enumf:
case Enumbv:
case Integer:
if(p + t->offset + t->nbytes >= e)
sysfatal("range");
v->i = getle(p + t->offset, t->nbytes);
break;
case Uchar:
if(p + t->offset + t->nbytes >= e)
sysfatal("range");
memcpy(v->uuid, p + t->offset, t->nbytes);
break;
}
}
}
void
dumpenum(Enum *p)
{
for(; p->s != nil; p++)
print("%s %d\n", p->s, p->v);
}
char*
enumtostr(Enum *p, uvlong i)
{
for(; p->s != nil; p++)
if(i == p->v)
return p->s;
return nil;
}
int
strtoenum(Enum *p, char *s)
{
for(; p->s != nil; p++)
if(cistrcmp(s, p->s) == 0)
return p->v;
return -1;
}
char*
enumbvtostr(Enum *p, uint i, char *s0, char *e)
{
char *s;
s = s0;
for(; p->s != nil; p++)
if(i & p->v){
if(s != s0)
s = seprint(s, e, " ");
s = seprint(s, e, "%s", p->s);
}
if(s != s0)
return s0;
return nil;
}
void
printitems(int type, Item *tabi, Itemv *tabv, int n)
{
char *s, buf[128];
int i;
Item *t;
Itemv *v;
// print("type %d\n", type);
USED(type);
for(i = 0; i < n; i++){
t = tabi + i;
v = tabv + i;
print(" %-12s ", t->name);
switch(t->type){
default:
sysfatal("bad type");
case String:
print(t->fmt, v->s);
break;
case Integer:
print(t->fmt, v->i);
break;
case Uchar:
print(t->fmt, v->uuid);
break;
case Enumf:
s = enumtostr(t->tab, v->i);
if(s != nil){
print(t->fmt, s);
print(" (%#llux)", v->i);
}
else
print("%lld", v->i);
break;
case Enumbv:
s = enumbvtostr(t->tab, v->i, buf, buf+sizeof buf);
if(s != nil){
print(t->fmt, s);
print(" (%#llux)", v->i);
}
else
print("%lld", v->i);
break;
}
print("\n");
}
}
uchar*
next(uchar *p, uchar *e)
{
int ns;
p += p[1];
if(p >= e)
sysfatal("structures out-of-bounds");
for(ns = 0;; ns++){
p = memchr(p, 0, e - p - 1);
if(p == nil)
sysfatal("bad strings");
p++;
if(p[0] == 0){
p++;
break;
}
}
USED(ns);
return p;
}
Sm*
finddmi(void)
{
uchar *buf, *p, *e;
int type, hand, len, i, n;
Itemv *v;
Sm *sm;
realmodefd();
buf = emalloc(Dmisz);
if(pread(rfd, buf, Dmisz, Dmistart) != Dmisz)
sysfatal("read: %r");
e = buf + Dmisz;
for(p = buf; p < e; p += 16)
if(memcmp(p, "_SM_", 4) == 0)
goto found;
sysfatal("no dmi structure");
found:
print("found at %#lux\n", p-buf+Dmistart);
len = p[5];
/* do checksums */
sm = emalloc(len);
sm->raw = *(Smbuf*)p;
print("dmi %ud.%ud\n", sm->raw.vers[0], sm->raw.vers[1]);
sm->stpa = getle(sm->raw.stpa, 4);
sm->stlen = getle(sm->raw.stlen, 2);
print("structure pa %llux len %d count %d\n", sm->stpa, sm->stlen, (uint)getle(sm->raw.nstrut, 2));
n = getle(sm->raw.nstrut, 2);
free(buf);
buf = emalloc(sm->stlen);
if(pread(rfd, buf, sm->stlen, sm->stpa) != sm->stlen)
sysfatal("read: %r");
p = buf;
e = buf + sm->stlen;
for(i = 0; i < n; i++){
type = p[0];
hand = getle(p+2, 2);
if(prtype != -1 && type != prtype)
goto n;
if(prhand != -1 && hand != prhand)
goto n;
print("%d: type %s %ud len %ud handle %ud\n",
i, enumtostr(tabletab, p[0]), p[0], p[1], hand);
if(type < nelem(itemtab)){
v = emalloc(itemtab[type].n*sizeof *v);
crack(p, e, itemtab[type].tab, v, itemtab[type].n);
printitems(type, itemtab[type].tab, v, itemtab[type].n);
free(v);
}
n:
p = next(p, e);
}
return sm;
}
void
usage(void)
{
fprint(2, "usage: dmi [-t type] [-h hand]\n");
exits("usage");
}
void
main(int argc, char **argv)
{
char *s, *p;
fmtinstall(L'ℛ', fmtℛ);
fmtinstall(L'𝒮', fmt𝒮);
fmtinstall(L'×', fmt×);
fmtinstall('H', encodefmt);
tabinit();
ARGBEGIN{
case 't':
s = EARGF(usage());
prtype = strtoul(s, &p, 0);
if(p == s)
prtype = strtoenum(tabletab, s);
if(prtype == -1)
sysfatal("bad type");
break;
case 'h':
prhand = strtoul(EARGF(usage()), &p, 0);
break;
case 'l':
dumpenum(tabletab);
exits("");
default:
usage();
}ARGEND
if(argc != 0)
usage();
finddmi();
// printdmi();
exits("");
}
|
