net/mlx5: fix meter flow direction check
[dpdk.git] / usertools / dpdk-pmdinfo.py
1 #!/usr/bin/env python3
2 # SPDX-License-Identifier: BSD-3-Clause
3 # Copyright(c) 2016  Neil Horman <nhorman@tuxdriver.com>
4
5 # -------------------------------------------------------------------------
6 #
7 # Utility to dump PMD_INFO_STRING support from an object file
8 #
9 # -------------------------------------------------------------------------
10 import json
11 import os
12 import platform
13 import sys
14 import argparse
15 from elftools.common.exceptions import ELFError
16 from elftools.common.py3compat import byte2int
17 from elftools.elf.elffile import ELFFile
18
19
20 # For running from development directory. It should take precedence over the
21 # installed pyelftools.
22 sys.path.insert(0, '.')
23
24 raw_output = False
25 pcidb = None
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             return SubDevice(subven, subdev, "(Unknown Subdevice)")
114
115
116 class SubDevice:
117     """
118     Class for subdevices.
119     """
120
121     def __init__(self, vendor, device, name):
122         """
123         Class initializes with vendorid, deviceid and name
124         """
125         self.vendorID = vendor
126         self.deviceID = device
127         self.name = name
128
129     def report(self):
130         print("\t\t%s\t%s\t%s" % (self.vendorID, self.deviceID, self.name))
131
132
133 class PCIIds:
134     """
135     Top class for all pci.ids entries.
136     All queries will be asked to this class.
137     PCIIds.vendors["0e11"].devices["0046"].\
138     subdevices["0e11:4091"].name  =  "Smart Array 6i"
139     """
140
141     def __init__(self, filename):
142         """
143         Prepares the directories.
144         Checks local data file.
145         Tries to load from local, if not found, downloads from web
146         """
147         self.version = ""
148         self.date = ""
149         self.vendors = {}
150         self.contents = None
151         self.readLocal(filename)
152         self.parse()
153
154     def reportVendors(self):
155         """Reports the vendors
156         """
157         for vid, v in self.vendors.items():
158             print(v.ID, v.name)
159
160     def report(self, vendor=None):
161         """
162         Reports everything for all vendors or a specific vendor
163         PCIIds.report()  reports everything
164         PCIIDs.report("0e11") reports only "Compaq Computer Corporation"
165         """
166         if vendor is not None:
167             self.vendors[vendor].report()
168         else:
169             for vID, v in self.vendors.items():
170                 v.report()
171
172     def find_vendor(self, vid):
173         # convert vid to a hex string and remove the 0x
174         vid = hex(vid)[2:]
175
176         try:
177             return self.vendors[vid]
178         except:
179             return Vendor("%s Unknown Vendor" % (vid))
180
181     def findDate(self, content):
182         for l in content:
183             if l.find("Date:") > -1:
184                 return l.split()[-2].replace("-", "")
185         return None
186
187     def parse(self):
188         if not self.contents:
189             print("data/%s-pci.ids not found" % self.date)
190         else:
191             vendorID = ""
192             deviceID = ""
193             for l in self.contents:
194                 if l[0] == "#":
195                     continue
196                 elif not l.strip():
197                     continue
198                 else:
199                     if l.find("\t\t") == 0:
200                         self.vendors[vendorID].devices[
201                             deviceID].addSubDevice(l)
202                     elif l.find("\t") == 0:
203                         deviceID = l.strip().split()[0]
204                         self.vendors[vendorID].addDevice(l)
205                     else:
206                         vendorID = l.split()[0]
207                         self.vendors[vendorID] = Vendor(l)
208
209     def readLocal(self, filename):
210         """
211         Reads the local file
212         """
213         with open(filename, 'r', encoding='utf-8') as f:
214             self.contents = f.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 search_path.split(':'):
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             return None
265         except ValueError:
266             # Not a number. Must be a name then
267             section = self.elffile.get_section_by_name(force_unicode(spec))
268             if section is None:
269                 # No match with a unicode name.
270                 # Some versions of pyelftools (<= 0.23) store internal strings
271                 # as bytes. Try again with the name encoded as bytes.
272                 section = self.elffile.get_section_by_name(force_bytes(spec))
273             return section
274
275     def pretty_print_pmdinfo(self, pmdinfo):
276         global pcidb
277
278         for i in pmdinfo["pci_ids"]:
279             vendor = pcidb.find_vendor(i[0])
280             device = vendor.find_device(i[1])
281             subdev = device.find_subid(i[2], i[3])
282             print("%s (%s) : %s (%s) %s" %
283                   (vendor.name, vendor.ID, device.name,
284                    device.ID, subdev.name))
285
286     def parse_pmd_info_string(self, mystring):
287         global raw_output
288         global pcidb
289
290         optional_pmd_info = [
291             {'id': 'params', 'tag': 'PMD PARAMETERS'},
292             {'id': 'kmod', 'tag': 'PMD KMOD DEPENDENCIES'}
293         ]
294
295         i = mystring.index("=")
296         mystring = mystring[i + 2:]
297         pmdinfo = json.loads(mystring)
298
299         if raw_output:
300             print(json.dumps(pmdinfo))
301             return
302
303         print("PMD NAME: " + pmdinfo["name"])
304         for i in optional_pmd_info:
305             try:
306                 print("%s: %s" % (i['tag'], pmdinfo[i['id']]))
307             except KeyError:
308                 continue
309
310         if pmdinfo["pci_ids"]:
311             print("PMD HW SUPPORT:")
312             if pcidb is not None:
313                 self.pretty_print_pmdinfo(pmdinfo)
314             else:
315                 print("VENDOR\t DEVICE\t SUBVENDOR\t SUBDEVICE")
316                 for i in pmdinfo["pci_ids"]:
317                     print("0x%04x\t 0x%04x\t 0x%04x\t\t 0x%04x" %
318                           (i[0], i[1], i[2], i[3]))
319
320         print("")
321
322     def display_pmd_info_strings(self, section_spec):
323         """ Display a strings dump of a section. section_spec is either a
324             section number or a name.
325         """
326         section = self._section_from_spec(section_spec)
327         if section is None:
328             return
329
330         data = section.data()
331         dataptr = 0
332
333         while dataptr < len(data):
334             while (dataptr < len(data) and
335                    not 32 <= byte2int(data[dataptr]) <= 127):
336                 dataptr += 1
337
338             if dataptr >= len(data):
339                 break
340
341             endptr = dataptr
342             while endptr < len(data) and byte2int(data[endptr]) != 0:
343                 endptr += 1
344
345             # pyelftools may return byte-strings, force decode them
346             mystring = force_unicode(data[dataptr:endptr])
347             rc = mystring.find("PMD_INFO_STRING")
348             if rc != -1:
349                 self.parse_pmd_info_string(mystring[rc:])
350
351             dataptr = endptr
352
353     def find_librte_eal(self, section):
354         for tag in section.iter_tags():
355             # pyelftools may return byte-strings, force decode them
356             if force_unicode(tag.entry.d_tag) == 'DT_NEEDED':
357                 if "librte_eal" in force_unicode(tag.needed):
358                     return force_unicode(tag.needed)
359         return None
360
361     def search_for_autoload_path(self):
362         scanelf = self
363         scanfile = None
364         library = None
365
366         section = self._section_from_spec(".dynamic")
367         try:
368             eallib = self.find_librte_eal(section)
369             if eallib is not None:
370                 ldlibpath = os.environ.get('LD_LIBRARY_PATH')
371                 if ldlibpath is None:
372                     ldlibpath = ""
373                 dtr = self.get_dt_runpath(section)
374                 library = search_file(eallib,
375                                       dtr + ":" + ldlibpath +
376                                       ":/usr/lib64:/lib64:/usr/lib:/lib")
377                 if library is None:
378                     return (None, None)
379                 if not raw_output:
380                     print("Scanning for autoload path in %s" % library)
381                 scanfile = open(library, 'rb')
382                 scanelf = ReadElf(scanfile, sys.stdout)
383         except AttributeError:
384             # Not a dynamic binary
385             pass
386         except ELFError:
387             scanfile.close()
388             return (None, None)
389
390         section = scanelf._section_from_spec(".rodata")
391         if section is None:
392             if scanfile is not None:
393                 scanfile.close()
394             return (None, None)
395
396         data = section.data()
397         dataptr = 0
398
399         while dataptr < len(data):
400             while (dataptr < len(data) and
401                    not 32 <= byte2int(data[dataptr]) <= 127):
402                 dataptr += 1
403
404             if dataptr >= len(data):
405                 break
406
407             endptr = dataptr
408             while endptr < len(data) and byte2int(data[endptr]) != 0:
409                 endptr += 1
410
411             # pyelftools may return byte-strings, force decode them
412             mystring = force_unicode(data[dataptr:endptr])
413             rc = mystring.find("DPDK_PLUGIN_PATH")
414             if rc != -1:
415                 rc = mystring.find("=")
416                 return (mystring[rc + 1:], library)
417
418             dataptr = endptr
419         if scanfile is not None:
420             scanfile.close()
421         return (None, None)
422
423     def get_dt_runpath(self, dynsec):
424         for tag in dynsec.iter_tags():
425             # pyelftools may return byte-strings, force decode them
426             if force_unicode(tag.entry.d_tag) == 'DT_RUNPATH':
427                 return force_unicode(tag.runpath)
428         return ""
429
430     def process_dt_needed_entries(self):
431         """ Look to see if there are any DT_NEEDED entries in the binary
432             And process those if there are
433         """
434         runpath = ""
435         ldlibpath = os.environ.get('LD_LIBRARY_PATH')
436         if ldlibpath is None:
437             ldlibpath = ""
438
439         dynsec = self._section_from_spec(".dynamic")
440         try:
441             runpath = self.get_dt_runpath(dynsec)
442         except AttributeError:
443             # dynsec is None, just return
444             return
445
446         for tag in dynsec.iter_tags():
447             # pyelftools may return byte-strings, force decode them
448             if force_unicode(tag.entry.d_tag) == 'DT_NEEDED':
449                 if 'librte_' in force_unicode(tag.needed):
450                     library = search_file(force_unicode(tag.needed),
451                                           runpath + ":" + ldlibpath +
452                                           ":/usr/lib64:/lib64:/usr/lib:/lib")
453                     if library is not None:
454                         with open(library, 'rb') as file:
455                             try:
456                                 libelf = ReadElf(file, sys.stdout)
457                             except ELFError:
458                                 print("%s is no an ELF file" % library)
459                                 continue
460                             libelf.process_dt_needed_entries()
461                             libelf.display_pmd_info_strings(".rodata")
462                             file.close()
463
464
465 # compat: remove force_unicode & force_bytes when pyelftools<=0.23 support is
466 # dropped.
467 def force_unicode(s):
468     if hasattr(s, 'decode') and callable(s.decode):
469         s = s.decode('latin-1')  # same encoding used in pyelftools py3compat
470     return s
471
472
473 def force_bytes(s):
474     if hasattr(s, 'encode') and callable(s.encode):
475         s = s.encode('latin-1')  # same encoding used in pyelftools py3compat
476     return s
477
478
479 def scan_autoload_path(autoload_path):
480     global raw_output
481
482     if not os.path.exists(autoload_path):
483         return
484
485     try:
486         dirs = os.listdir(autoload_path)
487     except OSError:
488         # Couldn't read the directory, give up
489         return
490
491     for d in dirs:
492         dpath = os.path.join(autoload_path, d)
493         if os.path.isdir(dpath):
494             scan_autoload_path(dpath)
495         if os.path.isfile(dpath):
496             try:
497                 file = open(dpath, 'rb')
498                 readelf = ReadElf(file, sys.stdout)
499             except ELFError:
500                 # this is likely not an elf file, skip it
501                 continue
502             except IOError:
503                 # No permission to read the file, skip it
504                 continue
505
506             if not raw_output:
507                 print("Hw Support for library %s" % d)
508             readelf.display_pmd_info_strings(".rodata")
509             file.close()
510
511
512 def scan_for_autoload_pmds(dpdk_path):
513     """
514     search the specified application or path for a pmd autoload path
515     then scan said path for pmds and report hw support
516     """
517     global raw_output
518
519     if not os.path.isfile(dpdk_path):
520         if not raw_output:
521             print("Must specify a file name")
522         return
523
524     file = open(dpdk_path, 'rb')
525     try:
526         readelf = ReadElf(file, sys.stdout)
527     except ElfError:
528         if not raw_output:
529             print("Unable to parse %s" % file)
530         return
531
532     (autoload_path, scannedfile) = readelf.search_for_autoload_path()
533     if not autoload_path:
534         if not raw_output:
535             print("No autoload path configured in %s" % dpdk_path)
536         return
537     if not raw_output:
538         if scannedfile is None:
539             scannedfile = dpdk_path
540         print("Found autoload path %s in %s" % (autoload_path, scannedfile))
541
542     file.close()
543     if not raw_output:
544         print("Discovered Autoload HW Support:")
545     scan_autoload_path(autoload_path)
546     return
547
548
549 def main(stream=None):
550     global raw_output
551     global pcidb
552
553     pcifile_default = "./pci.ids"  # For unknown OS's assume local file
554     if platform.system() == 'Linux':
555         # hwdata is the legacy location, misc is supported going forward
556         pcifile_default = "/usr/share/misc/pci.ids"
557         if not os.path.exists(pcifile_default):
558             pcifile_default = "/usr/share/hwdata/pci.ids"
559     elif platform.system() == 'FreeBSD':
560         pcifile_default = "/usr/local/share/pciids/pci.ids"
561         if not os.path.exists(pcifile_default):
562             pcifile_default = "/usr/share/misc/pci_vendors"
563
564     parser = argparse.ArgumentParser(
565         usage='usage: %(prog)s [-hrtp] [-d <pci id file>] elf_file',
566         description="Dump pmd hardware support info")
567     group = parser.add_mutually_exclusive_group()
568     group.add_argument('-r', '--raw',
569                        action='store_true', dest='raw_output',
570                        help='dump raw json strings')
571     group.add_argument("-t", "--table", dest="tblout",
572                        help="output information on hw support as a hex table",
573                        action='store_true')
574     parser.add_argument("-d", "--pcidb", dest="pcifile",
575                         help="specify a pci database to get vendor names from",
576                         default=pcifile_default, metavar="FILE")
577     parser.add_argument("-p", "--plugindir", dest="pdir",
578                         help="scan dpdk for autoload plugins",
579                         action='store_true')
580     parser.add_argument("elf_file", help="driver shared object file")
581     args = parser.parse_args()
582
583     if args.raw_output:
584         raw_output = True
585
586     if args.tblout:
587         args.pcifile = None
588
589     if args.pcifile:
590         pcidb = PCIIds(args.pcifile)
591         if pcidb is None:
592             print("Pci DB file not found")
593             exit(1)
594
595     if args.pdir:
596         exit(scan_for_autoload_pmds(args[0]))
597
598     ldlibpath = os.environ.get('LD_LIBRARY_PATH')
599     if ldlibpath is None:
600         ldlibpath = ""
601
602     if os.path.exists(args.elf_file):
603         myelffile = args.elf_file
604     else:
605         myelffile = search_file(args.elf_file,
606                                 ldlibpath + ":/usr/lib64:/lib64:/usr/lib:/lib")
607
608     if myelffile is None:
609         print("File not found")
610         sys.exit(1)
611
612     with open(myelffile, 'rb') as file:
613         try:
614             readelf = ReadElf(file, sys.stdout)
615             readelf.process_dt_needed_entries()
616             readelf.display_pmd_info_strings(".rodata")
617             sys.exit(0)
618
619         except ELFError as ex:
620             sys.stderr.write('ELF error: %s\n' % ex)
621             sys.exit(1)
622
623
624 # -------------------------------------------------------------------------
625 if __name__ == '__main__':
626     main()