xref: /dpdk/usertools/dpdk-devbind.py (revision d4f44265a1d74d270da2a6deaec8938b2f1b49d4)
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
35import sys
36import os
37import getopt
38import subprocess
39from os.path import exists, abspath, dirname, basename
40
41# The PCI base class for all devices
42network_class = {'Class': '02', 'Vendor': None, 'Device': None,
43                    'SVendor': None, 'SDevice': None}
44encryption_class = {'Class': '10', 'Vendor': None, 'Device': None,
45                   'SVendor': None, 'SDevice': None}
46intel_processor_class = {'Class': '0b', 'Vendor': '8086', 'Device': None,
47                   'SVendor': None, 'SDevice': None}
48cavium_sso = {'Class': '08', 'Vendor': '177d', 'Device': 'a04b,a04d',
49              'SVendor': None, 'SDevice': None}
50cavium_fpa = {'Class': '08', 'Vendor': '177d', 'Device': 'a053',
51              'SVendor': None, 'SDevice': None}
52
53network_devices = [network_class]
54crypto_devices = [encryption_class, intel_processor_class]
55eventdev_devices = [cavium_sso]
56mempool_devices = [cavium_fpa]
57
58# global dict ethernet devices present. Dictionary indexed by PCI address.
59# Each device within this is itself a dictionary of device properties
60devices = {}
61# list of supported DPDK drivers
62dpdk_drivers = ["igb_uio", "vfio-pci", "uio_pci_generic"]
63
64# command-line arg flags
65b_flag = None
66status_flag = False
67force_flag = False
68args = []
69
70
71def usage():
72    '''Print usage information for the program'''
73    argv0 = basename(sys.argv[0])
74    print("""
75Usage:
76------
77
78     %(argv0)s [options] DEVICE1 DEVICE2 ....
79
80where DEVICE1, DEVICE2 etc, are specified via PCI "domain:bus:slot.func" syntax
81or "bus:slot.func" syntax. For devices bound to Linux kernel drivers, they may
82also be referred to by Linux interface name e.g. eth0, eth1, em0, em1, etc.
83
84Options:
85    --help, --usage:
86        Display usage information and quit
87
88    -s, --status:
89        Print the current status of all known network, crypto, event
90        and mempool devices.
91        For each device, it displays the PCI domain, bus, slot and function,
92        along with a text description of the device. Depending upon whether the
93        device is being used by a kernel driver, the igb_uio driver, or no
94        driver, other relevant information will be displayed:
95        * the Linux interface name e.g. if=eth0
96        * the driver being used e.g. drv=igb_uio
97        * any suitable drivers not currently using that device
98            e.g. unused=igb_uio
99        NOTE: if this flag is passed along with a bind/unbind option, the
100        status display will always occur after the other operations have taken
101        place.
102
103    --status-dev:
104        Print the status of given device group. Supported device groups are:
105        "net", "crypto", "event" and "mempool"
106
107    -b driver, --bind=driver:
108        Select the driver to use or \"none\" to unbind the device
109
110    -u, --unbind:
111        Unbind a device (Equivalent to \"-b none\")
112
113    --force:
114        By default, network devices which are used by Linux - as indicated by
115        having routes in the routing table - cannot be modified. Using the
116        --force flag overrides this behavior, allowing active links to be
117        forcibly unbound.
118        WARNING: This can lead to loss of network connection and should be used
119        with caution.
120
121Examples:
122---------
123
124To display current device status:
125        %(argv0)s --status
126
127To display current network device status:
128        %(argv0)s --status-dev net
129
130To bind eth1 from the current driver and move to use igb_uio
131        %(argv0)s --bind=igb_uio eth1
132
133To unbind 0000:01:00.0 from using any driver
134        %(argv0)s -u 0000:01:00.0
135
136To bind 0000:02:00.0 and 0000:02:00.1 to the ixgbe kernel driver
137        %(argv0)s -b ixgbe 02:00.0 02:00.1
138
139    """ % locals())  # replace items from local variables
140
141
142# This is roughly compatible with check_output function in subprocess module
143# which is only available in python 2.7.
144def check_output(args, stderr=None):
145    '''Run a command and capture its output'''
146    return subprocess.Popen(args, stdout=subprocess.PIPE,
147                            stderr=stderr).communicate()[0]
148
149
150def find_module(mod):
151    '''find the .ko file for kernel module named mod.
152    Searches the $RTE_SDK/$RTE_TARGET directory, the kernel
153    modules directory and finally under the parent directory of
154    the script '''
155    # check $RTE_SDK/$RTE_TARGET directory
156    if 'RTE_SDK' in os.environ and 'RTE_TARGET' in os.environ:
157        path = "%s/%s/kmod/%s.ko" % (os.environ['RTE_SDK'],
158                                     os.environ['RTE_TARGET'], mod)
159        if exists(path):
160            return path
161
162    # check using depmod
163    try:
164        depmod_out = check_output(["modinfo", "-n", mod],
165                                  stderr=subprocess.STDOUT).lower()
166        if "error" not in depmod_out:
167            path = depmod_out.strip()
168            if exists(path):
169                return path
170    except:  # if modinfo can't find module, it fails, so continue
171        pass
172
173    # check for a copy based off current path
174    tools_dir = dirname(abspath(sys.argv[0]))
175    if tools_dir.endswith("tools"):
176        base_dir = dirname(tools_dir)
177        find_out = check_output(["find", base_dir, "-name", mod + ".ko"])
178        if len(find_out) > 0:  # something matched
179            path = find_out.splitlines()[0]
180            if exists(path):
181                return path
182
183
184def check_modules():
185    '''Checks that igb_uio is loaded'''
186    global dpdk_drivers
187
188    # list of supported modules
189    mods = [{"Name": driver, "Found": False} for driver in dpdk_drivers]
190
191    # first check if module is loaded
192    try:
193        # Get list of sysfs modules (both built-in and dynamically loaded)
194        sysfs_path = '/sys/module/'
195
196        # Get the list of directories in sysfs_path
197        sysfs_mods = [os.path.join(sysfs_path, o) for o
198                      in os.listdir(sysfs_path)
199                      if os.path.isdir(os.path.join(sysfs_path, o))]
200
201        # Extract the last element of '/sys/module/abc' in the array
202        sysfs_mods = [a.split('/')[-1] for a in sysfs_mods]
203
204        # special case for vfio_pci (module is named vfio-pci,
205        # but its .ko is named vfio_pci)
206        sysfs_mods = map(lambda a:
207                         a if a != 'vfio_pci' else 'vfio-pci', 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
227def 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
232def 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
259def clear_data():
260    '''This function clears any old data'''
261    devices = {}
262
263def 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
342def 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            else:
359                return False
360
361def dev_id_from_dev_name(dev_name):
362    '''Take a device "name" - a string passed in by user to identify a NIC
363    device, and determine the device id - i.e. the domain:bus:slot.func - for
364    it, which can then be used to index into the devices array'''
365
366    # check if it's already a suitable index
367    if dev_name in devices:
368        return dev_name
369    # check if it's an index just missing the domain part
370    elif "0000:" + dev_name in devices:
371        return "0000:" + dev_name
372    else:
373        # check if it's an interface name, e.g. eth1
374        for d in devices.keys():
375            if dev_name in devices[d]["Interface"].split(","):
376                return devices[d]["Slot"]
377    # if nothing else matches - error
378    print("Unknown device: %s. "
379          "Please specify device in \"bus:slot.func\" format" % dev_name)
380    sys.exit(1)
381
382
383def unbind_one(dev_id, force):
384    '''Unbind the device identified by "dev_id" from its current driver'''
385    dev = devices[dev_id]
386    if not has_driver(dev_id):
387        print("%s %s %s is not currently managed by any driver\n" %
388              (dev["Slot"], dev["Device_str"], dev["Interface"]))
389        return
390
391    # prevent us disconnecting ourselves
392    if dev["Ssh_if"] and not force:
393        print("Routing table indicates that interface %s is active. "
394              "Skipping unbind" % (dev_id))
395        return
396
397    # write to /sys to unbind
398    filename = "/sys/bus/pci/drivers/%s/unbind" % dev["Driver_str"]
399    try:
400        f = open(filename, "a")
401    except:
402        print("Error: unbind failed for %s - Cannot open %s"
403              % (dev_id, filename))
404        sys.exit(1)
405    f.write(dev_id)
406    f.close()
407
408
409def bind_one(dev_id, driver, force):
410    '''Bind the device given by "dev_id" to the driver "driver". If the device
411    is already bound to a different driver, it will be unbound first'''
412    dev = devices[dev_id]
413    saved_driver = None  # used to rollback any unbind in case of failure
414
415    # prevent disconnection of our ssh session
416    if dev["Ssh_if"] and not force:
417        print("Routing table indicates that interface %s is active. "
418              "Not modifying" % (dev_id))
419        return
420
421    # unbind any existing drivers we don't want
422    if has_driver(dev_id):
423        if dev["Driver_str"] == driver:
424            print("%s already bound to driver %s, skipping\n"
425                  % (dev_id, driver))
426            return
427        else:
428            saved_driver = dev["Driver_str"]
429            unbind_one(dev_id, force)
430            dev["Driver_str"] = ""  # clear driver string
431
432    # For kernels >= 3.15 driver_override can be used to specify the driver
433    # for a device rather than relying on the driver to provide a positive
434    # match of the device.  The existing process of looking up
435    # the vendor and device ID, adding them to the driver new_id,
436    # will erroneously bind other devices too which has the additional burden
437    # of unbinding those devices
438    if driver in dpdk_drivers:
439        filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
440        if os.path.exists(filename):
441            try:
442                f = open(filename, "w")
443            except:
444                print("Error: bind failed for %s - Cannot open %s"
445                      % (dev_id, filename))
446                return
447            try:
448                f.write("%s" % driver)
449                f.close()
450            except:
451                print("Error: bind failed for %s - Cannot write driver %s to "
452                      "PCI ID " % (dev_id, driver))
453                return
454        # For kernels < 3.15 use new_id to add PCI id's to the driver
455        else:
456            filename = "/sys/bus/pci/drivers/%s/new_id" % driver
457            try:
458                f = open(filename, "w")
459            except:
460                print("Error: bind failed for %s - Cannot open %s"
461                      % (dev_id, filename))
462                return
463            try:
464                # Convert Device and Vendor Id to int to write to new_id
465                f.write("%04x %04x" % (int(dev["Vendor"],16),
466                        int(dev["Device"], 16)))
467                f.close()
468            except:
469                print("Error: bind failed for %s - Cannot write new PCI ID to "
470                      "driver %s" % (dev_id, driver))
471                return
472
473    # do the bind by writing to /sys
474    filename = "/sys/bus/pci/drivers/%s/bind" % driver
475    try:
476        f = open(filename, "a")
477    except:
478        print("Error: bind failed for %s - Cannot open %s"
479              % (dev_id, filename))
480        if saved_driver is not None:  # restore any previous driver
481            bind_one(dev_id, saved_driver, force)
482        return
483    try:
484        f.write(dev_id)
485        f.close()
486    except:
487        # for some reason, closing dev_id after adding a new PCI ID to new_id
488        # results in IOError. however, if the device was successfully bound,
489        # we don't care for any errors and can safely ignore IOError
490        tmp = get_pci_device_details(dev_id, True)
491        if "Driver_str" in tmp and tmp["Driver_str"] == driver:
492            return
493        print("Error: bind failed for %s - Cannot bind to driver %s"
494              % (dev_id, driver))
495        if saved_driver is not None:  # restore any previous driver
496            bind_one(dev_id, saved_driver, force)
497        return
498
499    # For kernels > 3.15 driver_override is used to bind a device to a driver.
500    # Before unbinding it, overwrite driver_override with empty string so that
501    # the device can be bound to any other driver
502    filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
503    if os.path.exists(filename):
504        try:
505            f = open(filename, "w")
506        except:
507            print("Error: unbind failed for %s - Cannot open %s"
508                  % (dev_id, filename))
509            sys.exit(1)
510        try:
511            f.write("\00")
512            f.close()
513        except:
514            print("Error: unbind failed for %s - Cannot open %s"
515                  % (dev_id, filename))
516            sys.exit(1)
517
518
519def unbind_all(dev_list, force=False):
520    """Unbind method, takes a list of device locations"""
521    dev_list = map(dev_id_from_dev_name, dev_list)
522    for d in dev_list:
523        unbind_one(d, force)
524
525
526def bind_all(dev_list, driver, force=False):
527    """Bind method, takes a list of device locations"""
528    global devices
529
530    dev_list = map(dev_id_from_dev_name, dev_list)
531
532    for d in dev_list:
533        bind_one(d, driver, force)
534
535    # For kenels < 3.15 when binding devices to a generic driver
536    # (i.e. one that doesn't have a PCI ID table) using new_id, some devices
537    # that are not bound to any other driver could be bound even if no one has
538    # asked them to. hence, we check the list of drivers again, and see if
539    # some of the previously-unbound devices were erroneously bound.
540    if not os.path.exists("/sys/bus/pci/devices/%s/driver_override" % d):
541        for d in devices.keys():
542            # skip devices that were already bound or that we know should be bound
543            if "Driver_str" in devices[d] or d in dev_list:
544                continue
545
546            # update information about this device
547            devices[d] = dict(devices[d].items() +
548                              get_pci_device_details(d, True).items())
549
550            # check if updated information indicates that the device was bound
551            if "Driver_str" in devices[d]:
552                unbind_one(d, force)
553
554
555def display_devices(title, dev_list, extra_params=None):
556    '''Displays to the user the details of a list of devices given in
557    "dev_list". The "extra_params" parameter, if given, should contain a string
558     with %()s fields in it for replacement by the named fields in each
559     device's dictionary.'''
560    strings = []  # this holds the strings to print. We sort before printing
561    print("\n%s" % title)
562    print("="*len(title))
563    if len(dev_list) == 0:
564        strings.append("<none>")
565    else:
566        for dev in dev_list:
567            if extra_params is not None:
568                strings.append("%s '%s %s' %s" % (dev["Slot"],
569                                               dev["Device_str"],
570                                               dev["Device"],
571                                               extra_params % dev))
572            else:
573                strings.append("%s '%s'" % (dev["Slot"], dev["Device_str"]))
574    # sort before printing, so that the entries appear in PCI order
575    strings.sort()
576    print("\n".join(strings))  # print one per line
577
578def show_device_status(devices_type, device_name):
579    global dpdk_drivers
580    kernel_drv = []
581    dpdk_drv = []
582    no_drv = []
583
584    # split our list of network devices into the three categories above
585    for d in devices.keys():
586        if device_type_match(devices[d], devices_type):
587            if not has_driver(d):
588                no_drv.append(devices[d])
589                continue
590            if devices[d]["Driver_str"] in dpdk_drivers:
591                dpdk_drv.append(devices[d])
592            else:
593                kernel_drv.append(devices[d])
594
595    # print each category separately, so we can clearly see what's used by DPDK
596    display_devices("%s devices using DPDK-compatible driver" % device_name,
597                    dpdk_drv, "drv=%(Driver_str)s unused=%(Module_str)s")
598    display_devices("%s devices using kernel driver" % device_name, kernel_drv,
599                    "if=%(Interface)s drv=%(Driver_str)s "
600                    "unused=%(Module_str)s %(Active)s")
601    display_devices("Other %s devices" % device_name, no_drv,
602                    "unused=%(Module_str)s")
603
604def show_status():
605    '''Function called when the script is passed the "--status" option.
606    Displays to the user what devices are bound to the igb_uio driver, the
607    kernel driver or to no driver'''
608
609    if status_dev == "net" or status_dev == "all":
610        show_device_status(network_devices, "Network")
611
612    if status_dev == "crypto" or status_dev == "all":
613        show_device_status(crypto_devices, "Crypto")
614
615    if status_dev == "event" or status_dev == "all":
616        show_device_status(eventdev_devices, "Eventdev")
617
618    if status_dev == "mempool" or status_dev == "all":
619        show_device_status(mempool_devices, "Mempool")
620
621def parse_args():
622    '''Parses the command-line arguments given by the user and takes the
623    appropriate action for each'''
624    global b_flag
625    global status_flag
626    global status_dev
627    global force_flag
628    global args
629    if len(sys.argv) <= 1:
630        usage()
631        sys.exit(0)
632
633    try:
634        opts, args = getopt.getopt(sys.argv[1:], "b:us",
635                                   ["help", "usage", "status", "status-dev=",
636                                    "force", "bind=", "unbind", ])
637    except getopt.GetoptError as error:
638        print(str(error))
639        print("Run '%s --usage' for further information" % sys.argv[0])
640        sys.exit(1)
641
642    for opt, arg in opts:
643        if opt == "--help" or opt == "--usage":
644            usage()
645            sys.exit(0)
646        if opt == "--status-dev":
647            status_flag = True
648            status_dev = arg
649        if opt == "--status" or opt == "-s":
650            status_flag = True
651            status_dev = "all"
652        if opt == "--force":
653            force_flag = True
654        if opt == "-b" or opt == "-u" or opt == "--bind" or opt == "--unbind":
655            if b_flag is not None:
656                print("Error - Only one bind or unbind may be specified\n")
657                sys.exit(1)
658            if opt == "-u" or opt == "--unbind":
659                b_flag = "none"
660            else:
661                b_flag = arg
662
663
664def do_arg_actions():
665    '''do the actual action requested by the user'''
666    global b_flag
667    global status_flag
668    global force_flag
669    global args
670
671    if b_flag is None and not status_flag:
672        print("Error: No action specified for devices."
673              "Please give a -b or -u option")
674        print("Run '%s --usage' for further information" % sys.argv[0])
675        sys.exit(1)
676
677    if b_flag is not None and len(args) == 0:
678        print("Error: No devices specified.")
679        print("Run '%s --usage' for further information" % sys.argv[0])
680        sys.exit(1)
681
682    if b_flag == "none" or b_flag == "None":
683        unbind_all(args, force_flag)
684    elif b_flag is not None:
685        bind_all(args, b_flag, force_flag)
686    if status_flag:
687        if b_flag is not None:
688            clear_data()
689            # refresh if we have changed anything
690            get_device_details(network_devices)
691            get_device_details(crypto_devices)
692            get_device_details(eventdev_devices)
693            get_device_details(mempool_devices)
694        show_status()
695
696
697def main():
698    '''program main function'''
699    parse_args()
700    check_modules()
701    clear_data()
702    get_device_details(network_devices)
703    get_device_details(crypto_devices)
704    get_device_details(eventdev_devices)
705    get_device_details(mempool_devices)
706    do_arg_actions()
707
708if __name__ == "__main__":
709    main()
710