This commit was manufactured by cvs2svn to create branch
[bootmanager.git] / source / systeminfo.py
1 #!/usr/bin/python2
2
3 # --------------
4 # THIS file used to be named 'blockdevicescan.py', but has been renamed
5 # systeminfo.py and made more generic (now includes info about memory,
6 # and other hardware info on the machine)
7 # --------------
8
9 # Copyright (c) 2003 Intel Corporation
10 # All rights reserved.
11
12 # Redistribution and use in source and binary forms, with or without
13 # modification, are permitted provided that the following conditions are
14 # met:
15
16 #     * Redistributions of source code must retain the above copyright
17 #       notice, this list of conditions and the following disclaimer.
18
19 #     * Redistributions in binary form must reproduce the above
20 #       copyright notice, this list of conditions and the following
21 #       disclaimer in the documentation and/or other materials provided
22 #       with the distribution.
23
24 #     * Neither the name of the Intel Corporation nor the names of its
25 #       contributors may be used to endorse or promote products derived
26 #       from this software without specific prior written permission.
27
28 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
32 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
33 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
34 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
35 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
36 # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
37 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
38 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39
40 # EXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF
41 # YOUR JURISDICTION. It is licensee's responsibility to comply with any
42 # export regulations applicable in licensee's jurisdiction. Under
43 # CURRENT (May 2000) U.S. export regulations this software is eligible
44 # for export from the U.S. and can be downloaded by or otherwise
45 # exported or reexported worldwide EXCEPT to U.S. embargoed destinations
46 # which include Cuba, Iraq, Libya, North Korea, Iran, Syria, Sudan,
47 # Afghanistan and any other country to which the U.S. has embargoed
48 # goods and services.
49
50
51 # expected /proc/partitions format
52 #
53 #----------------------------------------------------
54 #major minor  #blocks  name
55 #
56 #3     0   40017915 hda
57 #3     1     208813 hda1
58 #3     2   20482875 hda2
59 #3     3     522112 hda3
60 #3     4   18804082 hda4
61 #----------------------------------------------------
62
63
64 import string
65 import os
66 import popen2
67 import merge_hw_tables
68
69 hwdatapath = "usr/share/hwdata"
70 class systeminfo:
71     """
72     a utility class for finding and returning information about
73     block devices, memory, and other hardware on the system
74     """
75
76     PROC_MEMINFO_PATH= "/proc/meminfo"
77
78
79     PROC_PARTITIONS_PATH= "/proc/partitions"
80
81     # set when the sfdisk -l <dev> trick has been done to make
82     # all devices show up
83     DEVICES_SCANNED_FLAG= "/tmp/devices_scanned"
84         
85     # a /proc/partitions block is 1024 bytes
86     # a GB to a HDD manufacturer is 10^9 bytes
87     BLOCKS_PER_GB = pow(10, 9) / 1024.0;
88
89
90     # -n is numeric ids (no lookup), -m is machine readable
91     LSPCI_CMD= "/sbin/lspci -nm"
92     
93     MODULE_CLASS_NETWORK= "network"
94     MODULE_CLASS_SCSI= "scsi"
95
96     PCI_CLASS_NETWORK_ETHERNET=0x0200L
97     PCI_CLASS_STORAGE_SCSI=0x0100L
98     PCI_CLASS_STORAGE_IDE=0x0101L
99     PCI_CLASS_STORAGE_FLOPPY=0x0102L
100     PCI_CLASS_STORAGE_IPI=0x0103L
101     PCI_CLASS_STORAGE_RAID=0x0104L
102     PCI_CLASS_STORAGE_OTHER=0x0180L
103
104     PCI_ANY=0xffffffffL
105
106     def get_total_phsyical_mem(self):
107         """
108         return the total physical memory of the machine, in kilobytes.
109
110         Return None if /proc/meminfo not readable.
111         """
112         
113         try:
114             meminfo_file= file(self.PROC_MEMINFO_PATH,"r")
115         except IOError, e:
116             return
117
118         total_memory= None
119         
120         for line in meminfo_file:
121
122             try:
123                 (fieldname,value)= string.split(line,":")
124             except ValueError, e:
125                 # this will happen for lines that don't have two values
126                 # (like the first line on 2.4 kernels)
127                 continue
128
129             fieldname= string.strip(fieldname)
130             value= string.strip(value)
131             
132             if fieldname == "MemTotal":
133                 try:
134                     (total_memory,units)= string.split(value)
135                 except ValueError, e:
136                     return
137                 
138                 if total_memory == "" or total_memory == None or \
139                        units == "" or units == None:
140                     return
141
142                 if string.lower(units) != "kb":
143                     return
144
145                 try:
146                     total_memory= int(total_memory)
147                 except ValueError, e:
148                     return
149
150                 break
151
152         meminfo_file.close()
153
154         return total_memory
155
156
157
158     def get_block_device_list(self):
159         """
160         get a list of block devices from this system.
161         return an associative array, where the device name
162         (full /dev/device path) is the key, and the value
163         is a tuple of (major,minor,numblocks,gb_size,readonly)
164         """
165         
166         # make sure we can access to the files/directories in /proc
167         if not os.access(self.PROC_PARTITIONS_PATH, os.F_OK):
168             return None
169
170
171         # only do this once every system boot
172         if not os.access(self.DEVICES_SCANNED_FLAG, os.R_OK):
173             
174             # this is ugly. under devfs, device
175             # entries in /dev/scsi/.. and /dev/ide/...
176             # don't show up until you attempt to read
177             # from the associated device at /dev (/dev/sda).
178             # so, lets run sfdisk -l (list partitions) against
179             # most possible block devices, that way they show
180             # up when it comes time to do the install.
181             for dev_prefix in ('sd','hd'):
182                 block_dev_num= 0
183                 while block_dev_num < 10:
184                     if block_dev_num < 26:
185                         devicename= "/dev/%s%c" % \
186                                     (dev_prefix, chr(ord('a')+block_dev_num))
187                     else:
188                         devicename= "/dev/%s%c%c" % \
189                                     ( dev_prefix,
190                                       chr(ord('a')+((block_dev_num/26)-1)),
191                                       chr(ord('a')+(block_dev_num%26)) )
192
193                     os.system( "sfdisk -l %s > /dev/null 2>&1" % devicename )
194                     block_dev_num = block_dev_num + 1
195
196             additional_scan_devices= ("/dev/cciss/c0d0p", "/dev/cciss/c0d1p",
197                                       "/dev/cciss/c0d2p", "/dev/cciss/c0d3p",
198                                       "/dev/cciss/c0d4p", "/dev/cciss/c0d5p",
199                                       "/dev/cciss/c0d6p", "/dev/cciss/c0d7p",
200                                       "/dev/cciss/c1d0p", "/dev/cciss/c1d1p",
201                                       "/dev/cciss/c1d2p", "/dev/cciss/c1d3p",
202                                       "/dev/cciss/c1d4p", "/dev/cciss/c1d5p",
203                                       "/dev/cciss/c1d6p", "/dev/cciss/c1d7p",)
204             
205             for devicename in additional_scan_devices:
206                 os.system( "sfdisk -l %s > /dev/null 2>&1" % devicename )
207
208             os.system( "touch %s" % self.DEVICES_SCANNED_FLAG )
209             
210
211         devicelist= {}
212
213         partitions_file= file(self.PROC_PARTITIONS_PATH,"r")
214         line_count= 0
215         
216         for line in partitions_file:
217             line_count= line_count + 1
218
219             # skip the first two lines always
220             if line_count < 2:
221                 continue
222
223             parts= string.split(line)
224
225             if len(parts) < 4:
226                 continue
227             
228             device= parts[3]
229
230             dev_name= "/dev/%s" % device
231             
232             try:
233                 major= int(parts[0])
234                 minor= int(parts[1])
235                 blocks= int(parts[2])
236             except ValueError, err:
237                 continue
238
239             # skip and ignore any partitions
240             if minor != 0:
241                 continue
242                 
243             gb_size= blocks/self.BLOCKS_PER_GB
244             
245             # parse the output of hdparm <disk> to get the readonly flag;
246             # if this fails, assume it isn't read only
247             readonly= 0
248             
249             hdparm_cmd = popen2.Popen3("hdparm %s 2> /dev/null" % dev_name)
250             status= hdparm_cmd.wait()
251
252             if os.WIFEXITED(status) and os.WEXITSTATUS(status) == 0:
253                 try:
254                     hdparm_output= hdparm_cmd.fromchild.read()
255                     hdparm_cmd= None
256                     
257                     # parse the output of hdparm, the lines we are interested
258                     # in look
259                     # like:
260                     #
261                     #  readonly     =  0 (off)
262                     #
263                     
264                     for line in string.split(hdparm_output,"\n"):
265                         
266                         line= string.strip(line)
267                         if line == "":
268                             continue
269                         
270                         line_parts= string.split(line,"=")
271                         if len(line_parts) < 2:
272                             continue
273
274                         name= string.strip(line_parts[0])
275
276                         if name == "readonly":
277                             value= string.strip(line_parts[1])
278                             if len(value) == 0:
279                                 break
280
281                             if value[0] == "1":
282                                 readonly= 1
283                                 break
284
285                 except IOError:
286                     pass
287
288             devicelist[dev_name]= (major,minor,blocks,gb_size,readonly)
289
290             
291         return devicelist
292
293
294
295     def get_system_modules( self, install_root, kernel_version= None ):
296         """
297         Return a list of kernel modules that this system requires.
298         This requires access to the installed system's root
299         directory, as the following files must exist and are used:
300         <install_root>/usr/share/hwdata/pcitable
301         <install_root>/lib/modules/(first entry if kernel_version unspecified)/modules.pcimap
302         <install_root>/lib/modules/(first entry if kernel version unspecified)/modules.dep
303
304         If there are more than one kernels installed, and the kernel
305         version is not specified, then only the first one in
306         /lib/modules is used.
307
308         Returns a dictionary, keys being the type of module:
309          - scsi       MODULE_CLASS_SCSI
310          - network    MODULE_CLASS_NETWORK
311         The value being the kernel module name to load.
312
313         Some sata devices show up under an IDE device class,
314         hence the reason for checking for ide devices as well.
315         If there actually is a match in the pci -> module lookup
316         table, and its an ide device, its most likely sata,
317         as ide modules are built in to the kernel.
318         """
319
320         # get the kernel version we are assuming
321         if kernel_version is None:
322             try:
323                 kernel_version= os.listdir( "%s/lib/modules/" % install_root )
324             except OSError, e:
325                 return
326
327             if len(kernel_version) == 0:
328                 return
329
330             if len(kernel_version) > 1:
331                 print( "WARNING: We may be returning modules for the wrong kernel." )
332
333             kernel_version= kernel_version[0]
334
335         print( "Using kernel version %s" % kernel_version )
336
337         # test to make sure the three files we need are present
338         pcitable_path = "%s/%s/pcitable" % (install_root,hwdatapath)
339         modules_pcimap_path = "%s/lib/modules/%s/modules.pcimap" % \
340                               (install_root,kernel_version)
341         modules_dep_path = "%s/lib/modules/%s/modules.dep" % \
342                            (install_root,kernel_version)
343
344         for path in (pcitable_path,modules_pcimap_path,modules_dep_path):
345             if not os.access(path,os.R_OK):
346                 print( "Unable to read %s" % path )
347                 return
348
349         # now, with those three files, merge them all into one easy to
350         # use lookup table
351         (all_pci_ids, all_modules) = merge_hw_tables.merge_files( modules_dep_path,
352                                                                   modules_pcimap_path,
353                                                                   pcitable_path )
354         if all_modules is None:
355             print( "Unable to merge pci id tables." )
356             return
357
358         # this is the actual data structure we return
359         system_mods= {}
360
361         # these are the lists that will be in system_mods
362         network_mods= []
363         scsi_mods= []
364
365
366         # get all the system devices from lspci
367         lspci_prog= popen2.Popen3( self.LSPCI_CMD, 1 )
368         if lspci_prog is None:
369             print( "Unable to run %s with popen2.Popen3" % self.LSPCI_CMD )
370             return
371         
372         returncode= lspci_prog.wait()
373         if returncode != 0:
374             print( "Running %s failed" % self.LSPCI_CMD )
375             return
376         else:
377             print( "Successfully ran %s" % self.LSPCI_CMD )
378             
379         # for every lspci line, parse in the four tuple PCI id and the
380         # search for the corresponding driver from the dictionary
381         # generated by merge_hw_tables
382         for line in lspci_prog.fromchild:
383             if string.strip(line) == "":
384                 continue
385     
386             parts= string.split(line)
387
388             try:
389                 classid= self.remove_quotes(parts[2])
390                 classid= long(classid,16)
391             except IndexError:
392                 print( "Skipping invalid classid:", string.strip(line) )
393                 continue
394             except ValueError, e:
395                 print( "Skipping invalid classid:", string.strip(line) )
396                 continue
397
398
399             if classid not in (self.PCI_CLASS_NETWORK_ETHERNET,
400                                self.PCI_CLASS_STORAGE_SCSI,
401                                self.PCI_CLASS_STORAGE_RAID,
402                                self.PCI_CLASS_STORAGE_OTHER,
403                                self.PCI_CLASS_STORAGE_IDE):
404                 continue
405
406             vendorid    = self.PCI_ANY
407             deviceid    = self.PCI_ANY
408             subvendorid = self.PCI_ANY
409             subdeviceid = self.PCI_ANY
410
411             # parse in vendorid
412             try:
413                 vendorid= self.remove_quotes(parts[3])
414                 vendorid= long(vendorid,16)
415             except IndexError:
416                 print( "Skipping invalid vendorid:", string.strip(line) )
417                 continue
418             except ValueError, e:
419                 print( "Skipping invalid vendorid:", string.strip(line) )
420                 continue
421
422             # parse in deviceid
423             try:
424                 deviceid= self.remove_quotes(parts[4])
425                 deviceid= long(deviceid,16)
426             except IndexError:
427                 print( "Skipping invalid deviceid:", string.strip(line) )
428                 continue
429             except ValueError, e:
430                 print( "Skipping invalid deviceid:", string.strip(line) )
431                 continue
432
433             # Now get the subvendor & subdevice portion by searching
434             # parts[5:] of the lspci output. Note that we have to skip
435             # the portions of the lspci output string that indicate
436             # revision info.
437
438             # parse in subvendorid
439             subvendorindex = -1
440             for i in range(5,len(parts)):
441                 p = self.remove_quotes(parts[i])
442                 if p[0] != '-':
443                     subvendorindex = i
444                     break
445
446             if subvendorindex != -1:
447                 try:
448                     subvendorid= self.remove_quotes(parts[subvendorindex])
449                     subvendorid= long(subvendorid,16)
450                 except IndexError:
451                     print( "Skipping invalid line:", string.strip(line) )
452                     continue
453                 except ValueError, e:
454                     print( "Skipping invalid line:", string.strip(line) )
455                     continue
456
457             # parse in subdeviceid
458             subdeviceindex = -1
459             for i in range(subvendorindex+1,len(parts)):
460                 p = self.remove_quotes(parts[i])
461                 if p[0] != '-':
462                     subdeviceindex = i
463                     break
464             if subdeviceindex != -1:
465                 error_msg = "Skipping invalid subdeviceid:"
466                 try:
467                     subdeviceid= self.remove_quotes(parts[subdeviceindex])
468                     subdeviceid= long(subdeviceid,16)
469                 except IndexError:
470                     print( error_msg, string.strip(line) )
471                     continue
472                 except ValueError, e:
473                     print( error_msg, string.strip(line) )
474                     continue
475
476             # search for driver that most closely matches the full_id
477             # to drivers that can handle any subvendor/subdevice
478             # version of the hardware.
479             full_ids = ((vendorid,deviceid,subvendorid,subdeviceid),
480                         (vendorid,deviceid,subvendorid,self.PCI_ANY),
481                         (vendorid,deviceid,self.PCI_ANY,self.PCI_ANY))
482
483             for full_id in full_ids:
484                 module = all_pci_ids.get(full_id, None)
485                 if module is not None:
486                     if classid == self.PCI_CLASS_NETWORK_ETHERNET:
487                         network_mods.append(module[0])
488                     elif classid in (self.PCI_CLASS_STORAGE_SCSI,
489                                      self.PCI_CLASS_STORAGE_RAID,
490                                      self.PCI_CLASS_STORAGE_OTHER,
491                                      self.PCI_CLASS_STORAGE_IDE):
492                         scsi_mods.append(module[0])
493                     break
494
495         system_mods[self.MODULE_CLASS_SCSI]= scsi_mods
496         system_mods[self.MODULE_CLASS_NETWORK]= network_mods
497         
498         return system_mods
499
500
501     def remove_quotes( self, str ):
502         """
503         remove double quotes off of a string if they exist
504         """
505         if str == "" or str == None:
506             return str
507         if str[:1] == '"':
508             str= str[1:]
509         if str[len(str)-1] == '"':
510             str= str[:len(str)-1]
511         return str
512
513
514
515 if __name__ == "__main__":
516     info= systeminfo()
517     
518     devices= info.get_block_device_list()
519     print "block devices detected:"
520     if not devices:
521         print "no devices found!"
522     else:
523         for dev in devices.keys():
524             print "%s %s" % (dev, repr(devices[dev]))
525             
526
527     print ""
528     memory= info.get_total_phsyical_mem()
529     if not memory:
530         print "unable to read /proc/meminfo for memory"
531     else:
532         print "total physical memory: %d kb" % memory
533         
534
535     print ""
536
537     import sys
538     kernel_version = None
539     if len(sys.argv) > 2:
540         kernel_version = sys.argv[1]
541         
542     modules= info.get_system_modules("/",kernel_version)
543     if not modules:
544         print "unable to list system modules"
545     else:
546         for type in modules:
547             if type == info.MODULE_CLASS_SCSI:
548                 print( "all scsi modules:" )
549                 for a_mod in modules[type]:
550                     print a_mod
551             elif type == info.MODULE_CLASS_NETWORK:
552                 print( "all network modules:" )
553                 for a_mod in modules[type]:
554                     print a_mod
555