]> mj.ucw.cz Git - pciutils.git/blob - ls-kernel.c
Merge branch 'fill-info'
[pciutils.git] / ls-kernel.c
1 /*
2  *      The PCI Utilities -- Show Kernel Drivers
3  *
4  *      Copyright (c) 1997--2013 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 <string.h>
11
12 #include "lspci.h"
13
14 #ifdef PCI_OS_LINUX
15
16 #include <sys/utsname.h>
17
18 #ifdef PCI_USE_LIBKMOD
19
20 #include <libkmod.h>
21
22 static struct kmod_ctx *kmod_ctx;
23
24 static int
25 show_kernel_init(void)
26 {
27   static int show_kernel_inited = -1;
28   if (show_kernel_inited >= 0)
29     return show_kernel_inited;
30
31   kmod_ctx = kmod_new(NULL, NULL);
32   if (!kmod_ctx)
33     {
34       fprintf(stderr, "lspci: Unable to initialize libkmod context\n");
35       goto failed;
36     }
37
38   int err;
39   if ((err = kmod_load_resources(kmod_ctx)) < 0)
40     {
41       fprintf(stderr, "lspci: Unable to load libkmod resources: error %d\n", err);
42       goto failed;
43     }
44
45   show_kernel_inited = 1;
46   return 1;
47
48 failed:
49   show_kernel_inited = 0;
50   return 0;
51 }
52
53 void
54 show_kernel_cleanup(void)
55 {
56   if (kmod_ctx)
57     kmod_unref(kmod_ctx);
58 }
59
60 static const char *next_module(struct device *d)
61 {
62   static struct kmod_list *klist, *kcurrent;
63   static struct kmod_module *kmodule;
64
65   if (kmodule)
66     {
67       kmod_module_unref(kmodule);
68       kmodule = NULL;
69     }
70
71   if (!klist)
72     {
73       pci_fill_info(d->dev, PCI_FILL_MODULE_ALIAS);
74       if (!d->dev->module_alias)
75         return NULL;
76       int err = kmod_module_new_from_lookup(kmod_ctx, d->dev->module_alias, &klist);
77       if (err < 0)
78         {
79           fprintf(stderr, "lspci: libkmod lookup failed: error %d\n", err);
80           return NULL;
81         }
82       kcurrent = klist;
83     }
84   else
85     kcurrent = kmod_list_next(klist, kcurrent);
86
87   if (kcurrent)
88     {
89       kmodule = kmod_module_get_module(kcurrent);
90       return kmod_module_get_name(kmodule);
91     }
92
93   kmod_module_unref_list(klist);
94   klist = NULL;
95   return NULL;
96 }
97
98 #else
99
100 struct pcimap_entry {
101   struct pcimap_entry *next;
102   unsigned int vendor, device;
103   unsigned int subvendor, subdevice;
104   unsigned int class, class_mask;
105   char module[1];
106 };
107
108 static struct pcimap_entry *pcimap_head;
109
110 static int
111 show_kernel_init(void)
112 {
113   static int tried_pcimap;
114   struct utsname uts;
115   char *name, line[1024];
116   FILE *f;
117
118   if (tried_pcimap)
119     return 1;
120   tried_pcimap = 1;
121
122   if (name = opt_pcimap)
123     {
124       f = fopen(name, "r");
125       if (!f)
126         die("Cannot open pcimap file %s: %m", name);
127     }
128   else
129     {
130       if (uname(&uts) < 0)
131         die("uname() failed: %m");
132       name = alloca(64 + strlen(uts.release));
133       sprintf(name, "/lib/modules/%s/modules.pcimap", uts.release);
134       f = fopen(name, "r");
135       if (!f)
136         return 1;
137     }
138
139   while (fgets(line, sizeof(line), f))
140     {
141       char *c = strchr(line, '\n');
142       struct pcimap_entry *e;
143
144       if (!c)
145         die("Unterminated or too long line in %s", name);
146       *c = 0;
147       if (!line[0] || line[0] == '#')
148         continue;
149
150       c = line;
151       while (*c && *c != ' ' && *c != '\t')
152         c++;
153       if (!*c)
154         continue;       /* FIXME: Emit warnings! */
155       *c++ = 0;
156
157       e = xmalloc(sizeof(*e) + strlen(line));
158       if (sscanf(c, "%i%i%i%i%i%i",
159                  &e->vendor, &e->device,
160                  &e->subvendor, &e->subdevice,
161                  &e->class, &e->class_mask) != 6)
162         continue;
163       e->next = pcimap_head;
164       pcimap_head = e;
165       strcpy(e->module, line);
166     }
167   fclose(f);
168
169   return 1;
170 }
171
172 static int
173 match_pcimap(struct device *d, struct pcimap_entry *e)
174 {
175   struct pci_dev *dev = d->dev;
176   unsigned int class = get_conf_long(d, PCI_REVISION_ID) >> 8;
177   word subv, subd;
178
179 #define MATCH(x, y) ((y) > 0xffff || (x) == (y))
180   get_subid(d, &subv, &subd);
181   return
182     MATCH(dev->vendor_id, e->vendor) &&
183     MATCH(dev->device_id, e->device) &&
184     MATCH(subv, e->subvendor) &&
185     MATCH(subd, e->subdevice) &&
186     (class & e->class_mask) == e->class;
187 #undef MATCH
188 }
189
190 static const char *next_module(struct device *d)
191 {
192   static struct pcimap_entry *current;
193
194   if (!current)
195     current = pcimap_head;
196   else
197     current = current->next;
198
199   while (current)
200     {
201       if (match_pcimap(d, current))
202         return current->module;
203       current = current->next;
204     }
205
206   return NULL;
207 }
208
209 void
210 show_kernel_cleanup(void)
211 {
212 }
213
214 #endif
215
216 #define DRIVER_BUF_SIZE 1024
217
218 static char *
219 find_driver(struct device *d, char *buf)
220 {
221   struct pci_dev *dev = d->dev;
222   char name[1024], *drv, *base;
223   int n;
224
225   if (dev->access->method != PCI_ACCESS_SYS_BUS_PCI)
226     return NULL;
227
228   base = pci_get_param(dev->access, "sysfs.path");
229   if (!base || !base[0])
230     return NULL;
231
232   n = snprintf(name, sizeof(name), "%s/devices/%04x:%02x:%02x.%d/driver",
233                base, dev->domain, dev->bus, dev->dev, dev->func);
234   if (n < 0 || n >= (int)sizeof(name))
235     die("show_driver: sysfs device name too long, why?");
236
237   n = readlink(name, buf, DRIVER_BUF_SIZE);
238   if (n < 0)
239     return NULL;
240   if (n >= DRIVER_BUF_SIZE)
241     return "<name-too-long>";
242   buf[n] = 0;
243
244   if (drv = strrchr(buf, '/'))
245     return drv+1;
246   else
247     return buf;
248 }
249
250 static const char *
251 next_module_filtered(struct device *d)
252 {
253   static char prev_module[256];
254   const char *module;
255
256   while (module = next_module(d))
257     {
258       if (strcmp(module, prev_module))
259         {
260           strncpy(prev_module, module, sizeof(prev_module));
261           prev_module[sizeof(prev_module) - 1] = 0;
262           return module;
263         }
264     }
265   prev_module[0] = 0;
266   return NULL;
267 }
268
269 void
270 show_kernel(struct device *d)
271 {
272   char buf[DRIVER_BUF_SIZE];
273   const char *driver, *module;
274
275   if (driver = find_driver(d, buf))
276     printf("\tKernel driver in use: %s\n", driver);
277
278   if (!show_kernel_init())
279     return;
280
281   int cnt = 0;
282   while (module = next_module_filtered(d))
283     printf("%s %s", (cnt++ ? "," : "\tKernel modules:"), module);
284   if (cnt)
285     putchar('\n');
286 }
287
288 void
289 show_kernel_machine(struct device *d)
290 {
291   char buf[DRIVER_BUF_SIZE];
292   const char *driver, *module;
293
294   if (driver = find_driver(d, buf))
295     printf("Driver:\t%s\n", driver);
296
297   if (!show_kernel_init())
298     return;
299
300   while (module = next_module_filtered(d))
301     printf("Module:\t%s\n", module);
302 }
303
304 #else
305
306 void
307 show_kernel(struct device *d UNUSED)
308 {
309 }
310
311 void
312 show_kernel_machine(struct device *d UNUSED)
313 {
314 }
315
316 void
317 show_kernel_cleanup(void)
318 {
319 }
320
321 #endif
322