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