-/*-
- * BSD LICENSE
- *
- * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * * Neither the name of Intel Corporation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2014 Intel Corporation
*/
#include <stdlib.h>
#include <cmdline_parse_num.h>
#include <cmdline_socket.h>
#include <cmdline.h>
-#include <rte_config.h>
#include "vm_power_cli.h"
#include "channel_manager.h"
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
channel_monitor_exit();
channel_manager_exit();
static void
cmd_show_vm_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_show_vm_result *res = parsed_result;
struct vm_info info;
}
cmdline_printf(cl, "Virtual CPU(s): %u\n", info.num_vcpus);
for (i = 0; i < info.num_vcpus; i++) {
- cmdline_printf(cl, " [%u]: Physical CPU Mask 0x%"PRIx64"\n", i,
- info.pcpu_mask[i]);
+ cmdline_printf(cl, " [%u]: Physical CPU %d\n", i,
+ info.pcpu_map[i]);
}
}
};
/* *** vCPU to pCPU mapping operations *** */
-struct cmd_set_pcpu_mask_result {
- cmdline_fixed_string_t set_pcpu_mask;
- cmdline_fixed_string_t vm_name;
- uint8_t vcpu;
- uint64_t core_mask;
-};
-
-static void
-cmd_set_pcpu_mask_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- struct cmd_set_pcpu_mask_result *res = parsed_result;
- if (set_pcpus_mask(res->vm_name, res->vcpu, res->core_mask) == 0)
- cmdline_printf(cl, "Pinned vCPU(%"PRId8") to pCPU core "
- "mask(0x%"PRIx64")\n", res->vcpu, res->core_mask);
- else
- cmdline_printf(cl, "Unable to pin vCPU(%"PRId8") to pCPU core "
- "mask(0x%"PRIx64")\n", res->vcpu, res->core_mask);
-}
-
-cmdline_parse_token_string_t cmd_set_pcpu_mask =
- TOKEN_STRING_INITIALIZER(struct cmd_set_pcpu_mask_result,
- set_pcpu_mask, "set_pcpu_mask");
-cmdline_parse_token_string_t cmd_set_pcpu_mask_vm_name =
- TOKEN_STRING_INITIALIZER(struct cmd_set_pcpu_mask_result,
- vm_name, NULL);
-cmdline_parse_token_num_t set_pcpu_mask_vcpu =
- TOKEN_NUM_INITIALIZER(struct cmd_set_pcpu_mask_result,
- vcpu, UINT8);
-cmdline_parse_token_num_t set_pcpu_mask_core_mask =
- TOKEN_NUM_INITIALIZER(struct cmd_set_pcpu_mask_result,
- core_mask, UINT64);
-
-
-cmdline_parse_inst_t cmd_set_pcpu_mask_set = {
- .f = cmd_set_pcpu_mask_parsed,
- .data = NULL,
- .help_str = "set_pcpu_mask <vm_name> <vcpu> <pcpu>, Set the binding "
- "of Virtual CPU on VM to the Physical CPU mask.",
- .tokens = {
- (void *)&cmd_set_pcpu_mask,
- (void *)&cmd_set_pcpu_mask_vm_name,
- (void *)&set_pcpu_mask_vcpu,
- (void *)&set_pcpu_mask_core_mask,
- NULL,
- },
-};
struct cmd_set_pcpu_result {
cmdline_fixed_string_t set_pcpu;
static void
cmd_set_pcpu_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_set_pcpu_result *res = parsed_result;
static void
cmd_vm_op_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_vm_op_result *res = parsed_result;
};
static void
cmd_channels_op_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
unsigned num_channels = 0, channel_num, i;
int channels_added;
- unsigned channel_list[CHANNEL_CMDS_MAX_VM_CHANNELS];
+ unsigned int channel_list[RTE_MAX_LCORE];
char *token, *remaining, *tail_ptr;
struct cmd_channels_op_result *res = parsed_result;
if ((errno != 0) || tail_ptr == NULL || (*tail_ptr != '\0'))
break;
- if (channel_num == CHANNEL_CMDS_MAX_VM_CHANNELS) {
+ if (channel_num == RTE_MAX_LCORE) {
cmdline_printf(cl, "Channel number '%u' exceeds the maximum number "
"of allowable channels(%u) for VM '%s'\n", channel_num,
- CHANNEL_CMDS_MAX_VM_CHANNELS, res->vm_name);
+ RTE_MAX_LCORE, res->vm_name);
return;
}
channel_list[num_channels++] = channel_num;
},
};
+struct cmd_set_query_result {
+ cmdline_fixed_string_t set_query;
+ cmdline_fixed_string_t vm_name;
+ cmdline_fixed_string_t query_status;
+};
+
+static void
+cmd_set_query_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_query_result *res = parsed_result;
+
+ if (!strcmp(res->query_status, "enable")) {
+ if (set_query_status(res->vm_name, true) < 0)
+ cmdline_printf(cl, "Unable to allow query for VM '%s'\n",
+ res->vm_name);
+ } else if (!strcmp(res->query_status, "disable")) {
+ if (set_query_status(res->vm_name, false) < 0)
+ cmdline_printf(cl, "Unable to disallow query for VM '%s'\n",
+ res->vm_name);
+ }
+}
+
+cmdline_parse_token_string_t cmd_set_query =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_query_result,
+ set_query, "set_query");
+cmdline_parse_token_string_t cmd_set_query_vm_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_query_result,
+ vm_name, NULL);
+cmdline_parse_token_string_t cmd_set_query_status =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_query_result,
+ query_status, "enable#disable");
+
+cmdline_parse_inst_t cmd_set_query_set = {
+ .f = cmd_set_query_parsed,
+ .data = NULL,
+ .help_str = "set_query <vm_name> <enable|disable>, allow or disallow queries"
+ " for the specified VM",
+ .tokens = {
+ (void *)&cmd_set_query,
+ (void *)&cmd_set_query_vm_name,
+ (void *)&cmd_set_query_status,
+ NULL,
+ },
+};
+
struct cmd_channels_status_op_result {
cmdline_fixed_string_t op;
cmdline_fixed_string_t vm_name;
static void
cmd_channels_status_op_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
unsigned num_channels = 0, channel_num;
int changed;
- unsigned channel_list[CHANNEL_CMDS_MAX_VM_CHANNELS];
+ unsigned int channel_list[RTE_MAX_LCORE];
char *token, *remaining, *tail_ptr;
struct cmd_channels_status_op_result *res = parsed_result;
enum channel_status status;
if ((errno != 0) || tail_ptr == NULL || (*tail_ptr != '\0'))
break;
- if (channel_num == CHANNEL_CMDS_MAX_VM_CHANNELS) {
+ if (channel_num == RTE_MAX_LCORE) {
cmdline_printf(cl, "%u exceeds the maximum number of allowable "
"channels(%u) for VM '%s'\n", channel_num,
- CHANNEL_CMDS_MAX_VM_CHANNELS, res->vm_name);
+ RTE_MAX_LCORE, res->vm_name);
return;
}
channel_list[num_channels++] = channel_num;
};
/* *** CPU Frequency operations *** */
-struct cmd_show_cpu_freq_mask_result {
- cmdline_fixed_string_t show_cpu_freq_mask;
- uint64_t core_mask;
-};
-
-static void
-cmd_show_cpu_freq_mask_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- struct cmd_show_cpu_freq_mask_result *res = parsed_result;
- unsigned i;
- uint64_t mask = res->core_mask;
- uint32_t freq;
-
- for (i = 0; mask; mask &= ~(1ULL << i++)) {
- if ((mask >> i) & 1) {
- freq = power_manager_get_current_frequency(i);
- if (freq > 0)
- cmdline_printf(cl, "Core %u: %"PRId32"\n", i, freq);
- }
- }
-}
-
-cmdline_parse_token_string_t cmd_show_cpu_freq_mask =
- TOKEN_STRING_INITIALIZER(struct cmd_show_cpu_freq_mask_result,
- show_cpu_freq_mask, "show_cpu_freq_mask");
-cmdline_parse_token_num_t cmd_show_cpu_freq_mask_core_mask =
- TOKEN_NUM_INITIALIZER(struct cmd_show_cpu_freq_mask_result,
- core_mask, UINT64);
-
-cmdline_parse_inst_t cmd_show_cpu_freq_mask_set = {
- .f = cmd_show_cpu_freq_mask_parsed,
- .data = NULL,
- .help_str = "show_cpu_freq_mask <mask>, Get the current frequency for each "
- "core specified in the mask",
- .tokens = {
- (void *)&cmd_show_cpu_freq_mask,
- (void *)&cmd_show_cpu_freq_mask_core_mask,
- NULL,
- },
-};
-
-struct cmd_set_cpu_freq_mask_result {
- cmdline_fixed_string_t set_cpu_freq_mask;
- uint64_t core_mask;
- cmdline_fixed_string_t cmd;
-};
-
-static void
-cmd_set_cpu_freq_mask_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
-{
- struct cmd_set_cpu_freq_mask_result *res = parsed_result;
- int ret = -1;
-
- if (!strcmp(res->cmd , "up"))
- ret = power_manager_scale_mask_up(res->core_mask);
- else if (!strcmp(res->cmd , "down"))
- ret = power_manager_scale_mask_down(res->core_mask);
- else if (!strcmp(res->cmd , "min"))
- ret = power_manager_scale_mask_min(res->core_mask);
- else if (!strcmp(res->cmd , "max"))
- ret = power_manager_scale_mask_max(res->core_mask);
- if (ret < 0) {
- cmdline_printf(cl, "Error scaling core_mask(0x%"PRIx64") '%s' , not "
- "all cores specified have been scaled\n",
- res->core_mask, res->cmd);
- };
-}
-
-cmdline_parse_token_string_t cmd_set_cpu_freq_mask =
- TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_mask_result,
- set_cpu_freq_mask, "set_cpu_freq_mask");
-cmdline_parse_token_num_t cmd_set_cpu_freq_mask_core_mask =
- TOKEN_NUM_INITIALIZER(struct cmd_set_cpu_freq_mask_result,
- core_mask, UINT64);
-cmdline_parse_token_string_t cmd_set_cpu_freq_mask_result =
- TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_mask_result,
- cmd, "up#down#min#max");
-
-cmdline_parse_inst_t cmd_set_cpu_freq_mask_set = {
- .f = cmd_set_cpu_freq_mask_parsed,
- .data = NULL,
- .help_str = "set_cpu_freq <core_mask> <up|down|min|max>, Set the current "
- "frequency for the cores specified in <core_mask> by scaling "
- "each up/down/min/max.",
- .tokens = {
- (void *)&cmd_set_cpu_freq_mask,
- (void *)&cmd_set_cpu_freq_mask_core_mask,
- (void *)&cmd_set_cpu_freq_mask_result,
- NULL,
- },
-};
-
-
-
struct cmd_show_cpu_freq_result {
cmdline_fixed_string_t show_cpu_freq;
uint8_t core_num;
static void
cmd_show_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_show_cpu_freq_result *res = parsed_result;
uint32_t curr_freq = power_manager_get_current_frequency(res->core_num);
static void
cmd_set_cpu_freq_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int ret = -1;
struct cmd_set_cpu_freq_result *res = parsed_result;
ret = power_manager_scale_core_min(res->core_num);
else if (!strcmp(res->cmd , "max"))
ret = power_manager_scale_core_max(res->core_num);
+ else if (!strcmp(res->cmd, "enable_turbo"))
+ ret = power_manager_enable_turbo_core(res->core_num);
+ else if (!strcmp(res->cmd, "disable_turbo"))
+ ret = power_manager_disable_turbo_core(res->core_num);
if (ret < 0) {
cmdline_printf(cl, "Error scaling core(%u) '%s'\n", res->core_num,
res->cmd);
cmdline_parse_token_string_t cmd_set_cpu_freq =
TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_result,
set_cpu_freq, "set_cpu_freq");
-cmdline_parse_token_string_t cmd_set_cpu_freq_core_num =
+cmdline_parse_token_num_t cmd_set_cpu_freq_core_num =
TOKEN_NUM_INITIALIZER(struct cmd_set_cpu_freq_result,
core_num, UINT8);
cmdline_parse_token_string_t cmd_set_cpu_freq_cmd_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_set_cpu_freq_result,
- cmd, "up#down#min#max");
+ cmd, "up#down#min#max#enable_turbo#disable_turbo");
cmdline_parse_inst_t cmd_set_cpu_freq_set = {
.f = cmd_set_cpu_freq_parsed,
.data = NULL,
- .help_str = "set_cpu_freq <core_num> <up|down|min|max>, Set the current "
- "frequency for the specified core by scaling up/down/min/max",
+ .help_str = "set_cpu_freq <core_num> <up|down|min|max|enable_turbo|disable_turbo>, adjust the current "
+ "frequency for the specified core",
.tokens = {
(void *)&cmd_set_cpu_freq,
(void *)&cmd_set_cpu_freq_core_num,
(cmdline_parse_inst_t *)&cmd_channels_op_set,
(cmdline_parse_inst_t *)&cmd_channels_status_op_set,
(cmdline_parse_inst_t *)&cmd_show_vm_set,
- (cmdline_parse_inst_t *)&cmd_show_cpu_freq_mask_set,
- (cmdline_parse_inst_t *)&cmd_set_cpu_freq_mask_set,
(cmdline_parse_inst_t *)&cmd_show_cpu_freq_set,
(cmdline_parse_inst_t *)&cmd_set_cpu_freq_set,
- (cmdline_parse_inst_t *)&cmd_set_pcpu_mask_set,
(cmdline_parse_inst_t *)&cmd_set_pcpu_set,
+ (cmdline_parse_inst_t *)&cmd_set_query_set,
NULL,
};
void
-run_cli(__attribute__((unused)) void *arg)
+run_cli(__rte_unused void *arg)
{
struct cmdline *cl;
git.droids-corp.org / dpdk.git / blobdiff