1 /* Simple code to turn various tables in an ELF file into alias definitions.
2 * This deals with kernel datastructures where they should be
3 * dealt with: in the kernel source.
5 * Copyright 2002-2003 Rusty Russell, IBM Corporation
6 * 2003 Kai Germaschewski
9 * This software may be used and distributed according to the terms
10 * of the GNU General Public License, incorporated herein by reference.
15 /* We use the ELF typedefs for kernel_ulong_t but bite the bullet and
16 * use either stdint.h or inttypes.h for the rest. */
17 #if KERNEL_ELFCLASS == ELFCLASS32
18 typedef Elf32_Addr kernel_ulong_t
;
19 #define BITS_PER_LONG 32
21 typedef Elf64_Addr kernel_ulong_t
;
22 #define BITS_PER_LONG 64
32 typedef uint32_t __u32
;
33 typedef uint16_t __u16
;
34 typedef unsigned char __u8
;
36 /* Big exception to the "don't include kernel headers into userspace, which
37 * even potentially has different endianness and word sizes, since
38 * we handle those differences explicitly below */
39 #include "../../include/linux/mod_devicetable.h"
41 #define ADD(str, sep, cond, field) \
45 sprintf(str + strlen(str), \
46 sizeof(field) == 1 ? "%02X" : \
47 sizeof(field) == 2 ? "%04X" : \
48 sizeof(field) == 4 ? "%08X" : "", \
51 sprintf(str + strlen(str), "*"); \
55 * Check that sizeof(device_id type) are consistent with size of section
56 * in .o file. If in-consistent then userspace and kernel does not agree
57 * on actual size which is a bug.
59 static void device_id_size_check(const char *modname
, const char *device_id
,
60 unsigned long size
, unsigned long id_size
)
62 if (size
% id_size
|| size
< id_size
) {
63 fatal("%s: sizeof(struct %s_device_id)=%lu is not a modulo "
64 "of the size of section __mod_%s_device_table=%lu.\n"
65 "Fix definition of struct %s_device_id "
66 "in mod_devicetable.h\n",
67 modname
, device_id
, id_size
, device_id
, size
, device_id
);
71 /* USB is special because the bcdDevice can be matched against a numeric range */
72 /* Looks like "usb:vNpNdNdcNdscNdpNicNiscNipNinN" */
73 static void do_usb_entry(struct usb_device_id
*id
,
74 unsigned int bcdDevice_initial
, int bcdDevice_initial_digits
,
75 unsigned char range_lo
, unsigned char range_hi
,
79 strcpy(alias
, "usb:");
80 ADD(alias
, "v", id
->match_flags
&USB_DEVICE_ID_MATCH_VENDOR
,
82 ADD(alias
, "p", id
->match_flags
&USB_DEVICE_ID_MATCH_PRODUCT
,
86 if (bcdDevice_initial_digits
)
87 sprintf(alias
+ strlen(alias
), "%0*X",
88 bcdDevice_initial_digits
, bcdDevice_initial
);
89 if (range_lo
== range_hi
)
90 sprintf(alias
+ strlen(alias
), "%u", range_lo
);
91 else if (range_lo
> 0 || range_hi
< 9)
92 sprintf(alias
+ strlen(alias
), "[%u-%u]", range_lo
, range_hi
);
93 if (bcdDevice_initial_digits
< (sizeof(id
->bcdDevice_lo
) * 2 - 1))
96 ADD(alias
, "dc", id
->match_flags
&USB_DEVICE_ID_MATCH_DEV_CLASS
,
99 id
->match_flags
&USB_DEVICE_ID_MATCH_DEV_SUBCLASS
,
100 id
->bDeviceSubClass
);
102 id
->match_flags
&USB_DEVICE_ID_MATCH_DEV_PROTOCOL
,
103 id
->bDeviceProtocol
);
105 id
->match_flags
&USB_DEVICE_ID_MATCH_INT_CLASS
,
106 id
->bInterfaceClass
);
108 id
->match_flags
&USB_DEVICE_ID_MATCH_INT_SUBCLASS
,
109 id
->bInterfaceSubClass
);
111 id
->match_flags
&USB_DEVICE_ID_MATCH_INT_PROTOCOL
,
112 id
->bInterfaceProtocol
);
114 id
->match_flags
&USB_DEVICE_ID_MATCH_INT_NUMBER
,
115 id
->bInterfaceNumber
);
117 /* Always end in a wildcard, for future extension */
118 if (alias
[strlen(alias
)-1] != '*')
120 buf_printf(&mod
->dev_table_buf
,
121 "MODULE_ALIAS(\"%s\");\n", alias
);
124 static void do_usb_entry_multi(struct usb_device_id
*id
, struct module
*mod
)
126 unsigned int devlo
, devhi
;
127 unsigned char chi
, clo
;
130 id
->match_flags
= TO_NATIVE(id
->match_flags
);
131 id
->idVendor
= TO_NATIVE(id
->idVendor
);
132 id
->idProduct
= TO_NATIVE(id
->idProduct
);
134 devlo
= id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_LO
?
135 TO_NATIVE(id
->bcdDevice_lo
) : 0x0U
;
136 devhi
= id
->match_flags
& USB_DEVICE_ID_MATCH_DEV_HI
?
137 TO_NATIVE(id
->bcdDevice_hi
) : ~0x0U
;
140 * Some modules (visor) have empty slots as placeholder for
141 * run-time specification that results in catch-all alias
143 if (!(id
->idVendor
| id
->idProduct
| id
->bDeviceClass
| id
->bInterfaceClass
))
146 /* Convert numeric bcdDevice range into fnmatch-able pattern(s) */
147 for (ndigits
= sizeof(id
->bcdDevice_lo
) * 2 - 1; devlo
<= devhi
; ndigits
--) {
150 if (chi
> 9) /* it's bcd not hex */
155 if (devlo
== devhi
|| !ndigits
) {
156 do_usb_entry(id
, devlo
, ndigits
, clo
, chi
, mod
);
161 do_usb_entry(id
, devlo
++, ndigits
, clo
, 9, mod
);
164 do_usb_entry(id
, devhi
--, ndigits
, 0, chi
, mod
);
168 static void do_usb_table(void *symval
, unsigned long size
,
172 const unsigned long id_size
= sizeof(struct usb_device_id
);
174 device_id_size_check(mod
->name
, "usb", size
, id_size
);
176 /* Leave last one: it's the terminator. */
179 for (i
= 0; i
< size
; i
+= id_size
)
180 do_usb_entry_multi(symval
+ i
, mod
);
183 /* Looks like: ieee1394:venNmoNspNverN */
184 static int do_ieee1394_entry(const char *filename
,
185 struct ieee1394_device_id
*id
, char *alias
)
187 id
->match_flags
= TO_NATIVE(id
->match_flags
);
188 id
->vendor_id
= TO_NATIVE(id
->vendor_id
);
189 id
->model_id
= TO_NATIVE(id
->model_id
);
190 id
->specifier_id
= TO_NATIVE(id
->specifier_id
);
191 id
->version
= TO_NATIVE(id
->version
);
193 strcpy(alias
, "ieee1394:");
194 ADD(alias
, "ven", id
->match_flags
& IEEE1394_MATCH_VENDOR_ID
,
196 ADD(alias
, "mo", id
->match_flags
& IEEE1394_MATCH_MODEL_ID
,
198 ADD(alias
, "sp", id
->match_flags
& IEEE1394_MATCH_SPECIFIER_ID
,
200 ADD(alias
, "ver", id
->match_flags
& IEEE1394_MATCH_VERSION
,
206 /* Looks like: pci:vNdNsvNsdNbcNscNiN. */
207 static int do_pci_entry(const char *filename
,
208 struct pci_device_id
*id
, char *alias
)
210 /* Class field can be divided into these three. */
211 unsigned char baseclass
, subclass
, interface
,
212 baseclass_mask
, subclass_mask
, interface_mask
;
214 id
->vendor
= TO_NATIVE(id
->vendor
);
215 id
->device
= TO_NATIVE(id
->device
);
216 id
->subvendor
= TO_NATIVE(id
->subvendor
);
217 id
->subdevice
= TO_NATIVE(id
->subdevice
);
218 id
->class = TO_NATIVE(id
->class);
219 id
->class_mask
= TO_NATIVE(id
->class_mask
);
221 strcpy(alias
, "pci:");
222 ADD(alias
, "v", id
->vendor
!= PCI_ANY_ID
, id
->vendor
);
223 ADD(alias
, "d", id
->device
!= PCI_ANY_ID
, id
->device
);
224 ADD(alias
, "sv", id
->subvendor
!= PCI_ANY_ID
, id
->subvendor
);
225 ADD(alias
, "sd", id
->subdevice
!= PCI_ANY_ID
, id
->subdevice
);
227 baseclass
= (id
->class) >> 16;
228 baseclass_mask
= (id
->class_mask
) >> 16;
229 subclass
= (id
->class) >> 8;
230 subclass_mask
= (id
->class_mask
) >> 8;
231 interface
= id
->class;
232 interface_mask
= id
->class_mask
;
234 if ((baseclass_mask
!= 0 && baseclass_mask
!= 0xFF)
235 || (subclass_mask
!= 0 && subclass_mask
!= 0xFF)
236 || (interface_mask
!= 0 && interface_mask
!= 0xFF)) {
237 warn("Can't handle masks in %s:%04X\n",
238 filename
, id
->class_mask
);
242 ADD(alias
, "bc", baseclass_mask
== 0xFF, baseclass
);
243 ADD(alias
, "sc", subclass_mask
== 0xFF, subclass
);
244 ADD(alias
, "i", interface_mask
== 0xFF, interface
);
248 /* looks like: "ccw:tNmNdtNdmN" */
249 static int do_ccw_entry(const char *filename
,
250 struct ccw_device_id
*id
, char *alias
)
252 id
->match_flags
= TO_NATIVE(id
->match_flags
);
253 id
->cu_type
= TO_NATIVE(id
->cu_type
);
254 id
->cu_model
= TO_NATIVE(id
->cu_model
);
255 id
->dev_type
= TO_NATIVE(id
->dev_type
);
256 id
->dev_model
= TO_NATIVE(id
->dev_model
);
258 strcpy(alias
, "ccw:");
259 ADD(alias
, "t", id
->match_flags
&CCW_DEVICE_ID_MATCH_CU_TYPE
,
261 ADD(alias
, "m", id
->match_flags
&CCW_DEVICE_ID_MATCH_CU_MODEL
,
263 ADD(alias
, "dt", id
->match_flags
&CCW_DEVICE_ID_MATCH_DEVICE_TYPE
,
265 ADD(alias
, "dm", id
->match_flags
&CCW_DEVICE_ID_MATCH_DEVICE_MODEL
,
270 /* looks like: "ap:tN" */
271 static int do_ap_entry(const char *filename
,
272 struct ap_device_id
*id
, char *alias
)
274 sprintf(alias
, "ap:t%02X", id
->dev_type
);
278 /* Looks like: "serio:tyNprNidNexN" */
279 static int do_serio_entry(const char *filename
,
280 struct serio_device_id
*id
, char *alias
)
282 id
->type
= TO_NATIVE(id
->type
);
283 id
->proto
= TO_NATIVE(id
->proto
);
284 id
->id
= TO_NATIVE(id
->id
);
285 id
->extra
= TO_NATIVE(id
->extra
);
287 strcpy(alias
, "serio:");
288 ADD(alias
, "ty", id
->type
!= SERIO_ANY
, id
->type
);
289 ADD(alias
, "pr", id
->proto
!= SERIO_ANY
, id
->proto
);
290 ADD(alias
, "id", id
->id
!= SERIO_ANY
, id
->id
);
291 ADD(alias
, "ex", id
->extra
!= SERIO_ANY
, id
->extra
);
296 /* looks like: "pnp:dD" */
297 static int do_pnp_entry(const char *filename
,
298 struct pnp_device_id
*id
, char *alias
)
300 sprintf(alias
, "pnp:d%s", id
->id
);
304 /* looks like: "pnp:cCdD..." */
305 static int do_pnp_card_entry(const char *filename
,
306 struct pnp_card_device_id
*id
, char *alias
)
310 sprintf(alias
, "pnp:c%s", id
->id
);
311 for (i
= 0; i
< PNP_MAX_DEVICES
; i
++) {
312 if (! *id
->devs
[i
].id
)
314 sprintf(alias
+ strlen(alias
), "d%s", id
->devs
[i
].id
);
319 /* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */
320 static int do_pcmcia_entry(const char *filename
,
321 struct pcmcia_device_id
*id
, char *alias
)
325 id
->match_flags
= TO_NATIVE(id
->match_flags
);
326 id
->manf_id
= TO_NATIVE(id
->manf_id
);
327 id
->card_id
= TO_NATIVE(id
->card_id
);
328 id
->func_id
= TO_NATIVE(id
->func_id
);
329 id
->function
= TO_NATIVE(id
->function
);
330 id
->device_no
= TO_NATIVE(id
->device_no
);
332 for (i
=0; i
<4; i
++) {
333 id
->prod_id_hash
[i
] = TO_NATIVE(id
->prod_id_hash
[i
]);
336 strcpy(alias
, "pcmcia:");
337 ADD(alias
, "m", id
->match_flags
& PCMCIA_DEV_ID_MATCH_MANF_ID
,
339 ADD(alias
, "c", id
->match_flags
& PCMCIA_DEV_ID_MATCH_CARD_ID
,
341 ADD(alias
, "f", id
->match_flags
& PCMCIA_DEV_ID_MATCH_FUNC_ID
,
343 ADD(alias
, "fn", id
->match_flags
& PCMCIA_DEV_ID_MATCH_FUNCTION
,
345 ADD(alias
, "pfn", id
->match_flags
& PCMCIA_DEV_ID_MATCH_DEVICE_NO
,
347 ADD(alias
, "pa", id
->match_flags
& PCMCIA_DEV_ID_MATCH_PROD_ID1
, id
->prod_id_hash
[0]);
348 ADD(alias
, "pb", id
->match_flags
& PCMCIA_DEV_ID_MATCH_PROD_ID2
, id
->prod_id_hash
[1]);
349 ADD(alias
, "pc", id
->match_flags
& PCMCIA_DEV_ID_MATCH_PROD_ID3
, id
->prod_id_hash
[2]);
350 ADD(alias
, "pd", id
->match_flags
& PCMCIA_DEV_ID_MATCH_PROD_ID4
, id
->prod_id_hash
[3]);
357 static int do_of_entry (const char *filename
, struct of_device_id
*of
, char *alias
)
361 len
= sprintf (alias
, "of:N%sT%s",
362 of
->name
[0] ? of
->name
: "*",
363 of
->type
[0] ? of
->type
: "*");
365 if (of
->compatible
[0])
366 sprintf (&alias
[len
], "%sC%s",
367 of
->type
[0] ? "*" : "",
370 /* Replace all whitespace with underscores */
371 for (tmp
= alias
; tmp
&& *tmp
; tmp
++)
378 static int do_vio_entry(const char *filename
, struct vio_device_id
*vio
,
383 sprintf(alias
, "vio:T%sS%s", vio
->type
[0] ? vio
->type
: "*",
384 vio
->compat
[0] ? vio
->compat
: "*");
386 /* Replace all whitespace with underscores */
387 for (tmp
= alias
; tmp
&& *tmp
; tmp
++)
394 static int do_i2c_entry(const char *filename
, struct i2c_device_id
*i2c
, char *alias
)
396 strcpy(alias
, "i2c:");
397 ADD(alias
, "id", 1, i2c
->id
);
401 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
403 static void do_input(char *alias
,
404 kernel_ulong_t
*arr
, unsigned int min
, unsigned int max
)
408 for (i
= min
; i
< max
; i
++)
409 if (arr
[i
/ BITS_PER_LONG
] & (1L << (i
%BITS_PER_LONG
)))
410 sprintf(alias
+ strlen(alias
), "%X,*", i
);
413 /* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */
414 static int do_input_entry(const char *filename
, struct input_device_id
*id
,
417 sprintf(alias
, "input:");
419 ADD(alias
, "b", id
->flags
& INPUT_DEVICE_ID_MATCH_BUS
, id
->bustype
);
420 ADD(alias
, "v", id
->flags
& INPUT_DEVICE_ID_MATCH_VENDOR
, id
->vendor
);
421 ADD(alias
, "p", id
->flags
& INPUT_DEVICE_ID_MATCH_PRODUCT
, id
->product
);
422 ADD(alias
, "e", id
->flags
& INPUT_DEVICE_ID_MATCH_VERSION
, id
->version
);
424 sprintf(alias
+ strlen(alias
), "-e*");
425 if (id
->flags
& INPUT_DEVICE_ID_MATCH_EVBIT
)
426 do_input(alias
, id
->evbit
, 0, INPUT_DEVICE_ID_EV_MAX
);
427 sprintf(alias
+ strlen(alias
), "k*");
428 if (id
->flags
& INPUT_DEVICE_ID_MATCH_KEYBIT
)
429 do_input(alias
, id
->keybit
,
430 INPUT_DEVICE_ID_KEY_MIN_INTERESTING
,
431 INPUT_DEVICE_ID_KEY_MAX
);
432 sprintf(alias
+ strlen(alias
), "r*");
433 if (id
->flags
& INPUT_DEVICE_ID_MATCH_RELBIT
)
434 do_input(alias
, id
->relbit
, 0, INPUT_DEVICE_ID_REL_MAX
);
435 sprintf(alias
+ strlen(alias
), "a*");
436 if (id
->flags
& INPUT_DEVICE_ID_MATCH_ABSBIT
)
437 do_input(alias
, id
->absbit
, 0, INPUT_DEVICE_ID_ABS_MAX
);
438 sprintf(alias
+ strlen(alias
), "m*");
439 if (id
->flags
& INPUT_DEVICE_ID_MATCH_MSCIT
)
440 do_input(alias
, id
->mscbit
, 0, INPUT_DEVICE_ID_MSC_MAX
);
441 sprintf(alias
+ strlen(alias
), "l*");
442 if (id
->flags
& INPUT_DEVICE_ID_MATCH_LEDBIT
)
443 do_input(alias
, id
->ledbit
, 0, INPUT_DEVICE_ID_LED_MAX
);
444 sprintf(alias
+ strlen(alias
), "s*");
445 if (id
->flags
& INPUT_DEVICE_ID_MATCH_SNDBIT
)
446 do_input(alias
, id
->sndbit
, 0, INPUT_DEVICE_ID_SND_MAX
);
447 sprintf(alias
+ strlen(alias
), "f*");
448 if (id
->flags
& INPUT_DEVICE_ID_MATCH_FFBIT
)
449 do_input(alias
, id
->ffbit
, 0, INPUT_DEVICE_ID_FF_MAX
);
450 sprintf(alias
+ strlen(alias
), "w*");
451 if (id
->flags
& INPUT_DEVICE_ID_MATCH_SWBIT
)
452 do_input(alias
, id
->swbit
, 0, INPUT_DEVICE_ID_SW_MAX
);
456 static int do_eisa_entry(const char *filename
, struct eisa_device_id
*eisa
,
460 sprintf(alias
, EISA_DEVICE_MODALIAS_FMT
"*", eisa
->sig
);
464 /* Looks like: parisc:tNhvNrevNsvN */
465 static int do_parisc_entry(const char *filename
, struct parisc_device_id
*id
,
468 id
->hw_type
= TO_NATIVE(id
->hw_type
);
469 id
->hversion
= TO_NATIVE(id
->hversion
);
470 id
->hversion_rev
= TO_NATIVE(id
->hversion_rev
);
471 id
->sversion
= TO_NATIVE(id
->sversion
);
473 strcpy(alias
, "parisc:");
474 ADD(alias
, "t", id
->hw_type
!= PA_HWTYPE_ANY_ID
, id
->hw_type
);
475 ADD(alias
, "hv", id
->hversion
!= PA_HVERSION_ANY_ID
, id
->hversion
);
476 ADD(alias
, "rev", id
->hversion_rev
!= PA_HVERSION_REV_ANY_ID
, id
->hversion_rev
);
477 ADD(alias
, "sv", id
->sversion
!= PA_SVERSION_ANY_ID
, id
->sversion
);
482 /* Ignore any prefix, eg. v850 prepends _ */
483 static inline int sym_is(const char *symbol
, const char *name
)
487 match
= strstr(symbol
, name
);
490 return match
[strlen(symbol
)] == '\0';
493 static void do_table(void *symval
, unsigned long size
,
494 unsigned long id_size
,
495 const char *device_id
,
501 int (*do_entry
)(const char *, void *entry
, char *alias
) = function
;
503 device_id_size_check(mod
->name
, device_id
, size
, id_size
);
504 /* Leave last one: it's the terminator. */
507 for (i
= 0; i
< size
; i
+= id_size
) {
508 if (do_entry(mod
->name
, symval
+i
, alias
)) {
509 /* Always end in a wildcard, for future extension */
510 if (alias
[strlen(alias
)-1] != '*')
512 buf_printf(&mod
->dev_table_buf
,
513 "MODULE_ALIAS(\"%s\");\n", alias
);
518 /* Create MODULE_ALIAS() statements.
519 * At this time, we cannot write the actual output C source yet,
520 * so we write into the mod->dev_table_buf buffer. */
521 void handle_moddevtable(struct module
*mod
, struct elf_info
*info
,
522 Elf_Sym
*sym
, const char *symname
)
526 /* We're looking for a section relative symbol */
527 if (!sym
->st_shndx
|| sym
->st_shndx
>= info
->hdr
->e_shnum
)
530 symval
= (void *)info
->hdr
531 + info
->sechdrs
[sym
->st_shndx
].sh_offset
534 if (sym_is(symname
, "__mod_pci_device_table"))
535 do_table(symval
, sym
->st_size
,
536 sizeof(struct pci_device_id
), "pci",
538 else if (sym_is(symname
, "__mod_usb_device_table"))
539 /* special case to handle bcdDevice ranges */
540 do_usb_table(symval
, sym
->st_size
, mod
);
541 else if (sym_is(symname
, "__mod_ieee1394_device_table"))
542 do_table(symval
, sym
->st_size
,
543 sizeof(struct ieee1394_device_id
), "ieee1394",
544 do_ieee1394_entry
, mod
);
545 else if (sym_is(symname
, "__mod_ccw_device_table"))
546 do_table(symval
, sym
->st_size
,
547 sizeof(struct ccw_device_id
), "ccw",
549 else if (sym_is(symname
, "__mod_ap_device_table"))
550 do_table(symval
, sym
->st_size
,
551 sizeof(struct ap_device_id
), "ap",
553 else if (sym_is(symname
, "__mod_serio_device_table"))
554 do_table(symval
, sym
->st_size
,
555 sizeof(struct serio_device_id
), "serio",
556 do_serio_entry
, mod
);
557 else if (sym_is(symname
, "__mod_pnp_device_table"))
558 do_table(symval
, sym
->st_size
,
559 sizeof(struct pnp_device_id
), "pnp",
561 else if (sym_is(symname
, "__mod_pnp_card_device_table"))
562 do_table(symval
, sym
->st_size
,
563 sizeof(struct pnp_card_device_id
), "pnp_card",
564 do_pnp_card_entry
, mod
);
565 else if (sym_is(symname
, "__mod_pcmcia_device_table"))
566 do_table(symval
, sym
->st_size
,
567 sizeof(struct pcmcia_device_id
), "pcmcia",
568 do_pcmcia_entry
, mod
);
569 else if (sym_is(symname
, "__mod_of_device_table"))
570 do_table(symval
, sym
->st_size
,
571 sizeof(struct of_device_id
), "of",
573 else if (sym_is(symname
, "__mod_vio_device_table"))
574 do_table(symval
, sym
->st_size
,
575 sizeof(struct vio_device_id
), "vio",
577 else if (sym_is(symname
, "__mod_i2c_device_table"))
578 do_table(symval
, sym
->st_size
,
579 sizeof(struct i2c_device_id
), "i2c",
581 else if (sym_is(symname
, "__mod_input_device_table"))
582 do_table(symval
, sym
->st_size
,
583 sizeof(struct input_device_id
), "input",
584 do_input_entry
, mod
);
585 else if (sym_is(symname
, "__mod_eisa_device_table"))
586 do_table(symval
, sym
->st_size
,
587 sizeof(struct eisa_device_id
), "eisa",
589 else if (sym_is(symname
, "__mod_parisc_device_table"))
590 do_table(symval
, sym
->st_size
,
591 sizeof(struct parisc_device_id
), "parisc",
592 do_parisc_entry
, mod
);
595 /* Now add out buffered information to the generated C source */
596 void add_moddevtable(struct buffer
*buf
, struct module
*mod
)
598 buf_printf(buf
, "\n");
599 buf_write(buf
, mod
->dev_table_buf
.p
, mod
->dev_table_buf
.pos
);
600 free(mod
->dev_table_buf
.p
);