log_reader.go
1 package main 2 3 import ( 4 "bufio" 5 "flag" 6 "fmt" 7 "log" 8 "os" 9 "regexp" 10 "strconv" 11 "strings" 12 ) 13 14 type LogDevReader struct { 15 InputDirectory string 16 ACPITables map[string][]byte 17 EC []byte 18 } 19 20 func isXDigit(x uint8) bool { 21 if x >= '0' && x <= '9' { 22 return true 23 } 24 if x >= 'a' && x <= 'f' { 25 return true 26 } 27 if x >= 'A' && x <= 'F' { 28 return true 29 } 30 return false 31 } 32 33 type HexLine struct { 34 length uint 35 values [16]byte 36 start uint 37 } 38 39 func (l *LogDevReader) ReadHexLine(line string) (hex HexLine) { 40 hex.start = 0 41 line = strings.Trim(line, " ") 42 fmt.Sscanf(line, "%x:", &hex.start) 43 ll, _ := fmt.Sscanf(line, "%x: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", &hex.start, 44 &hex.values[0], &hex.values[1], &hex.values[2], 45 &hex.values[3], &hex.values[4], &hex.values[5], 46 &hex.values[6], &hex.values[7], &hex.values[8], 47 &hex.values[9], &hex.values[10], &hex.values[11], 48 &hex.values[12], &hex.values[13], &hex.values[14], 49 &hex.values[15]) 50 hex.length = uint(ll - 1) 51 return 52 } 53 54 func (l *LogDevReader) AssignHexLine(inp string, target []byte) []byte { 55 hex := l.ReadHexLine(inp) 56 if hex.start+hex.length > uint(len(target)) { 57 target = target[0 : hex.start+hex.length] 58 } 59 copy(target[hex.start:hex.start+hex.length], hex.values[0:hex.length]) 60 return target 61 } 62 63 func (l *LogDevReader) GetEC() []byte { 64 if l.EC != nil { 65 return l.EC 66 } 67 l.EC = make([]byte, 0x100, 0x100) 68 69 file, err := os.Open(l.InputDirectory + "/ectool.log") 70 if err != nil { 71 log.Fatal(err) 72 } 73 defer file.Close() 74 75 scanner := bufio.NewScanner(file) 76 77 for scanner.Scan() { 78 line := scanner.Text() 79 if len(line) > 7 && isXDigit(line[0]) && isXDigit(line[1]) && line[2] == ':' { 80 l.EC = l.AssignHexLine(line, l.EC) 81 } 82 } 83 84 if err := scanner.Err(); err != nil { 85 log.Fatal(err) 86 } 87 88 return l.EC 89 } 90 91 func (l *LogDevReader) GetACPI() (Tables map[string][]byte) { 92 if l.ACPITables != nil { 93 return l.ACPITables 94 } 95 l.ACPITables = Tables 96 97 file, err := os.Open(l.InputDirectory + "/acpidump.log") 98 if err != nil { 99 log.Fatal(err) 100 } 101 defer file.Close() 102 103 scanner := bufio.NewScanner(file) 104 105 Tables = map[string][]byte{} 106 107 curTable := "" 108 for scanner.Scan() { 109 line := scanner.Text() 110 /* Only supports ACPI tables up to 0x100000 in size, FIXME if needed */ 111 is_hexline, _ := regexp.MatchString(" *[0-9A-Fa-f]{4,5}: ", line) 112 switch { 113 case len(line) >= 6 && line[5] == '@': 114 curTable = line[0:4] 115 Tables[curTable] = make([]byte, 0, 0x100000) 116 case is_hexline: 117 Tables[curTable] = l.AssignHexLine(line, Tables[curTable]) 118 } 119 } 120 121 if err := scanner.Err(); err != nil { 122 log.Fatal(err) 123 } 124 125 return 126 } 127 128 func (l *LogDevReader) GetPCIList() (PCIList []PCIDevData) { 129 file, err := os.Open(l.InputDirectory + "/lspci.log") 130 if err != nil { 131 log.Fatal(err) 132 } 133 defer file.Close() 134 135 scanner := bufio.NewScanner(file) 136 137 PCIList = []PCIDevData{} 138 139 for scanner.Scan() { 140 line := scanner.Text() 141 switch { 142 case !(len(line) < 7 || !isXDigit(line[0]) || !isXDigit(line[1]) || line[2] != ':' || !isXDigit(line[3]) || !isXDigit(line[4]) || line[5] != '.' || !isXDigit(line[6])): 143 cur := PCIDevData{} 144 fmt.Sscanf(line, "%x:%x.%x", &cur.Bus, &cur.Dev, &cur.Func) 145 lc := strings.LastIndex(line, ":") 146 li := strings.LastIndex(line[0:lc], "[") 147 if li < 0 { 148 continue 149 } 150 ven := 0 151 dev := 0 152 fmt.Sscanf(line[li+1:], "%x:%x", &ven, &dev) 153 cur.PCIDevID = uint16(dev) 154 cur.PCIVenID = uint16(ven) 155 cur.ConfigDump = make([]byte, 0x100, 0x1000) 156 PCIList = append(PCIList, cur) 157 case len(line) > 7 && isXDigit(line[0]) && line[1] == '0' && line[2] == ':': 158 start := 0 159 fmt.Sscanf(line, "%x:", &start) 160 cur := &PCIList[len(PCIList)-1] 161 cur.ConfigDump = l.AssignHexLine(line, cur.ConfigDump) 162 } 163 } 164 165 if err := scanner.Err(); err != nil { 166 log.Fatal(err) 167 } 168 169 return 170 } 171 172 func (l *LogDevReader) GetInteltool() (ret InteltoolData) { 173 file, err := os.Open(l.InputDirectory + "/inteltool.log") 174 if err != nil { 175 log.Fatal(err) 176 } 177 defer file.Close() 178 179 scanner := bufio.NewScanner(file) 180 paragraph := "" 181 ret.GPIO = map[uint16]uint32{} 182 ret.RCBA = map[uint16]uint32{} 183 ret.IOBP = map[uint32]uint32{} 184 ret.IGD = map[uint32]uint32{} 185 ret.MCHBAR = map[uint16]uint32{} 186 ret.PMBASE = map[uint16]uint32{} 187 for scanner.Scan() { 188 line := scanner.Text() 189 switch { 190 case len(line) > 7 && line[0] == '0' && line[1] == 'x' && line[6] == ':' && paragraph == "RCBA": 191 addr, value := 0, 0 192 fmt.Sscanf(line, "0x%x: 0x%x", &addr, &value) 193 ret.RCBA[uint16(addr)] = uint32(value) 194 case len(line) > 11 && line[0] == '0' && line[1] == 'x' && line[10] == ':' && paragraph == "IOBP": 195 addr, value := 0, 0 196 fmt.Sscanf(line, "0x%x: 0x%x", &addr, &value) 197 ret.IOBP[uint32(addr)] = uint32(value) 198 case len(line) > 9 && line[0] == '0' && line[1] == 'x' && line[8] == ':' && paragraph == "IGD": 199 addr, value := 0, 0 200 fmt.Sscanf(line, "0x%x: 0x%x", &addr, &value) 201 ret.IGD[uint32(addr)] = uint32(value) 202 case len(line) > 7 && line[0] == '0' && line[1] == 'x' && line[6] == ':' && paragraph == "MCHBAR": 203 addr, value := 0, 0 204 fmt.Sscanf(line, "0x%x: 0x%x", &addr, &value) 205 ret.MCHBAR[uint16(addr)] = uint32(value) 206 case strings.Contains(line, "DEFAULT"): 207 continue 208 case strings.Contains(line, "DIFF"): 209 continue 210 case strings.HasPrefix(line, "gpiobase"): 211 addr, value := 0, 0 212 fmt.Sscanf(line, "gpiobase+0x%x: 0x%x", &addr, &value) 213 ret.GPIO[uint16(addr)] = uint32(value) 214 case strings.HasPrefix(line, "pmbase"): 215 addr, value := 0, 0 216 fmt.Sscanf(line, "pmbase+0x%x: 0x%x", &addr, &value) 217 ret.PMBASE[uint16(addr)] = uint32(value) 218 case strings.HasPrefix(line, "============="): 219 paragraph = strings.Trim(line, "= ") 220 } 221 } 222 223 if err := scanner.Err(); err != nil { 224 log.Fatal(err) 225 } 226 return 227 } 228 229 func (l *LogDevReader) GetDMI() (ret DMIData) { 230 file, err := os.Open(l.InputDirectory + "/dmidecode.log") 231 if err != nil { 232 log.Fatal(err) 233 } 234 defer file.Close() 235 236 scanner := bufio.NewScanner(file) 237 paragraph := "" 238 for scanner.Scan() { 239 line := scanner.Text() 240 if !strings.HasPrefix(line, "\t") { 241 paragraph = strings.TrimSpace(line) 242 continue 243 } 244 idx := strings.Index(line, ":") 245 if idx < 0 { 246 continue 247 } 248 name := strings.TrimSpace(line[0:idx]) 249 value := strings.TrimSpace(line[idx+1:]) 250 switch paragraph + ":" + name { 251 case "System Information:Manufacturer": 252 ret.Vendor = value 253 case "System Information:Product Name": 254 ret.Model = value 255 case "System Information:Version": 256 ret.Version = value 257 case "Chassis Information:Type": 258 ret.IsLaptop = (value == "Notebook" || value == "Laptop") 259 } 260 } 261 262 if err := scanner.Err(); err != nil { 263 log.Fatal(err) 264 } 265 return 266 } 267 268 func (l *LogDevReader) GetAzaliaCodecs() (ret []AzaliaCodec) { 269 cardno := -1 270 for i := 0; i < 10; i++ { 271 pin, err := os.Open(l.InputDirectory + "/pin_hwC" + strconv.Itoa(i) + "D0") 272 if err == nil { 273 pin.Close() 274 cardno = i 275 break 276 } 277 } 278 if cardno == -1 { 279 return 280 } 281 for codecno := 0; codecno < 10; codecno++ { 282 cur := AzaliaCodec{CodecNo: codecno, PinConfig: map[int]uint32{}} 283 codec, err := os.Open(l.InputDirectory + "/codec#" + strconv.Itoa(codecno)) 284 if err != nil { 285 continue 286 } 287 defer codec.Close() 288 pin, err := os.Open(l.InputDirectory + "/pin_hwC" + strconv.Itoa(cardno) + 289 "D" + strconv.Itoa(codecno)) 290 if err != nil { 291 continue 292 } 293 defer pin.Close() 294 295 scanner := bufio.NewScanner(codec) 296 for scanner.Scan() { 297 line := scanner.Text() 298 if strings.HasPrefix(line, "Codec:") { 299 fmt.Sscanf(line, "Codec: %s", &cur.Name) 300 continue 301 } 302 if strings.HasPrefix(line, "Vendor Id:") { 303 fmt.Sscanf(line, "Vendor Id: 0x%x", &cur.VendorID) 304 continue 305 } 306 if strings.HasPrefix(line, "Subsystem Id:") { 307 fmt.Sscanf(line, "Subsystem Id: 0x%x", &cur.SubsystemID) 308 continue 309 } 310 } 311 312 scanner = bufio.NewScanner(pin) 313 for scanner.Scan() { 314 line := scanner.Text() 315 addr := 0 316 val := uint32(0) 317 fmt.Sscanf(line, "0x%x 0x%x", &addr, &val) 318 cur.PinConfig[addr] = val 319 } 320 ret = append(ret, cur) 321 } 322 return 323 } 324 325 func (l *LogDevReader) GetIOPorts() []IOPorts { 326 file, err := os.Open(l.InputDirectory + "/ioports.log") 327 if err != nil { 328 log.Fatal(err) 329 } 330 defer file.Close() 331 scanner := bufio.NewScanner(file) 332 ret := make([]IOPorts, 0, 100) 333 for scanner.Scan() { 334 line := scanner.Text() 335 el := IOPorts{} 336 fmt.Sscanf(line, " %x-%x : %s", &el.Start, &el.End, &el.Usage) 337 ret = append(ret, el) 338 } 339 340 if err := scanner.Err(); err != nil { 341 log.Fatal(err) 342 } 343 return ret 344 345 } 346 347 func (l *LogDevReader) GetCPUModel() (ret []uint32) { 348 file, err := os.Open(l.InputDirectory + "/cpuinfo.log") 349 if err != nil { 350 log.Fatal(err) 351 } 352 defer file.Close() 353 354 scanner := bufio.NewScanner(file) 355 ret = make([]uint32, 0, 100) 356 proc := 0 357 for scanner.Scan() { 358 line := scanner.Text() 359 sep := strings.Index(line, ":") 360 if sep < 0 { 361 continue 362 } 363 key := strings.TrimSpace(line[0:sep]) 364 val := strings.TrimSpace(line[sep+1:]) 365 366 if key == "processor" { 367 proc, _ := strconv.Atoi(val) 368 if len(ret) <= proc { 369 ret = ret[0 : proc+1] 370 } 371 continue 372 } 373 if key == "cpu family" { 374 family, _ := strconv.Atoi(val) 375 ret[proc] |= uint32(((family & 0xf) << 8) | ((family & 0xff0) << 16)) 376 } 377 if key == "model" { 378 model, _ := strconv.Atoi(val) 379 ret[proc] |= uint32(((model & 0xf) << 4) | ((model & 0xf0) << 12)) 380 } 381 if key == "stepping" { 382 stepping, _ := strconv.Atoi(val) 383 ret[proc] |= uint32(stepping & 0xf) 384 } 385 } 386 387 if err := scanner.Err(); err != nil { 388 log.Fatal(err) 389 } 390 return 391 } 392 393 func (l *LogDevReader) HasPS2() bool { 394 file, err := os.Open(l.InputDirectory + "/input_bustypes.log") 395 if err != nil { 396 log.Fatal(err) 397 } 398 defer file.Close() 399 scanner := bufio.NewScanner(file) 400 for scanner.Scan() { 401 line := scanner.Text() 402 if strings.Index(line, "0011") >= 0 { 403 return true 404 } 405 } 406 return false 407 } 408 409 var FlagLogInput = flag.String("input_log", ".", "Input log directory") 410 var FlagLogMkLogs = flag.Bool("make_logs", false, "Dump logs") 411 412 func MakeLogReader() *LogDevReader { 413 if *FlagLogMkLogs { 414 MakeLogs(*FlagLogInput) 415 } 416 return &LogDevReader{InputDirectory: *FlagLogInput} 417 }