examples/vm_power_manager/guest_cli/vm_power_cli_guest.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5
   6 #include <stdint.h>
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <termios.h>
  10
  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>
  16 #include <cmdline.h>
  17 #include <rte_log.h>
  18 #include <rte_lcore.h>
  19 #include <rte_ethdev.h>
  20
  21 #include <rte_power.h>
  22 #include <guest_channel.h>
  23
  24 #include "vm_power_cli_guest.h"
  25
  26
  27 #define CHANNEL_PATH "/dev/virtio-ports/virtio.serial.port.poweragent"
  28
  29
  30 #define RTE_LOGTYPE_GUEST_CHANNEL RTE_LOGTYPE_USER1
  31
  32 struct cmd_quit_result {
  33         cmdline_fixed_string_t quit;
  34 };
  35
  36 union PFID {
  37         struct rte_ether_addr addr;
  38         uint64_t pfid;
  39 };
  40
  41 static struct channel_packet policy;
  42
  43 struct channel_packet *
  44 get_policy(void)
  45 {
  46         return &policy;
  47 }
  48
  49 int
  50 set_policy_mac(int port, int idx)
  51 {
  52         struct channel_packet *policy;
  53         union PFID pfid;
  54         int ret;
  55
  56         /* Use port MAC address as the vfid */
  57         ret = rte_eth_macaddr_get(port, &pfid.addr);
  58         if (retval != 0) {
  59                 printf("Failed to get device (port %u) MAC address: %s\n",
  60                                 port, rte_strerror(-retval));
  61                 return retval;
  62         }
  63
  64         printf("Port %u MAC: %02" PRIx8 ":%02" PRIx8 ":%02" PRIx8 ":"
  65                         "%02" PRIx8 ":%02" PRIx8 ":%02" PRIx8 "\n",
  66                         port,
  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;
  72         return 0;
  73 }
  74
  75 int
  76 set_policy_defaults(struct channel_packet *pkt)
  77 {
  78         int ret;
  79
  80         ret = set_policy_mac(0, 0);
  81         if (ret != 0)
  82                 return ret;
  83
  84         pkt->nb_mac_to_monitor = 1;
  85
  86         pkt->t_boost_status.tbEnabled = false;
  87
  88         pkt->vcpu_to_control[0] = 0;
  89         pkt->vcpu_to_control[1] = 1;
  90         pkt->num_vcpu = 2;
  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;
  95
  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;
 102
 103         pkt->timer_policy.hours_to_use_traffic_profile[0] = 8;
 104         pkt->timer_policy.hours_to_use_traffic_profile[1] = 10;
 105
 106         pkt->core_type = CORE_TYPE_VIRTUAL;
 107         pkt->workload = LOW;
 108         pkt->policy_to_use = TIME;
 109         pkt->command = PKT_POLICY;
 110         strcpy(pkt->vm_name, "ubuntu2");
 111 }
 112
 113 static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
 114                                 __attribute__((unused)) struct cmdline *cl,
 115                             __attribute__((unused)) void *data)
 116 {
 117         unsigned lcore_id;
 118
 119         RTE_LCORE_FOREACH(lcore_id) {
 120                 rte_power_exit(lcore_id);
 121         }
 122         cmdline_quit(cl);
 123 }
 124
 125 cmdline_parse_token_string_t cmd_quit_quit =
 126         TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, "quit");
 127
 128 cmdline_parse_inst_t cmd_quit = {
 129         .f = cmd_quit_parsed,  /* function to call */
 130         .data = NULL,      /* 2nd arg of func */
 131         .help_str = "close the application",
 132         .tokens = {        /* token list, NULL terminated */
 133                 (void *)&cmd_quit_quit,
 134                 NULL,
 135         },
 136 };
 137
 138 /* *** VM operations *** */
 139
 140 struct cmd_set_cpu_freq_result {
 141         cmdline_fixed_string_t set_cpu_freq;
 142         uint8_t lcore_id;
 143         cmdline_fixed_string_t cmd;
 144 };
 145
 146 static void
 147 cmd_set_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
 148                        __attribute__((unused)) void *data)
 149 {
 150         int ret = -1;
 151         struct cmd_set_cpu_freq_result *res = parsed_result;
 152
 153         if (!strcmp(res->cmd , "up"))
 154                 ret = rte_power_freq_up(res->lcore_id);
 155         else if (!strcmp(res->cmd , "down"))
 156                 ret = rte_power_freq_down(res->lcore_id);
 157         else if (!strcmp(res->cmd , "min"))
 158                 ret = rte_power_freq_min(res->lcore_id);
 159         else if (!strcmp(res->cmd , "max"))
 160                 ret = rte_power_freq_max(res->lcore_id);
 161         else if (!strcmp(res->cmd, "enable_turbo"))
 162                 ret = rte_power_freq_enable_turbo(res->lcore_id);
 163         else if (!strcmp(res->cmd, "disable_turbo"))
 164                 ret = rte_power_freq_disable_turbo(res->lcore_id);
 165         if (ret != 1)
 166                 cmdline_printf(cl, "Error sending message: %s\n", strerror(ret));
 167 }
 168
 169 cmdline_parse_token_string_t cmd_set_cpu_freq =
 170         TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_result,
 171                         set_cpu_freq, "set_cpu_freq");
 172 cmdline_parse_token_string_t cmd_set_cpu_freq_core_num =
 173         TOKEN_NUM_INITIALIZER(struct cmd_set_cpu_freq_result,
 174                         lcore_id, UINT8);
 175 cmdline_parse_token_string_t cmd_set_cpu_freq_cmd_cmd =
 176         TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_result,
 177                         cmd, "up#down#min#max#enable_turbo#disable_turbo");
 178
 179 cmdline_parse_inst_t cmd_set_cpu_freq_set = {
 180         .f = cmd_set_cpu_freq_parsed,
 181         .data = NULL,
 182         .help_str = "set_cpu_freq <core_num> "
 183                         "<up|down|min|max|enable_turbo|disable_turbo>, "
 184                         "adjust the frequency for the specified core.",
 185         .tokens = {
 186                 (void *)&cmd_set_cpu_freq,
 187                 (void *)&cmd_set_cpu_freq_core_num,
 188                 (void *)&cmd_set_cpu_freq_cmd_cmd,
 189                 NULL,
 190         },
 191 };
 192
 193 struct cmd_send_policy_result {
 194         cmdline_fixed_string_t send_policy;
 195         cmdline_fixed_string_t cmd;
 196 };
 197
 198 static inline int
 199 send_policy(struct channel_packet *pkt)
 200 {
 201         int ret;
 202
 203         ret = rte_power_guest_channel_send_msg(pkt, 1);
 204         if (ret == 0)
 205                 return 1;
 206         RTE_LOG(DEBUG, POWER, "Error sending message: %s\n",
 207                         ret > 0 ? strerror(ret) : "channel not connected");
 208         return -1;
 209 }
 210
 211 static void
 212 cmd_send_policy_parsed(void *parsed_result, struct cmdline *cl,
 213                        __attribute__((unused)) void *data)
 214 {
 215         int ret = -1;
 216         struct cmd_send_policy_result *res = parsed_result;
 217
 218         if (!strcmp(res->cmd, "now")) {
 219                 printf("Sending Policy down now!\n");
 220                 ret = send_policy(&policy);
 221         }
 222         if (ret != 1)
 223                 cmdline_printf(cl, "Error sending message: %s\n",
 224                                 strerror(ret));
 225 }
 226
 227 cmdline_parse_token_string_t cmd_send_policy =
 228         TOKEN_STRING_INITIALIZER(struct cmd_send_policy_result,
 229                         send_policy, "send_policy");
 230 cmdline_parse_token_string_t cmd_send_policy_cmd_cmd =
 231         TOKEN_STRING_INITIALIZER(struct cmd_send_policy_result,
 232                         cmd, "now");
 233
 234 cmdline_parse_inst_t cmd_send_policy_set = {
 235         .f = cmd_send_policy_parsed,
 236         .data = NULL,
 237         .help_str = "send_policy now",
 238         .tokens = {
 239                 (void *)&cmd_send_policy,
 240                 (void *)&cmd_send_policy_cmd_cmd,
 241                 NULL,
 242         },
 243 };
 244
 245 cmdline_parse_ctx_t main_ctx[] = {
 246                 (cmdline_parse_inst_t *)&cmd_quit,
 247                 (cmdline_parse_inst_t *)&cmd_send_policy_set,
 248                 (cmdline_parse_inst_t *)&cmd_set_cpu_freq_set,
 249                 NULL,
 250 };
 251
 252 void
 253 run_cli(__attribute__((unused)) void *arg)
 254 {
 255         struct cmdline *cl;
 256
 257         cl = cmdline_stdin_new(main_ctx, "vmpower(guest)> ");
 258         if (cl == NULL)
 259                 return;
 260
 261         cmdline_interact(cl);
 262         cmdline_stdin_exit(cl);
 263 }