CSIT-861: SW cryptodev perf tests
[csit.git] / resources / libraries / python / DUTSetup.py
1 # Copyright (c) 2016 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """DUT setup library."""
15
16 from robot.api import logger
17
18 from resources.libraries.python.topology import NodeType, Topology
19 from resources.libraries.python.ssh import SSH
20 from resources.libraries.python.constants import Constants
21 from resources.libraries.python.VatExecutor import VatExecutor
22 from resources.libraries.python.VPPUtil import VPPUtil
23
24
25 class DUTSetup(object):
26     """Contains methods for setting up DUTs."""
27     @staticmethod
28     def start_vpp_service_on_all_duts(nodes):
29         """Start up the VPP service on all nodes."""
30         ssh = SSH()
31         for node in nodes.values():
32             if node['type'] == NodeType.DUT:
33                 ssh.connect(node)
34                 (ret_code, stdout, stderr) = \
35                     ssh.exec_command_sudo('service vpp restart', timeout=120)
36                 if int(ret_code) != 0:
37                     logger.debug('stdout: {0}'.format(stdout))
38                     logger.debug('stderr: {0}'.format(stderr))
39                     raise Exception('DUT {0} failed to start VPP service'.
40                                     format(node['host']))
41
42     @staticmethod
43     def vpp_show_version_verbose(node):
44         """Run "show version verbose" CLI command.
45
46         :param node: Node to run command on.
47         :type node: dict
48         """
49         vat = VatExecutor()
50         vat.execute_script("show_version_verbose.vat", node, json_out=False)
51
52     @staticmethod
53     def show_vpp_version_on_all_duts(nodes):
54         """Show VPP version verbose on all DUTs.
55
56         :param nodes: VPP nodes
57         :type nodes: dict
58         """
59         for node in nodes.values():
60             if node['type'] == NodeType.DUT:
61                 DUTSetup.vpp_show_version_verbose(node)
62
63     @staticmethod
64     def vpp_api_trace_save(node):
65         """Run "api trace save" CLI command.
66
67         :param node: Node to run command on.
68         :type node: dict
69         """
70         vat = VatExecutor()
71         vat.execute_script("api_trace_save.vat", node, json_out=False)
72
73     @staticmethod
74     def vpp_api_trace_dump(node):
75         """Run "api trace custom-dump" CLI command.
76
77         :param node: Node to run command on.
78         :type node: dict
79         """
80         vat = VatExecutor()
81         vat.execute_script("api_trace_dump.vat", node, json_out=False)
82
83     @staticmethod
84     def setup_all_duts(nodes):
85         """Prepare all DUTs in given topology for test execution."""
86         for node in nodes.values():
87             if node['type'] == NodeType.DUT:
88                 DUTSetup.setup_dut(node)
89
90     @staticmethod
91     def setup_dut(node):
92         """Run script over SSH to setup the DUT node.
93
94         :param node: DUT node to set up.
95         :type node: dict
96
97         :raises Exception: If the DUT setup fails.
98         """
99         ssh = SSH()
100         ssh.connect(node)
101
102         (ret_code, stdout, stderr) = \
103             ssh.exec_command('sudo -Sn bash {0}/{1}/dut_setup.sh'.
104                              format(Constants.REMOTE_FW_DIR,
105                                     Constants.RESOURCES_LIB_SH), timeout=120)
106         logger.trace(stdout)
107         logger.trace(stderr)
108         if int(ret_code) != 0:
109             logger.debug('DUT {0} setup script failed: "{1}"'.
110                          format(node['host'], stdout + stderr))
111             raise Exception('DUT test setup script failed at node {}'.
112                             format(node['host']))
113
114     @staticmethod
115     def get_vpp_pid(node):
116         """Get PID of running VPP process.
117
118         :param node: DUT node.
119         :type node: dict
120         :returns: PID
121         :rtype: int
122         :raises RuntimeError if it is not possible to get the PID.
123         """
124
125         ssh = SSH()
126         ssh.connect(node)
127
128         for i in range(3):
129             logger.trace('Try {}: Get VPP PID'.format(i))
130             ret_code, stdout, stderr = ssh.exec_command('pidof vpp')
131
132             if int(ret_code) != 0:
133                 raise RuntimeError('Not possible to get PID of VPP process '
134                                    'on node: {0}\n {1}'.
135                                    format(node['host'], stdout + stderr))
136
137             if len(stdout.splitlines()) == 1:
138                 return int(stdout)
139             elif len(stdout.splitlines()) == 0:
140                 logger.debug("No VPP PID found on node {0}".
141                              format(node['host']))
142                 continue
143             else:
144                 logger.debug("More then one VPP PID found on node {0}".
145                              format(node['host']))
146                 ret_list = list()
147                 for line in stdout.splitlines():
148                     ret_list.append(int(line))
149                 return ret_list
150
151         return None
152
153     @staticmethod
154     def get_vpp_pids(nodes):
155         """Get PID of running VPP process on all DUTs.
156
157         :param nodes: DUT nodes.
158         :type nodes: dict
159         :returns: PIDs
160         :rtype: dict
161         """
162
163         pids = dict()
164         for node in nodes.values():
165             if node['type'] == NodeType.DUT:
166                 pids[node['host']] = DUTSetup.get_vpp_pid(node)
167         return pids
168
169     @staticmethod
170     def vpp_show_crypto_device_mapping(node):
171         """Run "show crypto device mapping" CLI command.
172
173         :param node: Node to run command on.
174         :type node: dict
175         """
176         vat = VatExecutor()
177         vat.execute_script("show_crypto_device_mapping.vat", node,
178                            json_out=False)
179
180     @staticmethod
181     def crypto_device_verify(node, force_init=False, numvfs=32):
182         """Verify if Crypto QAT device virtual functions are initialized on all
183         DUTs. If parameter force initialization is set to True, then try to
184         initialize or disable QAT.
185
186         :param node: DUT node.
187         :param force_init: If True then try to initialize to specific value.
188         :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
189         :type node: dict
190         :type force_init: bool
191         :type numvfs: int
192         :returns: nothing
193         :raises RuntimeError: If QAT is not initialized or failed to initialize.
194         """
195
196         ssh = SSH()
197         ssh.connect(node)
198
199         cryptodev = Topology.get_cryptodev(node)
200         cmd = 'cat /sys/bus/pci/devices/{0}/sriov_numvfs'.\
201             format(cryptodev.replace(':', r'\:'))
202
203         # Try to read number of VFs from PCI address of QAT device
204         for _ in range(3):
205             ret_code, stdout, _ = ssh.exec_command(cmd)
206             if int(ret_code) == 0:
207                 try:
208                     sriov_numvfs = int(stdout)
209                 except ValueError:
210                     logger.trace('Reading sriov_numvfs info failed on {0}'.
211                                  format(node['host']))
212                 else:
213                     if sriov_numvfs != numvfs:
214                         if force_init:
215                             # QAT is not initialized and we want to initialize
216                             # with numvfs
217                             DUTSetup.crypto_device_init(node, numvfs)
218                         else:
219                             raise RuntimeError('QAT device {0} is not '
220                                                'initialized to {1} on host {2}'
221                                                .format(cryptodev, numvfs,
222                                                        node['host']))
223                     break
224
225     @staticmethod
226     def crypto_device_init(node, numvfs):
227         """Init Crypto QAT device virtual functions on DUT.
228
229         :param node: DUT node.
230         :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
231         :type node: dict
232         :type numvfs: int
233         :returns: nothing
234         :raises RuntimeError: If failed to stop VPP or QAT failed to initialize.
235         """
236         cryptodev = Topology.get_cryptodev(node)
237
238         # QAT device must be re-bound to kernel driver before initialization
239         driver = 'dh895xcc'
240         kernel_module = 'qat_dh895xcc'
241         current_driver = DUTSetup.get_pci_dev_driver(
242             node, cryptodev.replace(':', r'\:'))
243
244         DUTSetup.kernel_module_verify(node, kernel_module, force_load=True)
245
246         VPPUtil.stop_vpp_service(node)
247         if current_driver is not None:
248             DUTSetup.pci_driver_unbind(node, cryptodev)
249         DUTSetup.pci_driver_bind(node, cryptodev, driver)
250
251         ssh = SSH()
252         ssh.connect(node)
253
254         # Initialize QAT VFs
255         if numvfs > 0:
256             cmd = 'echo "{0}" | tee /sys/bus/pci/devices/{1}/sriov_numvfs'.\
257                 format(numvfs, cryptodev.replace(':', r'\:'), timeout=180)
258             ret_code, _, _ = ssh.exec_command_sudo("sh -c '{0}'".format(cmd))
259
260             if int(ret_code) != 0:
261                 raise RuntimeError('Failed to initialize {0} VFs on QAT device '
262                                    ' on host {1}'.format(numvfs, node['host']))
263
264     @staticmethod
265     def pci_driver_unbind(node, pci_addr):
266         """Unbind PCI device from current driver on node.
267
268         :param node: DUT node.
269         :param pci_addr: PCI device address.
270         :type node: dict
271         :type pci_addr: str
272         :returns: nothing
273         :raises RuntimeError: If PCI device unbind failed.
274         """
275
276         ssh = SSH()
277         ssh.connect(node)
278
279         ret_code, _, _ = ssh.exec_command_sudo(
280             "sh -c 'echo {0} | tee /sys/bus/pci/devices/{1}/driver/unbind'"
281             .format(pci_addr, pci_addr.replace(':', r'\:')), timeout=180)
282
283         if int(ret_code) != 0:
284             raise RuntimeError('Failed to unbind PCI device {0} from driver on '
285                                'host {1}'.format(pci_addr, node['host']))
286
287     @staticmethod
288     def pci_driver_bind(node, pci_addr, driver):
289         """Bind PCI device to driver on node.
290
291         :param node: DUT node.
292         :param pci_addr: PCI device address.
293         :param driver: Driver to bind.
294         :type node: dict
295         :type pci_addr: str
296         :type driver: str
297         :returns: nothing
298         :raises RuntimeError: If PCI device bind failed.
299         """
300
301         ssh = SSH()
302         ssh.connect(node)
303
304         ret_code, _, _ = ssh.exec_command_sudo(
305             "sh -c 'echo {0} | tee /sys/bus/pci/drivers/{1}/bind'".format(
306                 pci_addr, driver), timeout=180)
307
308         if int(ret_code) != 0:
309             raise RuntimeError('Failed to bind PCI device {0} to {1} driver on '
310                                'host {2}'.format(pci_addr, driver,
311                                                  node['host']))
312
313     @staticmethod
314     def get_pci_dev_driver(node, pci_addr):
315         """Get current PCI device driver on node.
316
317         :param node: DUT node.
318         :param pci_addr: PCI device address.
319         :type node: dict
320         :type pci_addr: str
321         :returns: Driver or None
322         :raises RuntimeError: If PCI rescan or lspci command execution failed.
323         """
324         ssh = SSH()
325         ssh.connect(node)
326
327         for i in range(3):
328             logger.trace('Try {0}: Get interface driver'.format(i))
329             cmd = 'sh -c "echo 1 > /sys/bus/pci/rescan"'
330             ret_code, _, _ = ssh.exec_command_sudo(cmd)
331             if int(ret_code) != 0:
332                 raise RuntimeError("'{0}' failed on '{1}'"
333                                    .format(cmd, node['host']))
334
335             cmd = 'lspci -vmmks {0}'.format(pci_addr)
336             ret_code, stdout, _ = ssh.exec_command(cmd)
337             if int(ret_code) != 0:
338                 raise RuntimeError("'{0}' failed on '{1}'"
339                                    .format(cmd, node['host']))
340
341             for line in stdout.splitlines():
342                 if len(line) == 0:
343                     continue
344                 name = None
345                 value = None
346                 try:
347                     name, value = line.split("\t", 1)
348                 except ValueError:
349                     if name == "Driver:":
350                         return None
351                 if name == 'Driver:':
352                     return value
353         else:
354             return None
355
356     @staticmethod
357     def kernel_module_verify(node, module, force_load=False):
358         """Verify if kernel module is loaded on all DUTs. If parameter force
359         load is set to True, then try to load the modules.
360
361         :param node: DUT node.
362         :param module: Module to verify.
363         :param force_load: If True then try to load module.
364         :type node: dict
365         :type module: str
366         :type force_load: bool
367         :returns: nothing
368         :raises RuntimeError: If module is not loaded or failed to load.
369         """
370
371         ssh = SSH()
372         ssh.connect(node)
373
374         cmd = 'grep -w {0} /proc/modules'.format(module)
375         ret_code, _, _ = ssh.exec_command(cmd)
376
377         if int(ret_code) != 0:
378             if force_load:
379                 # Module is not loaded and we want to load it
380                 DUTSetup.kernel_module_load(node, module)
381             else:
382                 raise RuntimeError('Kernel module {0} is not loaded on host '
383                                    '{1}'.format(module, node['host']))
384
385     @staticmethod
386     def kernel_module_load(node, module):
387         """Load kernel module on node.
388
389         :param node: DUT node.
390         :param module: Module to load.
391         :type node: dict
392         :type module: str
393         :returns: nothing
394         :raises RuntimeError: If loading failed.
395         """
396
397         ssh = SSH()
398         ssh.connect(node)
399
400         ret_code, _, _ = ssh.exec_command_sudo("modprobe {0}".format(module))
401
402         if int(ret_code) != 0:
403             raise RuntimeError('Failed to load {0} kernel module on host {1}'.
404                                format(module, node['host']))

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.