doc: remove release version from known issues
[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 #include <rte_config.h>
44
45 #define TEST_POWER_VM_LCORE_ID            0U
46 #define TEST_POWER_VM_LCORE_OUT_OF_BOUNDS (RTE_MAX_LCORE+1)
47 #define TEST_POWER_VM_LCORE_INVALID       1U
48
49 static int
50 test_power_kvm_vm(void)
51 {
52         int ret;
53         enum power_management_env env;
54
55         ret = rte_power_set_env(PM_ENV_KVM_VM);
56         if (ret != 0) {
57                 printf("Failed on setting environment to PM_ENV_KVM_VM\n");
58                 return -1;
59         }
60
61         /* Test environment configuration */
62         env = rte_power_get_env();
63         if (env != PM_ENV_KVM_VM) {
64                 printf("Unexpectedly got a Power Management environment other than "
65                                 "KVM VM\n");
66                 rte_power_unset_env();
67                 return -1;
68         }
69
70         /* verify that function pointers are not NULL */
71         if (rte_power_freqs == NULL) {
72                 printf("rte_power_freqs should not be NULL, environment has not been "
73                                 "initialised\n");
74                 return -1;
75         }
76         if (rte_power_get_freq == NULL) {
77                 printf("rte_power_get_freq should not be NULL, environment has not "
78                                 "been initialised\n");
79                 return -1;
80         }
81         if (rte_power_set_freq == NULL) {
82                 printf("rte_power_set_freq should not be NULL, environment has not "
83                                 "been initialised\n");
84                 return -1;
85         }
86         if (rte_power_freq_up == NULL) {
87                 printf("rte_power_freq_up should not be NULL, environment has not "
88                                 "been initialised\n");
89                 return -1;
90         }
91         if (rte_power_freq_down == NULL) {
92                 printf("rte_power_freq_down should not be NULL, environment has not "
93                                 "been initialised\n");
94                 return -1;
95         }
96         if (rte_power_freq_max == NULL) {
97                 printf("rte_power_freq_max should not be NULL, environment has not "
98                                 "been initialised\n");
99                 return -1;
100         }
101         if (rte_power_freq_min == NULL) {
102                 printf("rte_power_freq_min should not be NULL, environment has not "
103                                 "been initialised\n");
104                 return -1;
105         }
106         /* Test initialisation of an out of bounds lcore */
107         ret = rte_power_init(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
108         if (ret != -1) {
109                 printf("rte_power_init unexpectedly succeeded on an invalid lcore %u\n",
110                                 TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
111                 rte_power_unset_env();
112                 return -1;
113         }
114
115         /* Test initialisation of a valid lcore */
116         ret = rte_power_init(TEST_POWER_VM_LCORE_ID);
117         if (ret < 0) {
118                 printf("Cannot initialise power management for lcore %u, this "
119                                 "may occur if environment is not configured "
120                                 "correctly(KVM VM) or operating in another valid "
121                                 "Power management environment\n", TEST_POWER_VM_LCORE_ID);
122                 rte_power_unset_env();
123                 return -1;
124         }
125
126         /* Test initialisation of previously initialised lcore */
127         ret = rte_power_init(TEST_POWER_VM_LCORE_ID);
128         if (ret == 0) {
129                 printf("rte_power_init unexpectedly succeeded on calling init twice on"
130                                 " lcore %u\n", TEST_POWER_VM_LCORE_ID);
131                 goto fail_all;
132         }
133
134         /* Test frequency up of invalid lcore */
135         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
136         if (ret == 1) {
137                 printf("rte_power_freq_up unexpectedly succeeded on invalid lcore %u\n",
138                                 TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
139                 goto fail_all;
140         }
141
142         /* Test frequency down of invalid lcore */
143         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
144         if (ret == 1) {
145                 printf("rte_power_freq_down unexpectedly succeeded on invalid lcore "
146                                 "%u\n", TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
147                 goto fail_all;
148         }
149
150         /* Test frequency min of invalid lcore */
151         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
152         if (ret == 1) {
153                 printf("rte_power_freq_min unexpectedly succeeded on invalid lcore "
154                                 "%u\n", TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
155                 goto fail_all;
156         }
157
158         /* Test frequency max of invalid lcore */
159         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
160         if (ret == 1) {
161                 printf("rte_power_freq_max unexpectedly succeeded on invalid lcore "
162                                 "%u\n", TEST_POWER_VM_LCORE_OUT_OF_BOUNDS);
163                 goto fail_all;
164         }
165
166         /* Test frequency up of valid but uninitialised lcore */
167         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_INVALID);
168         if (ret == 1) {
169                 printf("rte_power_freq_up unexpectedly succeeded on invalid lcore %u\n",
170                                 TEST_POWER_VM_LCORE_INVALID);
171                 goto fail_all;
172         }
173
174         /* Test frequency down of valid but uninitialised lcore */
175         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_INVALID);
176         if (ret == 1) {
177                 printf("rte_power_freq_down unexpectedly succeeded on invalid lcore "
178                                 "%u\n", TEST_POWER_VM_LCORE_INVALID);
179                 goto fail_all;
180         }
181
182         /* Test frequency min of valid but uninitialised lcore */
183         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_INVALID);
184         if (ret == 1) {
185                 printf("rte_power_freq_min unexpectedly succeeded on invalid lcore "
186                                 "%u\n", TEST_POWER_VM_LCORE_INVALID);
187                 goto fail_all;
188         }
189
190         /* Test frequency max of valid but uninitialised lcore */
191         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_INVALID);
192         if (ret == 1) {
193                 printf("rte_power_freq_max unexpectedly succeeded on invalid lcore "
194                                 "%u\n", TEST_POWER_VM_LCORE_INVALID);
195                 goto fail_all;
196         }
197
198         /* Test frequency up of valid lcore */
199         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_ID);
200         if (ret != 1) {
201                 printf("rte_power_freq_up unexpectedly failed on valid lcore %u\n",
202                                 TEST_POWER_VM_LCORE_ID);
203                 goto fail_all;
204         }
205
206         /* Test frequency down of valid lcore */
207         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_ID);
208         if (ret != 1) {
209                 printf("rte_power_freq_down unexpectedly failed on valid lcore "
210                                 "%u\n", TEST_POWER_VM_LCORE_ID);
211                 goto fail_all;
212         }
213
214         /* Test frequency min of valid lcore */
215         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_ID);
216         if (ret != 1) {
217                 printf("rte_power_freq_min unexpectedly failed on valid lcore "
218                                 "%u\n", TEST_POWER_VM_LCORE_ID);
219                 goto fail_all;
220         }
221
222         /* Test frequency max of valid lcore */
223         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_ID);
224         if (ret != 1) {
225                 printf("rte_power_freq_max unexpectedly failed on valid lcore "
226                                 "%u\n", TEST_POWER_VM_LCORE_ID);
227                 goto fail_all;
228         }
229
230         /* Test unsupported rte_power_freqs */
231         ret = rte_power_freqs(TEST_POWER_VM_LCORE_ID, NULL, 0);
232         if (ret != -ENOTSUP) {
233                 printf("rte_power_freqs did not return the expected -ENOTSUP(%d) but "
234                                 "returned %d\n", -ENOTSUP, ret);
235                 goto fail_all;
236         }
237
238         /* Test unsupported rte_power_get_freq */
239         ret = rte_power_get_freq(TEST_POWER_VM_LCORE_ID);
240         if (ret != -ENOTSUP) {
241                 printf("rte_power_get_freq did not return the expected -ENOTSUP(%d) but"
242                                 " returned %d for lcore %u\n",
243                                 -ENOTSUP, ret, TEST_POWER_VM_LCORE_ID);
244                 goto fail_all;
245         }
246
247         /* Test unsupported rte_power_set_freq */
248         ret = rte_power_set_freq(TEST_POWER_VM_LCORE_ID, 0);
249         if (ret != -ENOTSUP) {
250                 printf("rte_power_set_freq did not return the expected -ENOTSUP(%d) but"
251                                 " returned %d for lcore %u\n",
252                                 -ENOTSUP, ret, TEST_POWER_VM_LCORE_ID);
253                 goto fail_all;
254         }
255
256         /* Test removing of an lcore */
257         ret = rte_power_exit(TEST_POWER_VM_LCORE_ID);
258         if (ret != 0) {
259                 printf("rte_power_exit unexpectedly failed on valid lcore %u,"
260                                 "please ensure that the environment has been configured "
261                                 "correctly\n", TEST_POWER_VM_LCORE_ID);
262                 goto fail_all;
263         }
264
265         /* Test frequency up of previously removed lcore */
266         ret = rte_power_freq_up(TEST_POWER_VM_LCORE_ID);
267         if (ret == 0) {
268                 printf("rte_power_freq_up unexpectedly succeeded on a removed "
269                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
270                 return -1;
271         }
272
273         /* Test frequency down of previously removed lcore */
274         ret = rte_power_freq_down(TEST_POWER_VM_LCORE_ID);
275         if (ret == 0) {
276                 printf("rte_power_freq_down unexpectedly succeeded on a removed "
277                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
278                 return -1;
279         }
280
281         /* Test frequency min of previously removed lcore */
282         ret = rte_power_freq_min(TEST_POWER_VM_LCORE_ID);
283         if (ret == 0) {
284                 printf("rte_power_freq_min unexpectedly succeeded on a removed "
285                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
286                 return -1;
287         }
288
289         /* Test frequency max of previously removed lcore */
290         ret = rte_power_freq_max(TEST_POWER_VM_LCORE_ID);
291         if (ret == 0) {
292                 printf("rte_power_freq_max unexpectedly succeeded on a removed "
293                                 "lcore %u\n", TEST_POWER_VM_LCORE_ID);
294                 return -1;
295         }
296         rte_power_unset_env();
297         return 0;
298 fail_all:
299         rte_power_exit(TEST_POWER_VM_LCORE_ID);
300         rte_power_unset_env();
301         return -1;
302 }
303
304 static struct test_command power_kvm_vm_cmd = {
305         .command = "power_kvm_vm_autotest",
306         .callback = test_power_kvm_vm,
307 };
308 REGISTER_TEST_COMMAND(power_kvm_vm_cmd);