util/autoport/log_maker.go

   1 package main
   2
   3 import (
   4         "errors"
   5         "fmt"
   6         "io"
   7         "io/ioutil"
   8         "log"
   9         "os"
  10         "os/exec"
  11         "strings"
  12 )
  13
  14 func TryRunAndSave(output string, name string, arg []string) error {
  15         cmd := exec.Command(name, arg...)
  16
  17         f, err := os.Create(output)
  18         if err != nil {
  19                 log.Fatal(err)
  20         }
  21
  22         cmd.Stdout = f
  23         cmd.Stderr = f
  24
  25         err = cmd.Start()
  26         if err != nil {
  27                 return err
  28         }
  29         cmd.Wait()
  30         return nil
  31 }
  32
  33 func RunAndSave(output string, name string, arg ...string) {
  34         err := TryRunAndSave(output, name, arg)
  35         if err == nil {
  36                 return
  37         }
  38         idx := strings.LastIndex(name, "/")
  39         relname := name
  40         if idx >= 0 {
  41                 relname = name[idx+1:]
  42         }
  43         relname = "./" + relname
  44         err = TryRunAndSave(output, relname, arg)
  45         if err != nil {
  46                 log.Fatal(err)
  47         }
  48 }
  49
  50 const MAXPROMPTRETRY = 3
  51
  52 func PromptUser(prompt string, opts []string) (match string, err error) {
  53         for i := 1; i < MAXPROMPTRETRY; i++ {
  54                 fmt.Printf("%s. (%s) Default:%s\n", prompt,
  55                            strings.Join(opts, "/"), opts[0])
  56                 var usrInput string
  57                 fmt.Scanln(&usrInput)
  58
  59                 // Check for default entry
  60                 if usrInput == "" {
  61                         match = opts[0]
  62                         return
  63                 }
  64
  65                 for _, opt := range opts {
  66                         if opt == usrInput {
  67                                 match = opt
  68                                 return
  69                         }
  70                 }
  71         }
  72         err = errors.New("max retries exceeded")
  73         fmt.Fprintln(os.Stderr, "ERROR: max retries exceeded")
  74         return
  75 }
  76
  77 func MakeLogs(outDir string) {
  78         os.MkdirAll(outDir, 0700)
  79         RunAndSave(outDir+"/lspci.log", "lspci", "-nnvvvxxxx")
  80         RunAndSave(outDir+"/dmidecode.log", "dmidecode")
  81         RunAndSave(outDir+"/acpidump.log", "acpidump")
  82
  83         inteltoolArgs := "-a"
  84         opt, err := PromptUser("WARNING: The following tool MAY cause your system to hang when it attempts "+
  85                 "to probe for graphics registers.  Having the graphics registers will help create a better port. "+
  86                 "Should autoport probe these registers?",
  87                 []string{"y", "yes", "n", "no"})
  88
  89         // Continue even if there is an error
  90
  91         switch opt {
  92         case "y", "yes":
  93                 inteltoolArgs += "f"
  94         }
  95
  96         RunAndSave(outDir+"/inteltool.log", "../inteltool/inteltool", inteltoolArgs)
  97         RunAndSave(outDir+"/ectool.log", "../ectool/ectool", "-pd")
  98         RunAndSave(outDir+"/superiotool.log", "../superiotool/superiotool", "-ade")
  99
 100         SysDir := "/sys/class/sound/card0/"
 101         files, _ := ioutil.ReadDir(SysDir)
 102         for _, f := range files {
 103                 if (strings.HasPrefix(f.Name(), "hw") || strings.HasPrefix(f.Name(), "hdaudio")) && f.IsDir() {
 104                         in, err := os.Open(SysDir + f.Name() + "/init_pin_configs")
 105                         defer in.Close()
 106                         if err != nil {
 107                                 log.Fatal(err)
 108                         }
 109                         out, err := os.Create(outDir + "/pin_" + strings.Replace(f.Name(), "hdaudio", "hw", -1))
 110                         if err != nil {
 111                                 log.Fatal(err)
 112                         }
 113                         defer out.Close()
 114                         io.Copy(out, in)
 115                 }
 116         }
 117
 118         ProcDir := "/proc/asound/card0/"
 119         files, _ = ioutil.ReadDir(ProcDir)
 120         for _, f := range files {
 121                 if strings.HasPrefix(f.Name(), "codec#") && !f.IsDir() {
 122                         in, err := os.Open(ProcDir + f.Name())
 123                         defer in.Close()
 124                         if err != nil {
 125                                 log.Fatal(err)
 126                         }
 127                         out, err := os.Create(outDir + "/" + f.Name())
 128                         if err != nil {
 129                                 log.Fatal(err)
 130                         }
 131                         defer out.Close()
 132                         io.Copy(out, in)
 133                 }
 134         }
 135
 136         for _, fname := range []string{"cpuinfo", "ioports"} {
 137                 in, err := os.Open("/proc/" + fname)
 138                 defer in.Close()
 139                 if err != nil {
 140                         log.Fatal(err)
 141                 }
 142                 out, err := os.Create(outDir + "/" + fname + ".log")
 143                 if err != nil {
 144                         log.Fatal(err)
 145                 }
 146                 defer out.Close()
 147                 io.Copy(out, in)
 148         }
 149
 150         out, err := os.Create(outDir + "/input_bustypes.log")
 151         if err != nil {
 152                 log.Fatal(err)
 153         }
 154         defer out.Close()
 155
 156         ClassInputDir := "/sys/class/input/"
 157         files, _ = ioutil.ReadDir(ClassInputDir)
 158         for _, f := range files {
 159                 if strings.HasPrefix(f.Name(), "input") && !f.Mode().IsRegular() { /* Allow both dirs and symlinks.  */
 160                         in, err := os.Open(ClassInputDir + f.Name() + "/id/bustype")
 161                         defer in.Close()
 162                         if err != nil {
 163                                 log.Fatal(err)
 164                         }
 165                         io.Copy(out, in)
 166                 }
 167         }
 168 }