net/fm10k: add compile-time checks to vector driver
[dpdk.git] / usertools / dpdk-pmdinfo.py
1 #!/usr/bin/env python
2
3 # -------------------------------------------------------------------------
4 #
5 # Utility to dump PMD_INFO_STRING support from an object file
6 #
7 # -------------------------------------------------------------------------
8 from __future__ import print_function
9 import json
10 import os
11 import platform
12 import string
13 import sys
14 from elftools.common.exceptions import ELFError
15 from elftools.common.py3compat import (byte2int, bytes2str, str2bytes)
16 from elftools.elf.elffile import ELFFile
17 from optparse import OptionParser
18
19 # For running from development directory. It should take precedence over the
20 # installed pyelftools.
21 sys.path.insert(0, '.')
22
23 raw_output = False
24 pcidb = None
25
26 # ===========================================
27
28
29 class Vendor:
30     """
31     Class for vendors. This is the top level class
32     for the devices belong to a specific vendor.
33     self.devices is the device dictionary
34     subdevices are in each device.
35     """
36
37     def __init__(self, vendorStr):
38         """
39         Class initializes with the raw line from pci.ids
40         Parsing takes place inside __init__
41         """
42         self.ID = vendorStr.split()[0]
43         self.name = vendorStr.replace("%s " % self.ID, "").rstrip()
44         self.devices = {}
45
46     def addDevice(self, deviceStr):
47         """
48         Adds a device to self.devices
49         takes the raw line from pci.ids
50         """
51         s = deviceStr.strip()
52         devID = s.split()[0]
53         if devID in self.devices:
54             pass
55         else:
56             self.devices[devID] = Device(deviceStr)
57
58     def report(self):
59         print(self.ID, self.name)
60         for id, dev in self.devices.items():
61             dev.report()
62
63     def find_device(self, devid):
64         # convert to a hex string and remove 0x
65         devid = hex(devid)[2:]
66         try:
67             return self.devices[devid]
68         except:
69             return Device("%s  Unknown Device" % devid)
70
71
72 class Device:
73
74     def __init__(self, deviceStr):
75         """
76         Class for each device.
77         Each vendor has its own devices dictionary.
78         """
79         s = deviceStr.strip()
80         self.ID = s.split()[0]
81         self.name = s.replace("%s  " % self.ID, "")
82         self.subdevices = {}
83
84     def report(self):
85         print("\t%s\t%s" % (self.ID, self.name))
86         for subID, subdev in self.subdevices.items():
87             subdev.report()
88
89     def addSubDevice(self, subDeviceStr):
90         """
91         Adds a subvendor, subdevice to device.
92         Uses raw line from pci.ids
93         """
94         s = subDeviceStr.strip()
95         spl = s.split()
96         subVendorID = spl[0]
97         subDeviceID = spl[1]
98         subDeviceName = s.split("  ")[-1]
99         devID = "%s:%s" % (subVendorID, subDeviceID)
100         self.subdevices[devID] = SubDevice(
101             subVendorID, subDeviceID, subDeviceName)
102
103     def find_subid(self, subven, subdev):
104         subven = hex(subven)[2:]
105         subdev = hex(subdev)[2:]
106         devid = "%s:%s" % (subven, subdev)
107
108         try:
109             return self.subdevices[devid]
110         except:
111             if (subven == "ffff" and subdev == "ffff"):
112                 return SubDevice("ffff", "ffff", "(All Subdevices)")
113             else:
114                 return SubDevice(subven, subdev, "(Unknown Subdevice)")
115
116
117 class SubDevice:
118     """
119     Class for subdevices.
120     """
121
122     def __init__(self, vendor, device, name):
123         """
124         Class initializes with vendorid, deviceid and name
125         """
126         self.vendorID = vendor
127         self.deviceID = device
128         self.name = name
129
130     def report(self):
131         print("\t\t%s\t%s\t%s" % (self.vendorID, self.deviceID, self.name))
132
133
134 class PCIIds:
135     """
136     Top class for all pci.ids entries.
137     All queries will be asked to this class.
138     PCIIds.vendors["0e11"].devices["0046"].\
139     subdevices["0e11:4091"].name  =  "Smart Array 6i"
140     """
141
142     def __init__(self, filename):
143         """
144         Prepares the directories.
145         Checks local data file.
146         Tries to load from local, if not found, downloads from web
147         """
148         self.version = ""
149         self.date = ""
150         self.vendors = {}
151         self.contents = None
152         self.readLocal(filename)
153         self.parse()
154
155     def reportVendors(self):
156         """Reports the vendors
157         """
158         for vid, v in self.vendors.items():
159             print(v.ID, v.name)
160
161     def report(self, vendor=None):
162         """
163         Reports everything for all vendors or a specific vendor
164         PCIIds.report()  reports everything
165         PCIIDs.report("0e11") reports only "Compaq Computer Corporation"
166         """
167         if vendor is not None:
168             self.vendors[vendor].report()
169         else:
170             for vID, v in self.vendors.items():
171                 v.report()
172
173     def find_vendor(self, vid):
174         # convert vid to a hex string and remove the 0x
175         vid = hex(vid)[2:]
176
177         try:
178             return self.vendors[vid]
179         except:
180             return Vendor("%s Unknown Vendor" % (vid))
181
182     def findDate(self, content):
183         for l in content:
184             if l.find("Date:") > -1:
185                 return l.split()[-2].replace("-", "")
186         return None
187
188     def parse(self):
189         if len(self.contents) < 1:
190             print("data/%s-pci.ids not found" % self.date)
191         else:
192             vendorID = ""
193             deviceID = ""
194             for l in self.contents:
195                 if l[0] == "#":
196                     continue
197                 elif len(l.strip()) == 0:
198                     continue
199                 else:
200                     if l.find("\t\t") == 0:
201                         self.vendors[vendorID].devices[
202                             deviceID].addSubDevice(l)
203                     elif l.find("\t") == 0:
204                         deviceID = l.strip().split()[0]
205                         self.vendors[vendorID].addDevice(l)
206                     else:
207                         vendorID = l.split()[0]
208                         self.vendors[vendorID] = Vendor(l)
209
210     def readLocal(self, filename):
211         """
212         Reads the local file
213         """
214         self.contents = open(filename).readlines()
215         self.date = self.findDate(self.contents)
216
217     def loadLocal(self):
218         """
219         Loads database from local. If there is no file,
220         it creates a new one from web
221         """
222         self.date = idsfile[0].split("/")[1].split("-")[0]
223         self.readLocal()
224
225
226 # =======================================
227
228 def search_file(filename, search_path):
229     """ Given a search path, find file with requested name """
230     for path in string.split(search_path, ":"):
231         candidate = os.path.join(path, filename)
232         if os.path.exists(candidate):
233             return os.path.abspath(candidate)
234     return None
235
236
237 class ReadElf(object):
238     """ display_* methods are used to emit output into the output stream
239     """
240
241     def __init__(self, file, output):
242         """ file:
243                 stream object with the ELF file to read
244
245             output:
246                 output stream to write to
247         """
248         self.elffile = ELFFile(file)
249         self.output = output
250
251         # Lazily initialized if a debug dump is requested
252         self._dwarfinfo = None
253
254         self._versioninfo = None
255
256     def _section_from_spec(self, spec):
257         """ Retrieve a section given a "spec" (either number or name).
258             Return None if no such section exists in the file.
259         """
260         try:
261             num = int(spec)
262             if num < self.elffile.num_sections():
263                 return self.elffile.get_section(num)
264             else:
265                 return None
266         except ValueError:
267             # Not a number. Must be a name then
268             return self.elffile.get_section_by_name(str2bytes(spec))
269
270     def pretty_print_pmdinfo(self, pmdinfo):
271         global pcidb
272
273         for i in pmdinfo["pci_ids"]:
274             vendor = pcidb.find_vendor(i[0])
275             device = vendor.find_device(i[1])
276             subdev = device.find_subid(i[2], i[3])
277             print("%s (%s) : %s (%s) %s" %
278                   (vendor.name, vendor.ID, device.name,
279                    device.ID, subdev.name))
280
281     def parse_pmd_info_string(self, mystring):
282         global raw_output
283         global pcidb
284
285         optional_pmd_info = [
286             {'id': 'params', 'tag': 'PMD PARAMETERS'},
287             {'id': 'kmod', 'tag': 'PMD KMOD DEPENDENCIES'}
288         ]
289
290         i = mystring.index("=")
291         mystring = mystring[i + 2:]
292         pmdinfo = json.loads(mystring)
293
294         if raw_output:
295             print(json.dumps(pmdinfo))
296             return
297
298         print("PMD NAME: " + pmdinfo["name"])
299         for i in optional_pmd_info:
300             try:
301                 print("%s: %s" % (i['tag'], pmdinfo[i['id']]))
302             except KeyError:
303                 continue
304
305         if (len(pmdinfo["pci_ids"]) != 0):
306             print("PMD HW SUPPORT:")
307             if pcidb is not None:
308                 self.pretty_print_pmdinfo(pmdinfo)
309             else:
310                 print("VENDOR\t DEVICE\t SUBVENDOR\t SUBDEVICE")
311                 for i in pmdinfo["pci_ids"]:
312                     print("0x%04x\t 0x%04x\t 0x%04x\t\t 0x%04x" %
313                           (i[0], i[1], i[2], i[3]))
314
315         print("")
316
317     def display_pmd_info_strings(self, section_spec):
318         """ Display a strings dump of a section. section_spec is either a
319             section number or a name.
320         """
321         section = self._section_from_spec(section_spec)
322         if section is None:
323             return
324
325         data = section.data()
326         dataptr = 0
327
328         while dataptr < len(data):
329             while (dataptr < len(data) and
330                     not (32 <= byte2int(data[dataptr]) <= 127)):
331                 dataptr += 1
332
333             if dataptr >= len(data):
334                 break
335
336             endptr = dataptr
337             while endptr < len(data) and byte2int(data[endptr]) != 0:
338                 endptr += 1
339
340             mystring = bytes2str(data[dataptr:endptr])
341             rc = mystring.find("PMD_INFO_STRING")
342             if (rc != -1):
343                 self.parse_pmd_info_string(mystring)
344
345             dataptr = endptr
346
347     def find_librte_eal(self, section):
348         for tag in section.iter_tags():
349             if tag.entry.d_tag == 'DT_NEEDED':
350                 if "librte_eal" in tag.needed:
351                     return tag.needed
352         return None
353
354     def search_for_autoload_path(self):
355         scanelf = self
356         scanfile = None
357         library = None
358
359         section = self._section_from_spec(".dynamic")
360         try:
361             eallib = self.find_librte_eal(section)
362             if eallib is not None:
363                 ldlibpath = os.environ.get('LD_LIBRARY_PATH')
364                 if ldlibpath is None:
365                     ldlibpath = ""
366                 dtr = self.get_dt_runpath(section)
367                 library = search_file(eallib,
368                                       dtr + ":" + ldlibpath +
369                                       ":/usr/lib64:/lib64:/usr/lib:/lib")
370                 if library is None:
371                     return (None, None)
372                 if raw_output is False:
373                     print("Scanning for autoload path in %s" % library)
374                 scanfile = open(library, 'rb')
375                 scanelf = ReadElf(scanfile, sys.stdout)
376         except AttributeError:
377             # Not a dynamic binary
378             pass
379         except ELFError:
380             scanfile.close()
381             return (None, None)
382
383         section = scanelf._section_from_spec(".rodata")
384         if section is None:
385             if scanfile is not None:
386                 scanfile.close()
387             return (None, None)
388
389         data = section.data()
390         dataptr = 0
391
392         while dataptr < len(data):
393             while (dataptr < len(data) and
394                     not (32 <= byte2int(data[dataptr]) <= 127)):
395                 dataptr += 1
396
397             if dataptr >= len(data):
398                 break
399
400             endptr = dataptr
401             while endptr < len(data) and byte2int(data[endptr]) != 0:
402                 endptr += 1
403
404             mystring = bytes2str(data[dataptr:endptr])
405             rc = mystring.find("DPDK_PLUGIN_PATH")
406             if (rc != -1):
407                 rc = mystring.find("=")
408                 return (mystring[rc + 1:], library)
409
410             dataptr = endptr
411         if scanfile is not None:
412             scanfile.close()
413         return (None, None)
414
415     def get_dt_runpath(self, dynsec):
416         for tag in dynsec.iter_tags():
417             if tag.entry.d_tag == 'DT_RUNPATH':
418                 return tag.runpath
419         return ""
420
421     def process_dt_needed_entries(self):
422         """ Look to see if there are any DT_NEEDED entries in the binary
423             And process those if there are
424         """
425         global raw_output
426         runpath = ""
427         ldlibpath = os.environ.get('LD_LIBRARY_PATH')
428         if ldlibpath is None:
429             ldlibpath = ""
430
431         dynsec = self._section_from_spec(".dynamic")
432         try:
433             runpath = self.get_dt_runpath(dynsec)
434         except AttributeError:
435             # dynsec is None, just return
436             return
437
438         for tag in dynsec.iter_tags():
439             if tag.entry.d_tag == 'DT_NEEDED':
440                 rc = tag.needed.find(b"librte_pmd")
441                 if (rc != -1):
442                     library = search_file(tag.needed,
443                                           runpath + ":" + ldlibpath +
444                                           ":/usr/lib64:/lib64:/usr/lib:/lib")
445                     if library is not None:
446                         if raw_output is False:
447                             print("Scanning %s for pmd information" % library)
448                         with open(library, 'rb') as file:
449                             try:
450                                 libelf = ReadElf(file, sys.stdout)
451                             except ELFError:
452                                 print("%s is no an ELF file" % library)
453                                 continue
454                             libelf.process_dt_needed_entries()
455                             libelf.display_pmd_info_strings(".rodata")
456                             file.close()
457
458
459 def scan_autoload_path(autoload_path):
460     global raw_output
461
462     if os.path.exists(autoload_path) is False:
463         return
464
465     try:
466         dirs = os.listdir(autoload_path)
467     except OSError:
468         # Couldn't read the directory, give up
469         return
470
471     for d in dirs:
472         dpath = os.path.join(autoload_path, d)
473         if os.path.isdir(dpath):
474             scan_autoload_path(dpath)
475         if os.path.isfile(dpath):
476             try:
477                 file = open(dpath, 'rb')
478                 readelf = ReadElf(file, sys.stdout)
479             except ELFError:
480                 # this is likely not an elf file, skip it
481                 continue
482             except IOError:
483                 # No permission to read the file, skip it
484                 continue
485
486             if raw_output is False:
487                 print("Hw Support for library %s" % d)
488             readelf.display_pmd_info_strings(".rodata")
489             file.close()
490
491
492 def scan_for_autoload_pmds(dpdk_path):
493     """
494     search the specified application or path for a pmd autoload path
495     then scan said path for pmds and report hw support
496     """
497     global raw_output
498
499     if (os.path.isfile(dpdk_path) is False):
500         if raw_output is False:
501             print("Must specify a file name")
502         return
503
504     file = open(dpdk_path, 'rb')
505     try:
506         readelf = ReadElf(file, sys.stdout)
507     except ElfError:
508         if raw_output is False:
509             print("Unable to parse %s" % file)
510         return
511
512     (autoload_path, scannedfile) = readelf.search_for_autoload_path()
513     if (autoload_path is None or autoload_path is ""):
514         if (raw_output is False):
515             print("No autoload path configured in %s" % dpdk_path)
516         return
517     if (raw_output is False):
518         if (scannedfile is None):
519             scannedfile = dpdk_path
520         print("Found autoload path %s in %s" % (autoload_path, scannedfile))
521
522     file.close()
523     if (raw_output is False):
524         print("Discovered Autoload HW Support:")
525     scan_autoload_path(autoload_path)
526     return
527
528
529 def main(stream=None):
530     global raw_output
531     global pcidb
532
533     pcifile_default = "./pci.ids"  # For unknown OS's assume local file
534     if platform.system() == 'Linux':
535         pcifile_default = "/usr/share/hwdata/pci.ids"
536     elif platform.system() == 'FreeBSD':
537         pcifile_default = "/usr/local/share/pciids/pci.ids"
538         if not os.path.exists(pcifile_default):
539             pcifile_default = "/usr/share/misc/pci_vendors"
540
541     optparser = OptionParser(
542         usage='usage: %prog [-hrtp] [-d <pci id file] <elf-file>',
543         description="Dump pmd hardware support info",
544         add_help_option=True)
545     optparser.add_option('-r', '--raw',
546                          action='store_true', dest='raw_output',
547                          help='Dump raw json strings')
548     optparser.add_option("-d", "--pcidb", dest="pcifile",
549                          help="specify a pci database "
550                               "to get vendor names from",
551                          default=pcifile_default, metavar="FILE")
552     optparser.add_option("-t", "--table", dest="tblout",
553                          help="output information on hw support as a "
554                               "hex table",
555                          action='store_true')
556     optparser.add_option("-p", "--plugindir", dest="pdir",
557                          help="scan dpdk for autoload plugins",
558                          action='store_true')
559
560     options, args = optparser.parse_args()
561
562     if options.raw_output:
563         raw_output = True
564
565     if options.pcifile:
566         pcidb = PCIIds(options.pcifile)
567         if pcidb is None:
568             print("Pci DB file not found")
569             exit(1)
570
571     if options.tblout:
572         options.pcifile = None
573         pcidb = None
574
575     if (len(args) == 0):
576         optparser.print_usage()
577         exit(1)
578
579     if options.pdir is True:
580         exit(scan_for_autoload_pmds(args[0]))
581
582     ldlibpath = os.environ.get('LD_LIBRARY_PATH')
583     if (ldlibpath is None):
584         ldlibpath = ""
585
586     if (os.path.exists(args[0]) is True):
587         myelffile = args[0]
588     else:
589         myelffile = search_file(
590             args[0], ldlibpath + ":/usr/lib64:/lib64:/usr/lib:/lib")
591
592     if (myelffile is None):
593         print("File not found")
594         sys.exit(1)
595
596     with open(myelffile, 'rb') as file:
597         try:
598             readelf = ReadElf(file, sys.stdout)
599             readelf.process_dt_needed_entries()
600             readelf.display_pmd_info_strings(".rodata")
601             sys.exit(0)
602
603         except ELFError as ex:
604             sys.stderr.write('ELF error: %s\n' % ex)
605             sys.exit(1)
606
607
608 # -------------------------------------------------------------------------
609 if __name__ == '__main__':
610     main()