app/testpmd: remove port status check from TM command
[dpdk.git] / usertools / dpdk-devbind.py
1 #! /usr/bin/env python
2 #
3 #   BSD LICENSE
4 #
5 #   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
6 #   All rights reserved.
7 #
8 #   Redistribution and use in source and binary forms, with or without
9 #   modification, are permitted provided that the following conditions
10 #   are met:
11 #
12 #     * Redistributions of source code must retain the above copyright
13 #       notice, this list of conditions and the following disclaimer.
14 #     * Redistributions in binary form must reproduce the above copyright
15 #       notice, this list of conditions and the following disclaimer in
16 #       the documentation and/or other materials provided with the
17 #       distribution.
18 #     * Neither the name of Intel Corporation nor the names of its
19 #       contributors may be used to endorse or promote products derived
20 #       from this software without specific prior written permission.
21 #
22 #   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 #   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 #   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 #   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 #   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 #   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 #   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 #   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 #   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 #   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 #   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #
34
35 import sys
36 import os
37 import getopt
38 import subprocess
39 from os.path import exists, abspath, dirname, basename
40
41 # The PCI base class for all devices
42 network_class = {'Class': '02', 'Vendor': None, 'Device': None,
43                     'SVendor': None, 'SDevice': None}
44 encryption_class = {'Class': '10', 'Vendor': None, 'Device': None,
45                    'SVendor': None, 'SDevice': None}
46 intel_processor_class = {'Class': '0b', 'Vendor': '8086', 'Device': None,
47                    'SVendor': None, 'SDevice': None}
48 cavium_sso = {'Class': '08', 'Vendor': '177d', 'Device': 'a04b,a04d',
49               'SVendor': None, 'SDevice': None}
50 cavium_fpa = {'Class': '08', 'Vendor': '177d', 'Device': 'a053',
51               'SVendor': None, 'SDevice': None}
52 cavium_pkx = {'Class': '08', 'Vendor': '177d', 'Device': 'a0dd,a049',
53               'SVendor': None, 'SDevice': None}
54
55 network_devices = [network_class, cavium_pkx]
56 crypto_devices = [encryption_class, intel_processor_class]
57 eventdev_devices = [cavium_sso]
58 mempool_devices = [cavium_fpa]
59
60 # global dict ethernet devices present. Dictionary indexed by PCI address.
61 # Each device within this is itself a dictionary of device properties
62 devices = {}
63 # list of supported DPDK drivers
64 dpdk_drivers = ["igb_uio", "vfio-pci", "uio_pci_generic"]
65
66 # command-line arg flags
67 b_flag = None
68 status_flag = False
69 force_flag = False
70 args = []
71
72
73 def usage():
74     '''Print usage information for the program'''
75     argv0 = basename(sys.argv[0])
76     print("""
77 Usage:
78 ------
79
80      %(argv0)s [options] DEVICE1 DEVICE2 ....
81
82 where DEVICE1, DEVICE2 etc, are specified via PCI "domain:bus:slot.func" syntax
83 or "bus:slot.func" syntax. For devices bound to Linux kernel drivers, they may
84 also be referred to by Linux interface name e.g. eth0, eth1, em0, em1, etc.
85
86 Options:
87     --help, --usage:
88         Display usage information and quit
89
90     -s, --status:
91         Print the current status of all known network, crypto, event
92         and mempool devices.
93         For each device, it displays the PCI domain, bus, slot and function,
94         along with a text description of the device. Depending upon whether the
95         device is being used by a kernel driver, the igb_uio driver, or no
96         driver, other relevant information will be displayed:
97         * the Linux interface name e.g. if=eth0
98         * the driver being used e.g. drv=igb_uio
99         * any suitable drivers not currently using that device
100             e.g. unused=igb_uio
101         NOTE: if this flag is passed along with a bind/unbind option, the
102         status display will always occur after the other operations have taken
103         place.
104
105     --status-dev:
106         Print the status of given device group. Supported device groups are:
107         "net", "crypto", "event" and "mempool"
108
109     -b driver, --bind=driver:
110         Select the driver to use or \"none\" to unbind the device
111
112     -u, --unbind:
113         Unbind a device (Equivalent to \"-b none\")
114
115     --force:
116         By default, network devices which are used by Linux - as indicated by
117         having routes in the routing table - cannot be modified. Using the
118         --force flag overrides this behavior, allowing active links to be
119         forcibly unbound.
120         WARNING: This can lead to loss of network connection and should be used
121         with caution.
122
123 Examples:
124 ---------
125
126 To display current device status:
127         %(argv0)s --status
128
129 To display current network device status:
130         %(argv0)s --status-dev net
131
132 To bind eth1 from the current driver and move to use igb_uio
133         %(argv0)s --bind=igb_uio eth1
134
135 To unbind 0000:01:00.0 from using any driver
136         %(argv0)s -u 0000:01:00.0
137
138 To bind 0000:02:00.0 and 0000:02:00.1 to the ixgbe kernel driver
139         %(argv0)s -b ixgbe 02:00.0 02:00.1
140
141     """ % locals())  # replace items from local variables
142
143
144 # This is roughly compatible with check_output function in subprocess module
145 # which is only available in python 2.7.
146 def check_output(args, stderr=None):
147     '''Run a command and capture its output'''
148     return subprocess.Popen(args, stdout=subprocess.PIPE,
149                             stderr=stderr).communicate()[0]
150
151
152 def find_module(mod):
153     '''find the .ko file for kernel module named mod.
154     Searches the $RTE_SDK/$RTE_TARGET directory, the kernel
155     modules directory and finally under the parent directory of
156     the script '''
157     # check $RTE_SDK/$RTE_TARGET directory
158     if 'RTE_SDK' in os.environ and 'RTE_TARGET' in os.environ:
159         path = "%s/%s/kmod/%s.ko" % (os.environ['RTE_SDK'],
160                                      os.environ['RTE_TARGET'], mod)
161         if exists(path):
162             return path
163
164     # check using depmod
165     try:
166         with open(os.devnull, "w") as fnull:
167             path = check_output(["modinfo", "-n", mod], stderr=fnull).strip()
168
169         if path and exists(path):
170             return path
171     except:  # if modinfo can't find module, it fails, so continue
172         pass
173
174     # check for a copy based off current path
175     tools_dir = dirname(abspath(sys.argv[0]))
176     if tools_dir.endswith("tools"):
177         base_dir = dirname(tools_dir)
178         find_out = check_output(["find", base_dir, "-name", mod + ".ko"])
179         if len(find_out) > 0:  # something matched
180             path = find_out.splitlines()[0]
181             if exists(path):
182                 return path
183
184
185 def check_modules():
186     '''Checks that igb_uio is loaded'''
187     global dpdk_drivers
188
189     # list of supported modules
190     mods = [{"Name": driver, "Found": False} for driver in dpdk_drivers]
191
192     # first check if module is loaded
193     try:
194         # Get list of sysfs modules (both built-in and dynamically loaded)
195         sysfs_path = '/sys/module/'
196
197         # Get the list of directories in sysfs_path
198         sysfs_mods = [os.path.join(sysfs_path, o) for o
199                       in os.listdir(sysfs_path)
200                       if os.path.isdir(os.path.join(sysfs_path, o))]
201
202         # Extract the last element of '/sys/module/abc' in the array
203         sysfs_mods = [a.split('/')[-1] for a in sysfs_mods]
204
205         # special case for vfio_pci (module is named vfio-pci,
206         # but its .ko is named vfio_pci)
207         sysfs_mods = [a if a != 'vfio_pci' else 'vfio-pci' for a in sysfs_mods]
208
209         for mod in mods:
210             if mod["Name"] in sysfs_mods:
211                 mod["Found"] = True
212     except:
213         pass
214
215     # check if we have at least one loaded module
216     if True not in [mod["Found"] for mod in mods] and b_flag is not None:
217         if b_flag in dpdk_drivers:
218             print("Error - no supported modules(DPDK driver) are loaded")
219             sys.exit(1)
220         else:
221             print("Warning - no supported modules(DPDK driver) are loaded")
222
223     # change DPDK driver list to only contain drivers that are loaded
224     dpdk_drivers = [mod["Name"] for mod in mods if mod["Found"]]
225
226
227 def has_driver(dev_id):
228     '''return true if a device is assigned to a driver. False otherwise'''
229     return "Driver_str" in devices[dev_id]
230
231
232 def get_pci_device_details(dev_id, probe_lspci):
233     '''This function gets additional details for a PCI device'''
234     device = {}
235
236     if probe_lspci:
237         extra_info = check_output(["lspci", "-vmmks", dev_id]).splitlines()
238
239         # parse lspci details
240         for line in extra_info:
241             if len(line) == 0:
242                 continue
243             name, value = line.decode().split("\t", 1)
244             name = name.strip(":") + "_str"
245             device[name] = value
246     # check for a unix interface name
247     device["Interface"] = ""
248     for base, dirs, _ in os.walk("/sys/bus/pci/devices/%s/" % dev_id):
249         if "net" in dirs:
250             device["Interface"] = \
251                 ",".join(os.listdir(os.path.join(base, "net")))
252             break
253     # check if a port is used for ssh connection
254     device["Ssh_if"] = False
255     device["Active"] = ""
256
257     return device
258
259 def clear_data():
260     '''This function clears any old data'''
261     devices = {}
262
263 def get_device_details(devices_type):
264     '''This function populates the "devices" dictionary. The keys used are
265     the pci addresses (domain:bus:slot.func). The values are themselves
266     dictionaries - one for each NIC.'''
267     global devices
268     global dpdk_drivers
269
270     # first loop through and read details for all devices
271     # request machine readable format, with numeric IDs and String
272     dev = {}
273     dev_lines = check_output(["lspci", "-Dvmmnnk"]).splitlines()
274     for dev_line in dev_lines:
275         if len(dev_line) == 0:
276             if device_type_match(dev, devices_type):
277                 # Replace "Driver" with "Driver_str" to have consistency of
278                 # of dictionary key names
279                 if "Driver" in dev.keys():
280                     dev["Driver_str"] = dev.pop("Driver")
281                 # use dict to make copy of dev
282                 devices[dev["Slot"]] = dict(dev)
283             # Clear previous device's data
284             dev = {}
285         else:
286             name, value = dev_line.decode().split("\t", 1)
287             value_list = value.rsplit(' ', 1)
288             if len(value_list) > 1:
289                 # String stored in <name>_str
290                 dev[name.rstrip(":") + '_str'] = value_list[0]
291             # Numeric IDs
292             dev[name.rstrip(":")] = value_list[len(value_list) - 1] \
293                 .rstrip("]").lstrip("[")
294
295     if devices_type == network_devices:
296         # check what is the interface if any for an ssh connection if
297         # any to this host, so we can mark it later.
298         ssh_if = []
299         route = check_output(["ip", "-o", "route"])
300         # filter out all lines for 169.254 routes
301         route = "\n".join(filter(lambda ln: not ln.startswith("169.254"),
302                              route.decode().splitlines()))
303         rt_info = route.split()
304         for i in range(len(rt_info) - 1):
305             if rt_info[i] == "dev":
306                 ssh_if.append(rt_info[i+1])
307
308     # based on the basic info, get extended text details
309     for d in devices.keys():
310         if not device_type_match(devices[d], devices_type):
311             continue
312
313         # get additional info and add it to existing data
314         devices[d] = devices[d].copy()
315         # No need to probe lspci
316         devices[d].update(get_pci_device_details(d, False).items())
317
318         if devices_type == network_devices:
319             for _if in ssh_if:
320                 if _if in devices[d]["Interface"].split(","):
321                     devices[d]["Ssh_if"] = True
322                     devices[d]["Active"] = "*Active*"
323                     break
324
325         # add igb_uio to list of supporting modules if needed
326         if "Module_str" in devices[d]:
327             for driver in dpdk_drivers:
328                 if driver not in devices[d]["Module_str"]:
329                     devices[d]["Module_str"] = \
330                         devices[d]["Module_str"] + ",%s" % driver
331         else:
332             devices[d]["Module_str"] = ",".join(dpdk_drivers)
333
334         # make sure the driver and module strings do not have any duplicates
335         if has_driver(d):
336             modules = devices[d]["Module_str"].split(",")
337             if devices[d]["Driver_str"] in modules:
338                 modules.remove(devices[d]["Driver_str"])
339                 devices[d]["Module_str"] = ",".join(modules)
340
341
342 def device_type_match(dev, devices_type):
343     for i in range(len(devices_type)):
344         param_count = len(
345             [x for x in devices_type[i].values() if x is not None])
346         match_count = 0
347         if dev["Class"][0:2] == devices_type[i]["Class"]:
348             match_count = match_count + 1
349             for key in devices_type[i].keys():
350                 if key != 'Class' and devices_type[i][key]:
351                     value_list = devices_type[i][key].split(',')
352                     for value in value_list:
353                         if value.strip(' ') == dev[key]:
354                             match_count = match_count + 1
355             # count must be the number of non None parameters to match
356             if match_count == param_count:
357                 return True
358     return False
359
360 def dev_id_from_dev_name(dev_name):
361     '''Take a device "name" - a string passed in by user to identify a NIC
362     device, and determine the device id - i.e. the domain:bus:slot.func - for
363     it, which can then be used to index into the devices array'''
364
365     # check if it's already a suitable index
366     if dev_name in devices:
367         return dev_name
368     # check if it's an index just missing the domain part
369     elif "0000:" + dev_name in devices:
370         return "0000:" + dev_name
371     else:
372         # check if it's an interface name, e.g. eth1
373         for d in devices.keys():
374             if dev_name in devices[d]["Interface"].split(","):
375                 return devices[d]["Slot"]
376     # if nothing else matches - error
377     print("Unknown device: %s. "
378           "Please specify device in \"bus:slot.func\" format" % dev_name)
379     sys.exit(1)
380
381
382 def unbind_one(dev_id, force):
383     '''Unbind the device identified by "dev_id" from its current driver'''
384     dev = devices[dev_id]
385     if not has_driver(dev_id):
386         print("%s %s %s is not currently managed by any driver\n" %
387               (dev["Slot"], dev["Device_str"], dev["Interface"]))
388         return
389
390     # prevent us disconnecting ourselves
391     if dev["Ssh_if"] and not force:
392         print("Routing table indicates that interface %s is active. "
393               "Skipping unbind" % (dev_id))
394         return
395
396     # write to /sys to unbind
397     filename = "/sys/bus/pci/drivers/%s/unbind" % dev["Driver_str"]
398     try:
399         f = open(filename, "a")
400     except:
401         print("Error: unbind failed for %s - Cannot open %s"
402               % (dev_id, filename))
403         sys.exit(1)
404     f.write(dev_id)
405     f.close()
406
407
408 def bind_one(dev_id, driver, force):
409     '''Bind the device given by "dev_id" to the driver "driver". If the device
410     is already bound to a different driver, it will be unbound first'''
411     dev = devices[dev_id]
412     saved_driver = None  # used to rollback any unbind in case of failure
413
414     # prevent disconnection of our ssh session
415     if dev["Ssh_if"] and not force:
416         print("Routing table indicates that interface %s is active. "
417               "Not modifying" % (dev_id))
418         return
419
420     # unbind any existing drivers we don't want
421     if has_driver(dev_id):
422         if dev["Driver_str"] == driver:
423             print("%s already bound to driver %s, skipping\n"
424                   % (dev_id, driver))
425             return
426         else:
427             saved_driver = dev["Driver_str"]
428             unbind_one(dev_id, force)
429             dev["Driver_str"] = ""  # clear driver string
430
431     # For kernels >= 3.15 driver_override can be used to specify the driver
432     # for a device rather than relying on the driver to provide a positive
433     # match of the device.  The existing process of looking up
434     # the vendor and device ID, adding them to the driver new_id,
435     # will erroneously bind other devices too which has the additional burden
436     # of unbinding those devices
437     if driver in dpdk_drivers:
438         filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
439         if os.path.exists(filename):
440             try:
441                 f = open(filename, "w")
442             except:
443                 print("Error: bind failed for %s - Cannot open %s"
444                       % (dev_id, filename))
445                 return
446             try:
447                 f.write("%s" % driver)
448                 f.close()
449             except:
450                 print("Error: bind failed for %s - Cannot write driver %s to "
451                       "PCI ID " % (dev_id, driver))
452                 return
453         # For kernels < 3.15 use new_id to add PCI id's to the driver
454         else:
455             filename = "/sys/bus/pci/drivers/%s/new_id" % driver
456             try:
457                 f = open(filename, "w")
458             except:
459                 print("Error: bind failed for %s - Cannot open %s"
460                       % (dev_id, filename))
461                 return
462             try:
463                 # Convert Device and Vendor Id to int to write to new_id
464                 f.write("%04x %04x" % (int(dev["Vendor"],16),
465                         int(dev["Device"], 16)))
466                 f.close()
467             except:
468                 print("Error: bind failed for %s - Cannot write new PCI ID to "
469                       "driver %s" % (dev_id, driver))
470                 return
471
472     # do the bind by writing to /sys
473     filename = "/sys/bus/pci/drivers/%s/bind" % driver
474     try:
475         f = open(filename, "a")
476     except:
477         print("Error: bind failed for %s - Cannot open %s"
478               % (dev_id, filename))
479         if saved_driver is not None:  # restore any previous driver
480             bind_one(dev_id, saved_driver, force)
481         return
482     try:
483         f.write(dev_id)
484         f.close()
485     except:
486         # for some reason, closing dev_id after adding a new PCI ID to new_id
487         # results in IOError. however, if the device was successfully bound,
488         # we don't care for any errors and can safely ignore IOError
489         tmp = get_pci_device_details(dev_id, True)
490         if "Driver_str" in tmp and tmp["Driver_str"] == driver:
491             return
492         print("Error: bind failed for %s - Cannot bind to driver %s"
493               % (dev_id, driver))
494         if saved_driver is not None:  # restore any previous driver
495             bind_one(dev_id, saved_driver, force)
496         return
497
498     # For kernels > 3.15 driver_override is used to bind a device to a driver.
499     # Before unbinding it, overwrite driver_override with empty string so that
500     # the device can be bound to any other driver
501     filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
502     if os.path.exists(filename):
503         try:
504             f = open(filename, "w")
505         except:
506             print("Error: unbind failed for %s - Cannot open %s"
507                   % (dev_id, filename))
508             sys.exit(1)
509         try:
510             f.write("\00")
511             f.close()
512         except:
513             print("Error: unbind failed for %s - Cannot open %s"
514                   % (dev_id, filename))
515             sys.exit(1)
516
517
518 def unbind_all(dev_list, force=False):
519     """Unbind method, takes a list of device locations"""
520
521     if dev_list[0] == "dpdk":
522         for d in devices.keys():
523             if "Driver_str" in devices[d]:
524                 if devices[d]["Driver_str"] in dpdk_drivers:
525                     unbind_one(devices[d]["Slot"], force)
526         return
527
528     dev_list = map(dev_id_from_dev_name, dev_list)
529     for d in dev_list:
530         unbind_one(d, force)
531
532
533 def bind_all(dev_list, driver, force=False):
534     """Bind method, takes a list of device locations"""
535     global devices
536
537     dev_list = map(dev_id_from_dev_name, dev_list)
538
539     for d in dev_list:
540         bind_one(d, driver, force)
541
542     # For kenels < 3.15 when binding devices to a generic driver
543     # (i.e. one that doesn't have a PCI ID table) using new_id, some devices
544     # that are not bound to any other driver could be bound even if no one has
545     # asked them to. hence, we check the list of drivers again, and see if
546     # some of the previously-unbound devices were erroneously bound.
547     if not os.path.exists("/sys/bus/pci/devices/%s/driver_override" % d):
548         for d in devices.keys():
549             # skip devices that were already bound or that we know should be bound
550             if "Driver_str" in devices[d] or d in dev_list:
551                 continue
552
553             # update information about this device
554             devices[d] = dict(devices[d].items() +
555                               get_pci_device_details(d, True).items())
556
557             # check if updated information indicates that the device was bound
558             if "Driver_str" in devices[d]:
559                 unbind_one(d, force)
560
561
562 def display_devices(title, dev_list, extra_params=None):
563     '''Displays to the user the details of a list of devices given in
564     "dev_list". The "extra_params" parameter, if given, should contain a string
565      with %()s fields in it for replacement by the named fields in each
566      device's dictionary.'''
567     strings = []  # this holds the strings to print. We sort before printing
568     print("\n%s" % title)
569     print("="*len(title))
570     if len(dev_list) == 0:
571         strings.append("<none>")
572     else:
573         for dev in dev_list:
574             if extra_params is not None:
575                 strings.append("%s '%s %s' %s" % (dev["Slot"],
576                                                dev["Device_str"],
577                                                dev["Device"],
578                                                extra_params % dev))
579             else:
580                 strings.append("%s '%s'" % (dev["Slot"], dev["Device_str"]))
581     # sort before printing, so that the entries appear in PCI order
582     strings.sort()
583     print("\n".join(strings))  # print one per line
584
585 def show_device_status(devices_type, device_name):
586     global dpdk_drivers
587     kernel_drv = []
588     dpdk_drv = []
589     no_drv = []
590
591     # split our list of network devices into the three categories above
592     for d in devices.keys():
593         if device_type_match(devices[d], devices_type):
594             if not has_driver(d):
595                 no_drv.append(devices[d])
596                 continue
597             if devices[d]["Driver_str"] in dpdk_drivers:
598                 dpdk_drv.append(devices[d])
599             else:
600                 kernel_drv.append(devices[d])
601
602     # print each category separately, so we can clearly see what's used by DPDK
603     display_devices("%s devices using DPDK-compatible driver" % device_name,
604                     dpdk_drv, "drv=%(Driver_str)s unused=%(Module_str)s")
605     display_devices("%s devices using kernel driver" % device_name, kernel_drv,
606                     "if=%(Interface)s drv=%(Driver_str)s "
607                     "unused=%(Module_str)s %(Active)s")
608     display_devices("Other %s devices" % device_name, no_drv,
609                     "unused=%(Module_str)s")
610
611 def show_status():
612     '''Function called when the script is passed the "--status" option.
613     Displays to the user what devices are bound to the igb_uio driver, the
614     kernel driver or to no driver'''
615
616     if status_dev == "net" or status_dev == "all":
617         show_device_status(network_devices, "Network")
618
619     if status_dev == "crypto" or status_dev == "all":
620         show_device_status(crypto_devices, "Crypto")
621
622     if status_dev == "event" or status_dev == "all":
623         show_device_status(eventdev_devices, "Eventdev")
624
625     if status_dev == "mempool" or status_dev == "all":
626         show_device_status(mempool_devices, "Mempool")
627
628 def parse_args():
629     '''Parses the command-line arguments given by the user and takes the
630     appropriate action for each'''
631     global b_flag
632     global status_flag
633     global status_dev
634     global force_flag
635     global args
636     if len(sys.argv) <= 1:
637         usage()
638         sys.exit(0)
639
640     try:
641         opts, args = getopt.getopt(sys.argv[1:], "b:us",
642                                    ["help", "usage", "status", "status-dev=",
643                                     "force", "bind=", "unbind", ])
644     except getopt.GetoptError as error:
645         print(str(error))
646         print("Run '%s --usage' for further information" % sys.argv[0])
647         sys.exit(1)
648
649     for opt, arg in opts:
650         if opt == "--help" or opt == "--usage":
651             usage()
652             sys.exit(0)
653         if opt == "--status-dev":
654             status_flag = True
655             status_dev = arg
656         if opt == "--status" or opt == "-s":
657             status_flag = True
658             status_dev = "all"
659         if opt == "--force":
660             force_flag = True
661         if opt == "-b" or opt == "-u" or opt == "--bind" or opt == "--unbind":
662             if b_flag is not None:
663                 print("Error - Only one bind or unbind may be specified\n")
664                 sys.exit(1)
665             if opt == "-u" or opt == "--unbind":
666                 b_flag = "none"
667             else:
668                 b_flag = arg
669
670
671 def do_arg_actions():
672     '''do the actual action requested by the user'''
673     global b_flag
674     global status_flag
675     global force_flag
676     global args
677
678     if b_flag is None and not status_flag:
679         print("Error: No action specified for devices."
680               "Please give a -b or -u option")
681         print("Run '%s --usage' for further information" % sys.argv[0])
682         sys.exit(1)
683
684     if b_flag is not None and len(args) == 0:
685         print("Error: No devices specified.")
686         print("Run '%s --usage' for further information" % sys.argv[0])
687         sys.exit(1)
688
689     if b_flag == "none" or b_flag == "None":
690         unbind_all(args, force_flag)
691     elif b_flag is not None:
692         bind_all(args, b_flag, force_flag)
693     if status_flag:
694         if b_flag is not None:
695             clear_data()
696             # refresh if we have changed anything
697             get_device_details(network_devices)
698             get_device_details(crypto_devices)
699             get_device_details(eventdev_devices)
700             get_device_details(mempool_devices)
701         show_status()
702
703
704 def main():
705     '''program main function'''
706     parse_args()
707     check_modules()
708     clear_data()
709     get_device_details(network_devices)
710     get_device_details(crypto_devices)
711     get_device_details(eventdev_devices)
712     get_device_details(mempool_devices)
713     do_arg_actions()
714
715 if __name__ == "__main__":
716     main()