- use a valid node_id
[bootmanager.git] / source / merge_hw_tables.py
1 #!/usr/bin/env python
2
3 """
4 The point of this small utility is to take a file in the format
5 of /lib/modules/`uname -r`/modules.pcimap and /usr/share/hwdata/pcitable
6 and output a condensed, more easily used format for module detection. This is
7 done by first getting a list of all the built modules, then loading the
8 pci ids for each of those modules from modules.pcimap, then finally merging
9 in the contents of pcitable (for built modules only). The result should be
10 a file with a pretty comprehensive mapping of pci ids to module names.
11
12 The output is used by the PlanetLab boot cd (3.0+) and the pl_hwinit script
13 to load all the applicable modules by scanning lspci output.
14
15
16
17 Expected format of file modules.dep includes lines of:
18
19 /full/module/path/mod.ko: <dependencies>
20
21 Expected format of file modules.pcimap includes lines of:
22
23 # pci_module vendor device subvendor subdevice class class_mask driver_data
24 cciss 0x00000e11 0x0000b060 0x00000e11 0x00004070 0x00000000 0x00000000 0x0
25 cciss 0x00000e11 0x0000b178 0x00000e11 0x00004070 0x00000000 0x00000000 0x0
26
27 Expected format of file pcitable includes lines of:
28
29 # ("%d\t%d\t%s\t"%s"\n", vendid, devid, moduleName, cardDescription)
30 # or ("%d\t%d\t%d\t%d\t%s\t"%s"\n", vendid, devid, subvendid, subdevid, moduleNa
31 # me, cardDescription)
32 0x0e11  0x0508  "tmspci"        "Compaq|Netelligent 4/16 Token Ring"
33 0x1000  0x0407  0x8086  0x0532  "megaraid"      "Storage RAID Controller SRCU42X"
34
35 Lines listing a module name of ignore or unknown from pcitable are skipped
36
37
38
39 Output format, for each line that matches the above lines:
40 cciss 0e11:b060 0e11:b178
41
42 """
43
44 import os, sys
45 import string
46
47
48
49 class merge_hw_tables:
50     
51     def merge_files(self, modules_dep_path, modules_pcimap_path, pcitable_path):
52         """
53         merge the three files as described above, and return a dictionary.
54         keys are module names, value is a list of pci ids for that module,
55         in the form "0e11:b178"
56         """
57
58         try:
59             modulesdep_file= file(modules_dep_path,"r")
60         except IOError:
61             sys.stderr.write( "Unable to open modules.dep: %s\n" %
62                               modules_dep_path )
63             return
64
65         try:
66             pcimap_file= file(modules_pcimap_path,"r")
67         except IOError:
68             sys.stderr.write( "Unable to open modules.pcimap: %s\n" %
69                               modules_pcimap_path )
70             return
71
72         try:
73             pcitable_file= file(pcitable_path,"r")
74         except IOError:
75             sys.stderr.write( "Unable to open pcitable: %s\n" %
76                               pcitable_path )
77             return
78
79
80         # associative array to store all matches of module -> ['vendor:device',..]
81         # entries
82         all_modules= {}
83
84
85         # first step, create an associative array of all the built modules
86         for line in modulesdep_file:
87             parts= string.split(line,":")
88             if len(parts) < 2:
89                 continue
90
91             full_mod_path= parts[0]
92             parts= string.split(full_mod_path,"/")
93             module_name= parts[len(parts)-1]
94             module_name_len= len(module_name)
95             if module_name[module_name_len-3:] == ".ko":
96                 all_modules[module_name[:-3]]= []
97
98
99         # now, parse the pcimap and add devices
100         line_num= 0
101         for line in pcimap_file:
102             line_num= line_num+1
103             
104             # skip blank lines, or lines that begin with # (comments)
105             line= string.strip(line)
106             if len(line) == 0:
107                 continue
108
109             if line[0] == "#":
110                 continue
111
112             line_parts= string.split(line)
113             if line_parts is None or len(line_parts) != 8:
114                 sys.stderr.write( "Skipping line %d in pcimap " \
115                                   "(incorrect format)\n" % line_num )
116                 continue
117
118             # first two parts are always vendor / device id
119             module= line_parts[0]
120             vendor_id= line_parts[1]
121             device_id= line_parts[2]
122
123
124             # valid vendor and devices are 10 chars (0xXXXXXXXX) and begin with 0x
125             if len(vendor_id) != 10 or len(device_id) != 10:
126                 sys.stderr.write( "Skipping line %d in pcimap " \
127                                   "(invalid vendor/device id length)\n" %
128                                   line_num )
129                 continue
130             
131             if string.lower(vendor_id[:2]) != "0x" \
132                    or string.lower(device_id[:2]) != "0x":
133                 sys.stderr.write( "Skipping line %d in pcimap " \
134                                   "(invalid vendor/device id format)\n" % line_num )
135                 continue
136
137             # cut down the ids, only need last 4 bytes
138             # start at 6 = (10 total chars - 4 last chars need)
139             vendor_id= string.lower(vendor_id[6:])
140             device_id= string.lower(device_id[6:])
141             
142             full_id= "%s:%s" % (vendor_id, device_id)
143             
144             if all_modules.has_key(module):
145                 if full_id not in all_modules[module]:
146                     all_modules[module].append( full_id )
147             else:
148                 # normally shouldn't get here, as the list is
149                 # prepopulated with all the built modules
150                 all_modules[module]= [full_id,]
151
152
153         # parse pcitable, add any more ids for the devices
154         line_num= 0
155         for line in pcitable_file:
156             line_num= line_num+1
157             
158             # skip blank lines, or lines that begin with # (comments)
159             line= string.strip(line)
160             if len(line) == 0:
161                 continue
162
163             if line[0] == "#":
164                 continue
165
166             line_parts= string.split(line)
167             if line_parts is None or len(line_parts) <= 2:
168                 sys.stderr.write( "Skipping line %d in pcitable " \
169                                   "(incorrect format 1)\n" % line_num )
170                 continue
171
172             # vendor id is always the first field, device the second. also,
173             # strip off first two chars (the 0x)
174             vendor_id= string.lower(line_parts[0][2:])
175             device_id= string.lower(line_parts[1][2:])
176             
177             full_id= "%s:%s" % (vendor_id, device_id)
178             
179             # if the first char of the third field is a double
180             # quote, the third field is a module, else if the first
181             # char of the third field is a 0 (zero), the fifth field is
182             # the module name. it would nice if there was any easy way
183             # to split a string on spaces, but recognize quoted strings,
184             # so they wouldn't be split up. that is the reason for this wierd check
185             if line_parts[2][0] == '"':
186                 module= line_parts[2]
187             elif line_parts[2][0] == '0':
188                 try:
189                     module= line_parts[4]
190                 except ValueError, e:
191                     sys.stderr.write( "Skipping line %d in pcitable " \
192                                       "(incorrect format 2)\n" % line_num )
193                     continue
194             else:
195                 sys.stderr.write( "Skipping line %d in pcitable " \
196                                   "(incorrect format 3)\n" % line_num )
197                 continue
198
199             # remove the first and last char of module (quote marks)
200             module= module[1:]
201             module= module[:len(module)-1]
202             
203             # now add it if we don't already have this module -> id mapping
204             if all_modules.has_key(module):
205                 if full_id not in all_modules[module]:
206                     all_modules[module].append( full_id )
207             else:
208                 # don't add any modules from pcitable that we don't
209                 # already know about
210                 pass
211
212         pcitable_file.close()
213         pcimap_file.close()
214         modulesdep_file.close()
215
216         return all_modules
217     
218
219
220 if __name__ == "__main__":
221     def usage():
222         print( "\nUsage:" )
223         print( "rewrite-pcitable.py <modules.dep> <modules.pcimap> " \
224                "<pcitable> [<output>]" )
225         print( "" )
226
227         
228     if len(sys.argv) < 4:
229         usage()
230         sys.exit(1)
231
232
233     if len(sys.argv) > 4:
234         output_file_name= sys.argv[4]
235         try:
236             output_file= file(output_file_name,"w")
237         except IOError:
238             sys.stderr.write( "Unable to open %s for writing.\n" % output_file )
239             sys.exit(1)
240     else:
241         output_file= sys.stdout
242
243
244     all_modules= merge_hw_tables().merge_files( sys.argv[1], sys.argv[2],
245                                                 sys.argv[3] )
246
247     if all_modules is not None:
248         for module in all_modules.keys():
249             devices= all_modules[module]
250             if len(devices) > 0:
251                 devices_str= string.join( all_modules[module], " " )
252                 output_file.write( "%s %s\n" % (module,devices_str) )
253     else:
254         sys.stderr.write( "Unable to list modules.\n" )
255
256     output_file.close()