i40e: fix crash on DCB query
[dpdk.git] / app / test / test_power_kvm_vm.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <stdio.h>
35 #include <stdint.h>
36 #include <unistd.h>
37 #include <limits.h>
38 #include <string.h>
39
40 #include "test.h"
41
42 #include <rte_power.h>
43
44 #define TEST_POWER_VM_LCORE_ID            0U
45 #define TEST_POWER_VM_LCORE_OUT_OF_BOUNDS (RTE_MAX_LCORE+1)
46 #define TEST_POWER_VM_LCORE_INVALID       1U
47
48 static int
49 test_power_kvm_vm(void)
50 {
51         int ret;
52         enum power_management_env env;
53
54         ret = rte_power_set_env(PM_ENV_KVM_VM);
55         if (ret != 0) {
56                 printf("Failed on setting environment to PM_ENV_KVM_VM\n");
57                 return -1;
58         }
59
60         /* Test environment configuration */
61         env = rte_power_get_env();
62         if (env != PM_ENV_KVM_VM) {
63                 printf("Unexpectedly got a Power Management environment other than "
64                                 "KVM VM\n");
65                 rte_power_unset_env();
66                 return -1;
67         }
68
69         /* verify that function pointers are not NULL */
70         if (rte_power_freqs == NULL) {
71                 printf("rte_power_freqs should not be NULL, environment has not been "
72                                 "initialised\n");
73                 return -1;
74         }
75         if (rte_power_get_freq == NULL) {
76                 printf("rte_power_get_freq should not be NULL, environment has not "
77                                 "been initialised\n");
78                 return -1;
79         }
80         if (rte_power_set_freq == NULL) {
81                 printf("rte_power_set_freq should not be NULL, environment has not "
82                                 "been initialised\n");
83                 return -1;
84         }
85         if (rte_power_freq_up == NULL) {
86                 printf("rte_power_freq_up should not be NULL, environment has not "
87                                 "been initialised\n");
88                 return -1;
89         }
90         if (rte_power_freq_down == NULL) {
91                 printf("rte_power_freq_down should not be NULL, environment has not "
92                                 "been initialised\n");
93                 return -1;
94         }
95         if (rte_power_freq_max == NULL) {
96                 printf("rte_power_freq_max should not be NULL, environment has not "
97                                 "been initialised\n");
98                 return -1;
99         }
100         if (rte_power_freq_min == NULL) {
101                 printf("rte_power_freq_min should not be NULL, environment has not "
102                                 "been initialised\n");
103                 return -1;
104         }
105         /* Test initialisation of an out of bounds lcore */
106         ret = rte_power_init(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
107         if (ret != -1) {
108                 printf("rte_power_init unexpectedly succeeded on an invalid lcore %u\n",
109                                 TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
110                 rte_power_unset_env();
111                 return -1;
112         }
113
114         /* Test initialisation of a valid lcore */
115         ret = rte_power_init(TEST_POWER_VM_LCORE_ID);
116         if (ret < 0) {
117                 printf("Cannot initialise power management for lcore %u, this "
118                                 "may occur if environment is not configured "
119                                 "correctly(KVM VM) or operating in another valid "
120                                 "Power management environment\n", TEST_POWER_VM_LCORE_ID);
121                 rte_power_unset_env();
122                 return -1;
123         }
124
125         /* Test initialisation of previously initialised lcore */
126         ret = rte_power_init(TEST_POWER_VM_LCORE_ID);
127         if (ret == 0) {
128                 printf("rte_power_init unexpectedly succeeded on calling init twice on"
129                                 " lcore %u\n", TEST_POWER_VM_LCORE_ID);
130                 goto fail_all;
131         }
132
133         /* Test frequency up of invalid lcore */
134         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
135         if (ret == 1) {
136                 printf("rte_power_freq_up unexpectedly succeeded on invalid lcore %u\n",
137                                 TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
138                 goto fail_all;
139         }
140
141         /* Test frequency down of invalid lcore */
142         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
143         if (ret == 1) {
144                 printf("rte_power_freq_down unexpectedly succeeded on invalid lcore "
145                                 "%u\n", TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
146                 goto fail_all;
147         }
148
149         /* Test frequency min of invalid lcore */
150         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
151         if (ret == 1) {
152                 printf("rte_power_freq_min unexpectedly succeeded on invalid lcore "
153                                 "%u\n", TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
154                 goto fail_all;
155         }
156
157         /* Test frequency max of invalid lcore */
158         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
159         if (ret == 1) {
160                 printf("rte_power_freq_max unexpectedly succeeded on invalid lcore "
161                                 "%u\n", TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
162                 goto fail_all;
163         }
164
165         /* Test frequency up of valid but uninitialised lcore */
166         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_INVALID);
167         if (ret == 1) {
168                 printf("rte_power_freq_up unexpectedly succeeded on invalid lcore %u\n",
169                                 TEST_POWER_VM_LCORE_INVALID);
170                 goto fail_all;
171         }
172
173         /* Test frequency down of valid but uninitialised lcore */
174         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_INVALID);
175         if (ret == 1) {
176                 printf("rte_power_freq_down unexpectedly succeeded on invalid lcore "
177                                 "%u\n", TEST_POWER_VM_LCORE_INVALID);
178                 goto fail_all;
179         }
180
181         /* Test frequency min of valid but uninitialised lcore */
182         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_INVALID);
183         if (ret == 1) {
184                 printf("rte_power_freq_min unexpectedly succeeded on invalid lcore "
185                                 "%u\n", TEST_POWER_VM_LCORE_INVALID);
186                 goto fail_all;
187         }
188
189         /* Test frequency max of valid but uninitialised lcore */
190         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_INVALID);
191         if (ret == 1) {
192                 printf("rte_power_freq_max unexpectedly succeeded on invalid lcore "
193                                 "%u\n", TEST_POWER_VM_LCORE_INVALID);
194                 goto fail_all;
195         }
196
197         /* Test frequency up of valid lcore */
198         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_ID);
199         if (ret != 1) {
200                 printf("rte_power_freq_up unexpectedly failed on valid lcore %u\n",
201                                 TEST_POWER_VM_LCORE_ID);
202                 goto fail_all;
203         }
204
205         /* Test frequency down of valid lcore */
206         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_ID);
207         if (ret != 1) {
208                 printf("rte_power_freq_down unexpectedly failed on valid lcore "
209                                 "%u\n", TEST_POWER_VM_LCORE_ID);
210                 goto fail_all;
211         }
212
213         /* Test frequency min of valid lcore */
214         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_ID);
215         if (ret != 1) {
216                 printf("rte_power_freq_min unexpectedly failed on valid lcore "
217                                 "%u\n", TEST_POWER_VM_LCORE_ID);
218                 goto fail_all;
219         }
220
221         /* Test frequency max of valid lcore */
222         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_ID);
223         if (ret != 1) {
224                 printf("rte_power_freq_max unexpectedly failed on valid lcore "
225                                 "%u\n", TEST_POWER_VM_LCORE_ID);
226                 goto fail_all;
227         }
228
229         /* Test unsupported rte_power_freqs */
230         ret = rte_power_freqs(TEST_POWER_VM_LCORE_ID, NULL, 0);
231         if (ret != -ENOTSUP) {
232                 printf("rte_power_freqs did not return the expected -ENOTSUP(%d) but "
233                                 "returned %d\n", -ENOTSUP, ret);
234                 goto fail_all;
235         }
236
237         /* Test unsupported rte_power_get_freq */
238         ret = rte_power_get_freq(TEST_POWER_VM_LCORE_ID);
239         if (ret != -ENOTSUP) {
240                 printf("rte_power_get_freq did not return the expected -ENOTSUP(%d) but"
241                                 " returned %d for lcore %u\n",
242                                 -ENOTSUP, ret, TEST_POWER_VM_LCORE_ID);
243                 goto fail_all;
244         }
245
246         /* Test unsupported rte_power_set_freq */
247         ret = rte_power_set_freq(TEST_POWER_VM_LCORE_ID, 0);
248         if (ret != -ENOTSUP) {
249                 printf("rte_power_set_freq did not return the expected -ENOTSUP(%d) but"
250                                 " returned %d for lcore %u\n",
251                                 -ENOTSUP, ret, TEST_POWER_VM_LCORE_ID);
252                 goto fail_all;
253         }
254
255         /* Test removing of an lcore */
256         ret = rte_power_exit(TEST_POWER_VM_LCORE_ID);
257         if (ret != 0) {
258                 printf("rte_power_exit unexpectedly failed on valid lcore %u,"
259                                 "please ensure that the environment has been configured "
260                                 "correctly\n", TEST_POWER_VM_LCORE_ID);
261                 goto fail_all;
262         }
263
264         /* Test frequency up of previously removed lcore */
265         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_ID);
266         if (ret == 0) {
267                 printf("rte_power_freq_up unexpectedly succeeded on a removed "
268                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
269                 return -1;
270         }
271
272         /* Test frequency down of previously removed lcore */
273         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_ID);
274         if (ret == 0) {
275                 printf("rte_power_freq_down unexpectedly succeeded on a removed "
276                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
277                 return -1;
278         }
279
280         /* Test frequency min of previously removed lcore */
281         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_ID);
282         if (ret == 0) {
283                 printf("rte_power_freq_min unexpectedly succeeded on a removed "
284                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
285                 return -1;
286         }
287
288         /* Test frequency max of previously removed lcore */
289         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_ID);
290         if (ret == 0) {
291                 printf("rte_power_freq_max unexpectedly succeeded on a removed "
292                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
293                 return -1;
294         }
295         rte_power_unset_env();
296         return 0;
297 fail_all:
298         rte_power_exit(TEST_POWER_VM_LCORE_ID);
299         rte_power_unset_env();
300         return -1;
301 }
302
303 static struct test_command power_kvm_vm_cmd = {
304         .command = "power_kvm_vm_autotest",
305         .callback = test_power_kvm_vm,
306 };
307 REGISTER_TEST_COMMAND(power_kvm_vm_cmd);