lib/dump.c

   1 /*
   2  *      The PCI Library -- Reading of Bus Dumps
   3  *
   4  *      Copyright (c) 1997--2008 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #include <stdio.h>
  10 #include <ctype.h>
  11 #include <string.h>
  12 #include <errno.h>
  13
  14 #include "internal.h"
  15
  16 struct dump_data {
  17   int len, allocated;
  18   byte data[1];
  19 };
  20
  21 static void
  22 dump_config(struct pci_access *a)
  23 {
  24   pci_define_param(a, "dump.name", "", "Name of the bus dump file to read from");
  25 }
  26
  27 static int
  28 dump_detect(struct pci_access *a)
  29 {
  30   char *name = pci_get_param(a, "dump.name");
  31   return name && name[0];
  32 }
  33
  34 static void
  35 dump_alloc_data(struct pci_dev *dev, int len)
  36 {
  37   struct dump_data *dd = pci_malloc(dev->access, sizeof(struct dump_data) + len - 1);
  38   dd->allocated = len;
  39   dd->len = 0;
  40   memset(dd->data, 0xff, len);
  41   dev->aux = dd;
  42 }
  43
  44 static int
  45 dump_validate(char *s, char *fmt)
  46 {
  47   while (*fmt)
  48     {
  49       if (*fmt == '#' ? !isxdigit(*s) : *fmt != *s)
  50         return 0;
  51       fmt++, s++;
  52     }
  53   return 1;
  54 }
  55
  56 static void
  57 dump_init(struct pci_access *a)
  58 {
  59   char *name = pci_get_param(a, "dump.name");
  60   FILE *f;
  61   char buf[256];
  62   struct pci_dev *dev = NULL;
  63   int len, mn, bn, dn, fn, i, j;
  64
  65   if (!a)
  66     a->error("dump: File name not given.");
  67   if (!(f = fopen(name, "r")))
  68     a->error("dump: Cannot open %s: %s", name, strerror(errno));
  69   while (fgets(buf, sizeof(buf)-1, f))
  70     {
  71       char *z = strchr(buf, '\n');
  72       if (!z)
  73         a->error("dump: line too long or unterminated");
  74       *z-- = 0;
  75       if (z >= buf && *z == '\r')
  76         *z-- = 0;
  77       len = z - buf + 1;
  78       mn = 0;
  79       if (dump_validate(buf, "##:##.# ") && sscanf(buf, "%x:%x.%d", &bn, &dn, &fn) == 3 ||
  80           dump_validate(buf, "####:##:##.# ") && sscanf(buf, "%x:%x:%x.%d", &mn, &bn, &dn, &fn) == 4)
  81         {
  82           dev = pci_get_dev(a, mn, bn, dn, fn);
  83           dump_alloc_data(dev, 256);
  84           pci_link_dev(a, dev);
  85         }
  86       else if (!len)
  87         dev = NULL;
  88       else if (dev &&
  89                (dump_validate(buf, "##: ") || dump_validate(buf, "###: ")) &&
  90                sscanf(buf, "%x: ", &i) == 1)
  91         {
  92           struct dump_data *dd = dev->aux;
  93           z = strchr(buf, ' ') + 1;
  94           while (isxdigit(z[0]) && isxdigit(z[1]) && (!z[2] || z[2] == ' ') &&
  95                  sscanf(z, "%x", &j) == 1 && j < 256)
  96             {
  97               if (i >= 4096)
  98                 a->error("dump: At most 4096 bytes of config space are supported");
  99               if (i >= dd->allocated)   /* Need to re-allocate the buffer */
 100                 {
 101                   dump_alloc_data(dev, 4096);
 102                   memcpy(((struct dump_data *) dev->aux)->data, dd->data, 256);
 103                   pci_mfree(dd);
 104                   dd = dev->aux;
 105                 }
 106               dd->data[i++] = j;
 107               if (i > dd->len)
 108                 dd->len = i;
 109               z += 2;
 110               if (*z)
 111                 z++;
 112             }
 113           if (*z)
 114             a->error("dump: Malformed line");
 115         }
 116     }
 117 }
 118
 119 static void
 120 dump_cleanup(struct pci_access *a UNUSED)
 121 {
 122 }
 123
 124 static void
 125 dump_scan(struct pci_access *a UNUSED)
 126 {
 127 }
 128
 129 static int
 130 dump_read(struct pci_dev *d, int pos, byte *buf, int len)
 131 {
 132   struct dump_data *dd;
 133   if (!(dd = d->aux))
 134     {
 135       struct pci_dev *e = d->access->devices;
 136       while (e && (e->domain != d->domain || e->bus != d->bus || e->dev != d->dev || e->func != d->func))
 137         e = e->next;
 138       if (!e)
 139         return 0;
 140       dd = e->aux;
 141     }
 142   if (pos + len > dd->len)
 143     return 0;
 144   memcpy(buf, dd->data + pos, len);
 145   return 1;
 146 }
 147
 148 static int
 149 dump_write(struct pci_dev *d UNUSED, int pos UNUSED, byte *buf UNUSED, int len UNUSED)
 150 {
 151   d->access->error("Writing to dump files is not supported.");
 152   return 0;
 153 }
 154
 155 static void
 156 dump_cleanup_dev(struct pci_dev *d)
 157 {
 158   if (d->aux)
 159     {
 160       pci_mfree(d->aux);
 161       d->aux = NULL;
 162     }
 163 }
 164
 165 struct pci_methods pm_dump = {
 166   "dump",
 167   "Reading of register dumps (set the `dump.name' parameter)",
 168   dump_config,
 169   dump_detect,
 170   dump_init,
 171   dump_cleanup,
 172   dump_scan,
 173   pci_generic_fill_info,
 174   dump_read,
 175   dump_write,
 176   NULL,                                 /* init_dev */
 177   dump_cleanup_dev
 178 };