1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
11 #include <cmdline_rdline.h>
12 #include <cmdline_parse.h>
13 #include <cmdline_parse_string.h>
14 #include <cmdline_parse_num.h>
15 #include <cmdline_socket.h>
18 #include <rte_lcore.h>
19 #include <rte_ethdev.h>
21 #include <rte_power.h>
22 #include <guest_channel.h>
24 #include "vm_power_cli_guest.h"
27 #define CHANNEL_PATH "/dev/virtio-ports/virtio.serial.port.poweragent"
30 #define RTE_LOGTYPE_GUEST_CLI RTE_LOGTYPE_USER1
32 struct cmd_quit_result {
33 cmdline_fixed_string_t quit;
37 struct rte_ether_addr addr;
41 static struct channel_packet policy;
43 struct channel_packet *
50 set_policy_mac(int port, int idx)
52 struct channel_packet *policy;
56 /* Use port MAC address as the vfid */
57 ret = rte_eth_macaddr_get(port, &pfid.addr);
59 printf("Failed to get device (port %u) MAC address: %s\n",
60 port, rte_strerror(-ret));
64 printf("Port %u MAC: %02" PRIx8 ":%02" PRIx8 ":%02" PRIx8 ":"
65 "%02" PRIx8 ":%02" PRIx8 ":%02" PRIx8 "\n",
67 pfid.addr.addr_bytes[0], pfid.addr.addr_bytes[1],
68 pfid.addr.addr_bytes[2], pfid.addr.addr_bytes[3],
69 pfid.addr.addr_bytes[4], pfid.addr.addr_bytes[5]);
70 policy = get_policy();
71 policy->vfid[idx] = pfid.pfid;
76 set_policy_defaults(struct channel_packet *pkt)
80 ret = set_policy_mac(0, 0);
84 pkt->nb_mac_to_monitor = 1;
86 pkt->t_boost_status.tbEnabled = false;
88 pkt->vcpu_to_control[0] = 0;
89 pkt->vcpu_to_control[1] = 1;
91 /* Dummy Population. */
92 pkt->traffic_policy.min_packet_thresh = 96000;
93 pkt->traffic_policy.avg_max_packet_thresh = 1800000;
94 pkt->traffic_policy.max_max_packet_thresh = 2000000;
96 pkt->timer_policy.busy_hours[0] = 3;
97 pkt->timer_policy.busy_hours[1] = 4;
98 pkt->timer_policy.busy_hours[2] = 5;
99 pkt->timer_policy.quiet_hours[0] = 11;
100 pkt->timer_policy.quiet_hours[1] = 12;
101 pkt->timer_policy.quiet_hours[2] = 13;
103 pkt->timer_policy.hours_to_use_traffic_profile[0] = 8;
104 pkt->timer_policy.hours_to_use_traffic_profile[1] = 10;
106 pkt->core_type = CORE_TYPE_VIRTUAL;
108 pkt->policy_to_use = TIME;
109 pkt->command = PKT_POLICY;
110 strcpy(pkt->vm_name, "ubuntu2");
115 static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
116 __attribute__((unused)) struct cmdline *cl,
117 __attribute__((unused)) void *data)
121 RTE_LCORE_FOREACH(lcore_id) {
122 rte_power_exit(lcore_id);
127 cmdline_parse_token_string_t cmd_quit_quit =
128 TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, "quit");
130 cmdline_parse_inst_t cmd_quit = {
131 .f = cmd_quit_parsed, /* function to call */
132 .data = NULL, /* 2nd arg of func */
133 .help_str = "close the application",
134 .tokens = { /* token list, NULL terminated */
135 (void *)&cmd_quit_quit,
140 /* *** VM operations *** */
142 struct cmd_set_cpu_freq_result {
143 cmdline_fixed_string_t set_cpu_freq;
145 cmdline_fixed_string_t cmd;
149 check_response_cmd(unsigned int lcore_id, int *result)
151 struct channel_packet pkt;
154 ret = rte_power_guest_channel_receive_msg(&pkt, lcore_id);
158 switch (pkt.command) {
159 case(CPU_POWER_CMD_ACK):
162 case(CPU_POWER_CMD_NACK):
166 RTE_LOG(ERR, GUEST_CLI,
167 "Received invalid response from host, expecting ACK/NACK.\n");
175 cmd_set_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
176 __attribute__((unused)) void *data)
179 struct cmd_set_cpu_freq_result *res = parsed_result;
181 if (!strcmp(res->cmd, "up"))
182 ret = rte_power_freq_up(res->lcore_id);
183 else if (!strcmp(res->cmd, "down"))
184 ret = rte_power_freq_down(res->lcore_id);
185 else if (!strcmp(res->cmd, "min"))
186 ret = rte_power_freq_min(res->lcore_id);
187 else if (!strcmp(res->cmd, "max"))
188 ret = rte_power_freq_max(res->lcore_id);
189 else if (!strcmp(res->cmd, "enable_turbo"))
190 ret = rte_power_freq_enable_turbo(res->lcore_id);
191 else if (!strcmp(res->cmd, "disable_turbo"))
192 ret = rte_power_freq_disable_turbo(res->lcore_id);
195 cmdline_printf(cl, "Error sending message: %s\n", strerror(ret));
199 ret = check_response_cmd(res->lcore_id, &result);
201 RTE_LOG(ERR, GUEST_CLI, "No confirmation for sent message received\n");
203 cmdline_printf(cl, "%s received for message sent to host.\n",
204 result == 1 ? "ACK" : "NACK");
208 cmdline_parse_token_string_t cmd_set_cpu_freq =
209 TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_result,
210 set_cpu_freq, "set_cpu_freq");
211 cmdline_parse_token_num_t cmd_set_cpu_freq_core_num =
212 TOKEN_NUM_INITIALIZER(struct cmd_set_cpu_freq_result,
214 cmdline_parse_token_string_t cmd_set_cpu_freq_cmd_cmd =
215 TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_result,
216 cmd, "up#down#min#max#enable_turbo#disable_turbo");
218 cmdline_parse_inst_t cmd_set_cpu_freq_set = {
219 .f = cmd_set_cpu_freq_parsed,
221 .help_str = "set_cpu_freq <core_num> "
222 "<up|down|min|max|enable_turbo|disable_turbo>, "
223 "adjust the frequency for the specified core.",
225 (void *)&cmd_set_cpu_freq,
226 (void *)&cmd_set_cpu_freq_core_num,
227 (void *)&cmd_set_cpu_freq_cmd_cmd,
232 struct cmd_send_policy_result {
233 cmdline_fixed_string_t send_policy;
234 cmdline_fixed_string_t cmd;
238 send_policy(struct channel_packet *pkt, struct cmdline *cl)
242 ret = rte_power_guest_channel_send_msg(pkt, 1);
244 RTE_LOG(ERR, GUEST_CLI, "Error sending message: %s\n",
245 ret > 0 ? strerror(ret) : "channel not connected");
250 ret = check_response_cmd(1, &result);
252 RTE_LOG(ERR, GUEST_CLI, "No confirmation for sent policy received\n");
254 cmdline_printf(cl, "%s for sent policy received.\n",
255 result == 1 ? "ACK" : "NACK");
261 cmd_send_policy_parsed(void *parsed_result, struct cmdline *cl,
262 __attribute__((unused)) void *data)
265 struct cmd_send_policy_result *res = parsed_result;
267 if (!strcmp(res->cmd, "now")) {
268 printf("Sending Policy down now!\n");
269 ret = send_policy(&policy, cl);
272 cmdline_printf(cl, "Error sending message: %s\n",
276 cmdline_parse_token_string_t cmd_send_policy =
277 TOKEN_STRING_INITIALIZER(struct cmd_send_policy_result,
278 send_policy, "send_policy");
279 cmdline_parse_token_string_t cmd_send_policy_cmd_cmd =
280 TOKEN_STRING_INITIALIZER(struct cmd_send_policy_result,
283 cmdline_parse_inst_t cmd_send_policy_set = {
284 .f = cmd_send_policy_parsed,
286 .help_str = "send_policy now",
288 (void *)&cmd_send_policy,
289 (void *)&cmd_send_policy_cmd_cmd,
294 cmdline_parse_ctx_t main_ctx[] = {
295 (cmdline_parse_inst_t *)&cmd_quit,
296 (cmdline_parse_inst_t *)&cmd_send_policy_set,
297 (cmdline_parse_inst_t *)&cmd_set_cpu_freq_set,
302 run_cli(__attribute__((unused)) void *arg)
306 cl = cmdline_stdin_new(main_ctx, "vmpower(guest)> ");
310 cmdline_interact(cl);
311 cmdline_stdin_exit(cl);