net/mlx5: make tunnel hub list thread safe
[dpdk.git] / usertools / dpdk-devbind.py
1 #!/usr/bin/env python3
2 # SPDX-License-Identifier: BSD-3-Clause
3 # Copyright(c) 2010-2014 Intel Corporation
4 #
5
6 import sys
7 import os
8 import getopt
9 import subprocess
10 from glob import glob
11 from os.path import exists, abspath, dirname, basename
12 from os.path import join as path_join
13
14 # The PCI base class for all devices
15 network_class = {'Class': '02', 'Vendor': None, 'Device': None,
16                     'SVendor': None, 'SDevice': None}
17 acceleration_class = {'Class': '12', 'Vendor': None, 'Device': None,
18                       'SVendor': None, 'SDevice': None}
19 ifpga_class = {'Class': '12', 'Vendor': '8086', 'Device': '0b30',
20                     'SVendor': None, 'SDevice': None}
21 encryption_class = {'Class': '10', 'Vendor': None, 'Device': None,
22                    'SVendor': None, 'SDevice': None}
23 intel_processor_class = {'Class': '0b', 'Vendor': '8086', 'Device': None,
24                    'SVendor': None, 'SDevice': None}
25 cavium_sso = {'Class': '08', 'Vendor': '177d', 'Device': 'a04b,a04d',
26               'SVendor': None, 'SDevice': None}
27 cavium_fpa = {'Class': '08', 'Vendor': '177d', 'Device': 'a053',
28               'SVendor': None, 'SDevice': None}
29 cavium_pkx = {'Class': '08', 'Vendor': '177d', 'Device': 'a0dd,a049',
30               'SVendor': None, 'SDevice': None}
31 cavium_tim = {'Class': '08', 'Vendor': '177d', 'Device': 'a051',
32               'SVendor': None, 'SDevice': None}
33 cavium_zip = {'Class': '12', 'Vendor': '177d', 'Device': 'a037',
34               'SVendor': None, 'SDevice': None}
35 avp_vnic = {'Class': '05', 'Vendor': '1af4', 'Device': '1110',
36               'SVendor': None, 'SDevice': None}
37
38 octeontx2_sso = {'Class': '08', 'Vendor': '177d', 'Device': 'a0f9,a0fa',
39               'SVendor': None, 'SDevice': None}
40 octeontx2_npa = {'Class': '08', 'Vendor': '177d', 'Device': 'a0fb,a0fc',
41               'SVendor': None, 'SDevice': None}
42 octeontx2_dma = {'Class': '08', 'Vendor': '177d', 'Device': 'a081',
43               'SVendor': None, 'SDevice': None}
44 octeontx2_ree = {'Class': '08', 'Vendor': '177d', 'Device': 'a0f4',
45               'SVendor': None, 'SDevice': None}
46
47 intel_ioat_bdw = {'Class': '08', 'Vendor': '8086', 'Device': '6f20,6f21,6f22,6f23,6f24,6f25,6f26,6f27,6f2e,6f2f',
48               'SVendor': None, 'SDevice': None}
49 intel_ioat_skx = {'Class': '08', 'Vendor': '8086', 'Device': '2021',
50               'SVendor': None, 'SDevice': None}
51 intel_ioat_icx = {'Class': '08', 'Vendor': '8086', 'Device': '0b00',
52               'SVendor': None, 'SDevice': None}
53 intel_idxd_spr = {'Class': '08', 'Vendor': '8086', 'Device': '0b25',
54               'SVendor': None, 'SDevice': None}
55 intel_ntb_skx = {'Class': '06', 'Vendor': '8086', 'Device': '201c',
56               'SVendor': None, 'SDevice': None}
57 intel_ntb_icx = {'Class': '06', 'Vendor': '8086', 'Device': '347e',
58               'SVendor': None, 'SDevice': None}
59
60 network_devices = [network_class, cavium_pkx, avp_vnic, ifpga_class]
61 baseband_devices = [acceleration_class]
62 crypto_devices = [encryption_class, intel_processor_class]
63 eventdev_devices = [cavium_sso, cavium_tim, octeontx2_sso]
64 mempool_devices = [cavium_fpa, octeontx2_npa]
65 compress_devices = [cavium_zip]
66 regex_devices = [octeontx2_ree]
67 misc_devices = [intel_ioat_bdw, intel_ioat_skx, intel_ioat_icx, intel_idxd_spr,
68                 intel_ntb_skx, intel_ntb_icx,
69                 octeontx2_dma]
70
71 # global dict ethernet devices present. Dictionary indexed by PCI address.
72 # Each device within this is itself a dictionary of device properties
73 devices = {}
74 # list of supported DPDK drivers
75 dpdk_drivers = ["igb_uio", "vfio-pci", "uio_pci_generic"]
76 # list of currently loaded kernel modules
77 loaded_modules = None
78
79 # command-line arg flags
80 b_flag = None
81 status_flag = False
82 force_flag = False
83 args = []
84
85
86 def usage():
87     '''Print usage information for the program'''
88     argv0 = basename(sys.argv[0])
89     print("""
90 Usage:
91 ------
92
93      %(argv0)s [options] DEVICE1 DEVICE2 ....
94
95 where DEVICE1, DEVICE2 etc, are specified via PCI "domain:bus:slot.func" syntax
96 or "bus:slot.func" syntax. For devices bound to Linux kernel drivers, they may
97 also be referred to by Linux interface name e.g. eth0, eth1, em0, em1, etc.
98 If devices are specified using PCI <domain:>bus:device:func format, then
99 shell wildcards and ranges may be used, e.g. 80:04.*, 80:04.[0-3]
100
101 Options:
102     --help, --usage:
103         Display usage information and quit
104
105     -s, --status:
106         Print the current status of all known network, crypto, event
107         and mempool devices.
108         For each device, it displays the PCI domain, bus, slot and function,
109         along with a text description of the device. Depending upon whether the
110         device is being used by a kernel driver, the igb_uio driver, or no
111         driver, other relevant information will be displayed:
112         * the Linux interface name e.g. if=eth0
113         * the driver being used e.g. drv=igb_uio
114         * any suitable drivers not currently using that device
115             e.g. unused=igb_uio
116         NOTE: if this flag is passed along with a bind/unbind option, the
117         status display will always occur after the other operations have taken
118         place.
119
120     --status-dev:
121         Print the status of given device group. Supported device groups are:
122         "net", "baseband", "crypto", "event", "mempool" and "compress"
123
124     -b driver, --bind=driver:
125         Select the driver to use or \"none\" to unbind the device
126
127     -u, --unbind:
128         Unbind a device (Equivalent to \"-b none\")
129
130     --force:
131         By default, network devices which are used by Linux - as indicated by
132         having routes in the routing table - cannot be modified. Using the
133         --force flag overrides this behavior, allowing active links to be
134         forcibly unbound.
135         WARNING: This can lead to loss of network connection and should be used
136         with caution.
137
138 Examples:
139 ---------
140
141 To display current device status:
142         %(argv0)s --status
143
144 To display current network device status:
145         %(argv0)s --status-dev net
146
147 To bind eth1 from the current driver and move to use igb_uio
148         %(argv0)s --bind=igb_uio eth1
149
150 To unbind 0000:01:00.0 from using any driver
151         %(argv0)s -u 0000:01:00.0
152
153 To bind 0000:02:00.0 and 0000:02:00.1 to the ixgbe kernel driver
154         %(argv0)s -b ixgbe 02:00.0 02:00.1
155
156 To bind all functions on device 0000:02:00 to ixgbe kernel driver
157         %(argv0)s -b ixgbe 02:00.*
158
159     """ % locals())  # replace items from local variables
160
161 # check if a specific kernel module is loaded
162 def module_is_loaded(module):
163     global loaded_modules
164
165     if module == 'vfio_pci':
166         module = 'vfio-pci'
167
168     if loaded_modules:
169         return module in loaded_modules
170
171     # Get list of sysfs modules (both built-in and dynamically loaded)
172     sysfs_path = '/sys/module/'
173
174     # Get the list of directories in sysfs_path
175     sysfs_mods = [m for m in os.listdir(sysfs_path)
176                   if os.path.isdir(os.path.join(sysfs_path, m))]
177
178     # special case for vfio_pci (module is named vfio-pci,
179     # but its .ko is named vfio_pci)
180     sysfs_mods = [a if a != 'vfio_pci' else 'vfio-pci' for a in sysfs_mods]
181
182     loaded_modules = sysfs_mods
183
184     return module in sysfs_mods
185
186
187 def check_modules():
188     '''Checks that igb_uio is loaded'''
189     global dpdk_drivers
190
191     # list of supported modules
192     mods = [{"Name": driver, "Found": False} for driver in dpdk_drivers]
193
194     # first check if module is loaded
195     for mod in mods:
196         if module_is_loaded(mod["Name"]):
197             mod["Found"] = True
198
199     # check if we have at least one loaded module
200     if True not in [mod["Found"] for mod in mods] and b_flag is not None:
201         print("Warning: no supported DPDK kernel modules are loaded", file=sys.stderr)
202
203     # change DPDK driver list to only contain drivers that are loaded
204     dpdk_drivers = [mod["Name"] for mod in mods if mod["Found"]]
205
206
207 def has_driver(dev_id):
208     '''return true if a device is assigned to a driver. False otherwise'''
209     return "Driver_str" in devices[dev_id]
210
211
212 def get_pci_device_details(dev_id, probe_lspci):
213     '''This function gets additional details for a PCI device'''
214     device = {}
215
216     if probe_lspci:
217         extra_info = subprocess.check_output(["lspci", "-vmmks", dev_id]).splitlines()
218         # parse lspci details
219         for line in extra_info:
220             if len(line) == 0:
221                 continue
222             name, value = line.decode("utf8").split("\t", 1)
223             name = name.strip(":") + "_str"
224             device[name] = value
225     # check for a unix interface name
226     device["Interface"] = ""
227     for base, dirs, _ in os.walk("/sys/bus/pci/devices/%s/" % dev_id):
228         if "net" in dirs:
229             device["Interface"] = \
230                 ",".join(os.listdir(os.path.join(base, "net")))
231             break
232     # check if a port is used for ssh connection
233     device["Ssh_if"] = False
234     device["Active"] = ""
235
236     return device
237
238 def clear_data():
239     '''This function clears any old data'''
240     global devices
241     devices = {}
242
243 def get_device_details(devices_type):
244     '''This function populates the "devices" dictionary. The keys used are
245     the pci addresses (domain:bus:slot.func). The values are themselves
246     dictionaries - one for each NIC.'''
247     global devices
248     global dpdk_drivers
249
250     # first loop through and read details for all devices
251     # request machine readable format, with numeric IDs and String
252     dev = {}
253     dev_lines = subprocess.check_output(["lspci", "-Dvmmnnk"]).splitlines()
254     for dev_line in dev_lines:
255         if len(dev_line) == 0:
256             if device_type_match(dev, devices_type):
257                 # Replace "Driver" with "Driver_str" to have consistency of
258                 # of dictionary key names
259                 if "Driver" in dev.keys():
260                     dev["Driver_str"] = dev.pop("Driver")
261                 if "Module" in dev.keys():
262                     dev["Module_str"] = dev.pop("Module")
263                 # use dict to make copy of dev
264                 devices[dev["Slot"]] = dict(dev)
265             # Clear previous device's data
266             dev = {}
267         else:
268             name, value = dev_line.decode("utf8").split("\t", 1)
269             value_list = value.rsplit(' ', 1)
270             if len(value_list) > 1:
271                 # String stored in <name>_str
272                 dev[name.rstrip(":") + '_str'] = value_list[0]
273             # Numeric IDs
274             dev[name.rstrip(":")] = value_list[len(value_list) - 1] \
275                 .rstrip("]").lstrip("[")
276
277     if devices_type == network_devices:
278         # check what is the interface if any for an ssh connection if
279         # any to this host, so we can mark it later.
280         ssh_if = []
281         route = subprocess.check_output(["ip", "-o", "route"])
282         # filter out all lines for 169.254 routes
283         route = "\n".join(filter(lambda ln: not ln.startswith("169.254"),
284                              route.decode().splitlines()))
285         rt_info = route.split()
286         for i in range(len(rt_info) - 1):
287             if rt_info[i] == "dev":
288                 ssh_if.append(rt_info[i+1])
289
290     # based on the basic info, get extended text details
291     for d in devices.keys():
292         if not device_type_match(devices[d], devices_type):
293             continue
294
295         # get additional info and add it to existing data
296         devices[d] = devices[d].copy()
297         # No need to probe lspci
298         devices[d].update(get_pci_device_details(d, False).items())
299
300         if devices_type == network_devices:
301             for _if in ssh_if:
302                 if _if in devices[d]["Interface"].split(","):
303                     devices[d]["Ssh_if"] = True
304                     devices[d]["Active"] = "*Active*"
305                     break
306
307         # add igb_uio to list of supporting modules if needed
308         if "Module_str" in devices[d]:
309             for driver in dpdk_drivers:
310                 if driver not in devices[d]["Module_str"]:
311                     devices[d]["Module_str"] = \
312                         devices[d]["Module_str"] + ",%s" % driver
313         else:
314             devices[d]["Module_str"] = ",".join(dpdk_drivers)
315
316         # make sure the driver and module strings do not have any duplicates
317         if has_driver(d):
318             modules = devices[d]["Module_str"].split(",")
319             if devices[d]["Driver_str"] in modules:
320                 modules.remove(devices[d]["Driver_str"])
321                 devices[d]["Module_str"] = ",".join(modules)
322
323
324 def device_type_match(dev, devices_type):
325     for i in range(len(devices_type)):
326         param_count = len(
327             [x for x in devices_type[i].values() if x is not None])
328         match_count = 0
329         if dev["Class"][0:2] == devices_type[i]["Class"]:
330             match_count = match_count + 1
331             for key in devices_type[i].keys():
332                 if key != 'Class' and devices_type[i][key]:
333                     value_list = devices_type[i][key].split(',')
334                     for value in value_list:
335                         if value.strip(' ') == dev[key]:
336                             match_count = match_count + 1
337             # count must be the number of non None parameters to match
338             if match_count == param_count:
339                 return True
340     return False
341
342 def dev_id_from_dev_name(dev_name):
343     '''Take a device "name" - a string passed in by user to identify a NIC
344     device, and determine the device id - i.e. the domain:bus:slot.func - for
345     it, which can then be used to index into the devices array'''
346
347     # check if it's already a suitable index
348     if dev_name in devices:
349         return dev_name
350     # check if it's an index just missing the domain part
351     elif "0000:" + dev_name in devices:
352         return "0000:" + dev_name
353     else:
354         # check if it's an interface name, e.g. eth1
355         for d in devices.keys():
356             if dev_name in devices[d]["Interface"].split(","):
357                 return devices[d]["Slot"]
358     # if nothing else matches - error
359     raise ValueError("Unknown device: %s. "
360                      "Please specify device in \"bus:slot.func\" format" % dev_name)
361
362
363 def unbind_one(dev_id, force):
364     '''Unbind the device identified by "dev_id" from its current driver'''
365     dev = devices[dev_id]
366     if not has_driver(dev_id):
367         print("Notice: %s %s %s is not currently managed by any driver" %
368               (dev["Slot"], dev["Device_str"], dev["Interface"]), file=sys.stderr)
369         return
370
371     # prevent us disconnecting ourselves
372     if dev["Ssh_if"] and not force:
373         print("Warning: routing table indicates that interface %s is active. "
374               "Skipping unbind" % dev_id, file=sys.stderr)
375         return
376
377     # write to /sys to unbind
378     filename = "/sys/bus/pci/drivers/%s/unbind" % dev["Driver_str"]
379     try:
380         f = open(filename, "a")
381     except:
382         sys.exit("Error: unbind failed for %s - Cannot open %s" %
383                  (dev_id, filename))
384     f.write(dev_id)
385     f.close()
386
387
388 def bind_one(dev_id, driver, force):
389     '''Bind the device given by "dev_id" to the driver "driver". If the device
390     is already bound to a different driver, it will be unbound first'''
391     dev = devices[dev_id]
392     saved_driver = None  # used to rollback any unbind in case of failure
393
394     # prevent disconnection of our ssh session
395     if dev["Ssh_if"] and not force:
396         print("Warning: routing table indicates that interface %s is active. "
397               "Not modifying" % dev_id, file=sys.stderr)
398         return
399
400     # unbind any existing drivers we don't want
401     if has_driver(dev_id):
402         if dev["Driver_str"] == driver:
403             print("Notice: %s already bound to driver %s, skipping" %
404                   (dev_id, driver), file=sys.stderr)
405             return
406         else:
407             saved_driver = dev["Driver_str"]
408             unbind_one(dev_id, force)
409             dev["Driver_str"] = ""  # clear driver string
410
411     # For kernels >= 3.15 driver_override can be used to specify the driver
412     # for a device rather than relying on the driver to provide a positive
413     # match of the device.  The existing process of looking up
414     # the vendor and device ID, adding them to the driver new_id,
415     # will erroneously bind other devices too which has the additional burden
416     # of unbinding those devices
417     if driver in dpdk_drivers:
418         filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
419         if os.path.exists(filename):
420             try:
421                 f = open(filename, "w")
422             except:
423                 print("Error: bind failed for %s - Cannot open %s"
424                       % (dev_id, filename), file=sys.stderr)
425                 return
426             try:
427                 f.write("%s" % driver)
428                 f.close()
429             except:
430                 print("Error: bind failed for %s - Cannot write driver %s to "
431                       "PCI ID " % (dev_id, driver), file=sys.stderr)
432                 return
433         # For kernels < 3.15 use new_id to add PCI id's to the driver
434         else:
435             filename = "/sys/bus/pci/drivers/%s/new_id" % driver
436             try:
437                 f = open(filename, "w")
438             except:
439                 print("Error: bind failed for %s - Cannot open %s"
440                       % (dev_id, filename), file=sys.stderr)
441                 return
442             try:
443                 # Convert Device and Vendor Id to int to write to new_id
444                 f.write("%04x %04x" % (int(dev["Vendor"],16),
445                         int(dev["Device"], 16)))
446                 f.close()
447             except:
448                 print("Error: bind failed for %s - Cannot write new PCI ID to "
449                       "driver %s" % (dev_id, driver), file=sys.stderr)
450                 return
451
452     # do the bind by writing to /sys
453     filename = "/sys/bus/pci/drivers/%s/bind" % driver
454     try:
455         f = open(filename, "a")
456     except:
457         print("Error: bind failed for %s - Cannot open %s"
458               % (dev_id, filename), file=sys.stderr)
459         if saved_driver is not None:  # restore any previous driver
460             bind_one(dev_id, saved_driver, force)
461         return
462     try:
463         f.write(dev_id)
464         f.close()
465     except:
466         # for some reason, closing dev_id after adding a new PCI ID to new_id
467         # results in IOError. however, if the device was successfully bound,
468         # we don't care for any errors and can safely ignore IOError
469         tmp = get_pci_device_details(dev_id, True)
470         if "Driver_str" in tmp and tmp["Driver_str"] == driver:
471             return
472         print("Error: bind failed for %s - Cannot bind to driver %s"
473               % (dev_id, driver), file=sys.stderr)
474         if saved_driver is not None:  # restore any previous driver
475             bind_one(dev_id, saved_driver, force)
476         return
477
478     # For kernels > 3.15 driver_override is used to bind a device to a driver.
479     # Before unbinding it, overwrite driver_override with empty string so that
480     # the device can be bound to any other driver
481     filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
482     if os.path.exists(filename):
483         try:
484             f = open(filename, "w")
485         except:
486             sys.exit("Error: unbind failed for %s - Cannot open %s"
487                   % (dev_id, filename))
488         try:
489             f.write("\00")
490             f.close()
491         except:
492             sys.exit("Error: unbind failed for %s - Cannot open %s"
493                   % (dev_id, filename))
494
495
496 def unbind_all(dev_list, force=False):
497     """Unbind method, takes a list of device locations"""
498
499     if dev_list[0] == "dpdk":
500         for d in devices.keys():
501             if "Driver_str" in devices[d]:
502                 if devices[d]["Driver_str"] in dpdk_drivers:
503                     unbind_one(devices[d]["Slot"], force)
504         return
505
506     try:
507         dev_list = map(dev_id_from_dev_name, dev_list)
508     except ValueError as ex:
509         print(ex)
510         sys.exit(1)
511
512     for d in dev_list:
513         unbind_one(d, force)
514
515
516 def bind_all(dev_list, driver, force=False):
517     """Bind method, takes a list of device locations"""
518     global devices
519
520     # a common user error is to forget to specify the driver the devices need to
521     # be bound to. check if the driver is a valid device, and if it is, show
522     # a meaningful error.
523     try:
524         dev_id_from_dev_name(driver)
525         # if we've made it this far, this means that the "driver" was a valid
526         # device string, so it's probably not a valid driver name.
527         sys.exit("Error: Driver '%s' does not look like a valid driver. " \
528                  "Did you forget to specify the driver to bind devices to?" % driver)
529     except ValueError:
530         # driver generated error - it's not a valid device ID, so all is well
531         pass
532
533     # check if we're attempting to bind to a driver that isn't loaded
534     if not module_is_loaded(driver.replace('-','_')):
535         sys.exit("Error: Driver '%s' is not loaded." % driver)
536
537     try:
538         dev_list = map(dev_id_from_dev_name, dev_list)
539     except ValueError as ex:
540         sys.exit(ex)
541
542     for d in dev_list:
543         bind_one(d, driver, force)
544
545     # For kernels < 3.15 when binding devices to a generic driver
546     # (i.e. one that doesn't have a PCI ID table) using new_id, some devices
547     # that are not bound to any other driver could be bound even if no one has
548     # asked them to. hence, we check the list of drivers again, and see if
549     # some of the previously-unbound devices were erroneously bound.
550     if not os.path.exists("/sys/bus/pci/devices/%s/driver_override" % d):
551         for d in devices.keys():
552             # skip devices that were already bound or that we know should be bound
553             if "Driver_str" in devices[d] or d in dev_list:
554                 continue
555
556             # update information about this device
557             devices[d] = dict(devices[d].items() +
558                               get_pci_device_details(d, True).items())
559
560             # check if updated information indicates that the device was bound
561             if "Driver_str" in devices[d]:
562                 unbind_one(d, force)
563
564
565 def display_devices(title, dev_list, extra_params=None):
566     '''Displays to the user the details of a list of devices given in
567     "dev_list". The "extra_params" parameter, if given, should contain a string
568      with %()s fields in it for replacement by the named fields in each
569      device's dictionary.'''
570     strings = []  # this holds the strings to print. We sort before printing
571     print("\n%s" % title)
572     print("="*len(title))
573     if len(dev_list) == 0:
574         strings.append("<none>")
575     else:
576         for dev in dev_list:
577             if extra_params is not None:
578                 strings.append("%s '%s %s' %s" % (dev["Slot"],
579                                                dev["Device_str"],
580                                                dev["Device"],
581                                                extra_params % dev))
582             else:
583                 strings.append("%s '%s'" % (dev["Slot"], dev["Device_str"]))
584     # sort before printing, so that the entries appear in PCI order
585     strings.sort()
586     print("\n".join(strings))  # print one per line
587
588 def show_device_status(devices_type, device_name, if_field=False):
589     global dpdk_drivers
590     kernel_drv = []
591     dpdk_drv = []
592     no_drv = []
593
594     # split our list of network devices into the three categories above
595     for d in devices.keys():
596         if device_type_match(devices[d], devices_type):
597             if not has_driver(d):
598                 no_drv.append(devices[d])
599                 continue
600             if devices[d]["Driver_str"] in dpdk_drivers:
601                 dpdk_drv.append(devices[d])
602             else:
603                 kernel_drv.append(devices[d])
604
605     n_devs = len(dpdk_drv) + len(kernel_drv) + len(no_drv)
606
607     # don't bother displaying anything if there are no devices
608     if n_devs == 0:
609         msg = "No '%s' devices detected" % device_name
610         print("")
611         print(msg)
612         print("".join('=' * len(msg)))
613         return
614
615     # print each category separately, so we can clearly see what's used by DPDK
616     if len(dpdk_drv) != 0:
617         display_devices("%s devices using DPDK-compatible driver" % device_name,
618                         dpdk_drv, "drv=%(Driver_str)s unused=%(Module_str)s")
619     if len(kernel_drv) != 0:
620         if_text = ""
621         if if_field:
622             if_text = "if=%(Interface)s "
623         display_devices("%s devices using kernel driver" % device_name, kernel_drv,
624                         if_text + "drv=%(Driver_str)s "
625                         "unused=%(Module_str)s %(Active)s")
626     if len(no_drv) != 0:
627         display_devices("Other %s devices" % device_name, no_drv,
628                         "unused=%(Module_str)s")
629
630 def show_status():
631     '''Function called when the script is passed the "--status" option.
632     Displays to the user what devices are bound to the igb_uio driver, the
633     kernel driver or to no driver'''
634
635     if status_dev == "net" or status_dev == "all":
636         show_device_status(network_devices, "Network", if_field=True)
637
638     if status_dev == "baseband" or status_dev == "all":
639         show_device_status(baseband_devices, "Baseband")
640
641     if status_dev == "crypto" or status_dev == "all":
642         show_device_status(crypto_devices, "Crypto")
643
644     if status_dev == "event" or status_dev == "all":
645         show_device_status(eventdev_devices, "Eventdev")
646
647     if status_dev == "mempool" or status_dev == "all":
648         show_device_status(mempool_devices, "Mempool")
649
650     if status_dev == "compress" or status_dev == "all":
651         show_device_status(compress_devices , "Compress")
652
653     if status_dev == "misc" or status_dev == "all":
654         show_device_status(misc_devices, "Misc (rawdev)")
655
656     if status_dev == "regex" or status_dev == "all":
657         show_device_status(regex_devices, "Regex")
658
659
660 def pci_glob(arg):
661     '''Returns a list containing either:
662     * List of PCI B:D:F matching arg, using shell wildcards e.g. 80:04.*
663     * Only the passed arg if matching list is empty'''
664     sysfs_path = "/sys/bus/pci/devices"
665     for _glob in [arg, '0000:' + arg]:
666         paths = [basename(path) for path in glob(path_join(sysfs_path, _glob))]
667         if paths:
668             return paths
669     return [arg]
670
671
672 def parse_args():
673     '''Parses the command-line arguments given by the user and takes the
674     appropriate action for each'''
675     global b_flag
676     global status_flag
677     global status_dev
678     global force_flag
679     global args
680     if len(sys.argv) <= 1:
681         usage()
682         sys.exit(0)
683
684     try:
685         opts, args = getopt.getopt(sys.argv[1:], "b:us",
686                                    ["help", "usage", "status", "status-dev=",
687                                     "force", "bind=", "unbind", ])
688     except getopt.GetoptError as error:
689         print(str(error))
690         print("Run '%s --usage' for further information" % sys.argv[0])
691         sys.exit(1)
692
693     for opt, arg in opts:
694         if opt == "--help" or opt == "--usage":
695             usage()
696             sys.exit(0)
697         if opt == "--status-dev":
698             status_flag = True
699             status_dev = arg
700         if opt == "--status" or opt == "-s":
701             status_flag = True
702             status_dev = "all"
703         if opt == "--force":
704             force_flag = True
705         if opt == "-b" or opt == "-u" or opt == "--bind" or opt == "--unbind":
706             if b_flag is not None:
707                 sys.exit("Error: binding and unbinding are mutually exclusive")
708             if opt == "-u" or opt == "--unbind":
709                 b_flag = "none"
710             else:
711                 b_flag = arg
712
713     # resolve any PCI globs in the args
714     new_args = []
715     for arg in args:
716         new_args.extend(pci_glob(arg))
717     args = new_args
718
719 def do_arg_actions():
720     '''do the actual action requested by the user'''
721     global b_flag
722     global status_flag
723     global force_flag
724     global args
725
726     if b_flag is None and not status_flag:
727         print("Error: No action specified for devices. "
728               "Please give a -b or -u option", file=sys.stderr)
729         usage()
730         sys.exit(1)
731
732     if b_flag is not None and len(args) == 0:
733         print("Error: No devices specified.", file=sys.stderr)
734         usage()
735         sys.exit(1)
736
737     if b_flag == "none" or b_flag == "None":
738         unbind_all(args, force_flag)
739     elif b_flag is not None:
740         bind_all(args, b_flag, force_flag)
741     if status_flag:
742         if b_flag is not None:
743             clear_data()
744             # refresh if we have changed anything
745             get_device_details(network_devices)
746             get_device_details(baseband_devices)
747             get_device_details(crypto_devices)
748             get_device_details(eventdev_devices)
749             get_device_details(mempool_devices)
750             get_device_details(compress_devices)
751             get_device_details(regex_devices)
752             get_device_details(misc_devices)
753         show_status()
754
755
756 def main():
757     '''program main function'''
758     # check if lspci is installed, suppress any output
759     with open(os.devnull, 'w') as devnull:
760         ret = subprocess.call(['which', 'lspci'],
761                               stdout=devnull, stderr=devnull)
762         if ret != 0:
763             sys.exit("'lspci' not found - please install 'pciutils'")
764     parse_args()
765     check_modules()
766     clear_data()
767     get_device_details(network_devices)
768     get_device_details(baseband_devices)
769     get_device_details(crypto_devices)
770     get_device_details(eventdev_devices)
771     get_device_details(mempool_devices)
772     get_device_details(compress_devices)
773     get_device_details(regex_devices)
774     get_device_details(misc_devices)
775     do_arg_actions()
776
777 if __name__ == "__main__":
778     main()