net: add macro to extract MAC address bytes

[dpdk.git] / examples / vm_power_manager / guest_cli / vm_power_cli_guest.c

diff --git a/examples/vm_power_manager/guest_cli/vm_power_cli_guest.c b/examples/vm_power_manager/guest_cli/vm_power_cli_guest.c
index eb0ae91..94bfbba 100644 (file)
--- a/examples/vm_power_manager/guest_cli/vm_power_cli_guest.c
+++ b/examples/vm_power_manager/guest_cli/vm_power_cli_guest.c
@@ -19,7 +19,6 @@
 #include <rte_ethdev.h>
 
 #include <rte_power.h>
-#include <guest_channel.h>
 
 #include "vm_power_cli_guest.h"
 
@@ -38,9 +37,9 @@ union PFID {
        uint64_t pfid;
 };
 
-static struct channel_packet policy;
+static struct rte_power_channel_packet policy;
 
-struct channel_packet *
+struct rte_power_channel_packet *
 get_policy(void)
 {
        return &policy;
@@ -49,7 +48,7 @@ get_policy(void)
 int
 set_policy_mac(int port, int idx)
 {
-       struct channel_packet *policy;
+       struct rte_power_channel_packet *policy;
        union PFID pfid;
        int ret;
 
@@ -63,25 +62,22 @@ set_policy_mac(int port, int idx)
 
        printf("Port %u MAC: %02" PRIx8 ":%02" PRIx8 ":%02" PRIx8 ":"
                        "%02" PRIx8 ":%02" PRIx8 ":%02" PRIx8 "\n",
-                       port,
-                       pfid.addr.addr_bytes[0], pfid.addr.addr_bytes[1],
-                       pfid.addr.addr_bytes[2], pfid.addr.addr_bytes[3],
-                       pfid.addr.addr_bytes[4], pfid.addr.addr_bytes[5]);
+                       port, RTE_ETHER_ADDR_BYTES(&pfid.addr));
        policy = get_policy();
        policy->vfid[idx] = pfid.pfid;
        return 0;
 }
 
 int
-set_policy_defaults(struct channel_packet *pkt)
+set_policy_defaults(struct rte_power_channel_packet *pkt)
 {
        int ret;
 
        ret = set_policy_mac(0, 0);
        if (ret != 0)
-               return ret;
-
-       pkt->nb_mac_to_monitor = 1;
+               pkt->nb_mac_to_monitor = 0;
+       else
+               pkt->nb_mac_to_monitor = 1;
 
        pkt->t_boost_status.tbEnabled = false;
 
@@ -103,10 +99,10 @@ set_policy_defaults(struct channel_packet *pkt)
        pkt->timer_policy.hours_to_use_traffic_profile[0] = 8;
        pkt->timer_policy.hours_to_use_traffic_profile[1] = 10;
 
-       pkt->core_type = CORE_TYPE_VIRTUAL;
-       pkt->workload = LOW;
-       pkt->policy_to_use = TIME;
-       pkt->command = PKT_POLICY;
+       pkt->core_type = RTE_POWER_CORE_TYPE_VIRTUAL;
+       pkt->workload = RTE_POWER_WL_LOW;
+       pkt->policy_to_use = RTE_POWER_POLICY_TIME;
+       pkt->command = RTE_POWER_PKT_POLICY;
        strlcpy(pkt->vm_name, "ubuntu2", sizeof(pkt->vm_name));
 
        return 0;
@@ -145,7 +141,7 @@ struct cmd_freq_list_result {
 };
 
 static int
-query_data(struct channel_packet *pkt, unsigned int lcore_id)
+query_data(struct rte_power_channel_packet *pkt, unsigned int lcore_id)
 {
        int ret;
        ret = rte_power_guest_channel_send_msg(pkt, lcore_id);
@@ -157,19 +153,19 @@ query_data(struct channel_packet *pkt, unsigned int lcore_id)
 }
 
 static int
-receive_freq_list(struct channel_packet_freq_list *pkt_freq_list,
+receive_freq_list(struct rte_power_channel_packet_freq_list *pkt_freq_list,
                unsigned int lcore_id)
 {
        int ret;
 
        ret = rte_power_guest_channel_receive_msg(pkt_freq_list,
-                       sizeof(struct channel_packet_freq_list),
+                       sizeof(*pkt_freq_list),
                        lcore_id);
        if (ret < 0) {
                RTE_LOG(ERR, GUEST_CLI, "Error receiving message.\n");
                return -1;
        }
-       if (pkt_freq_list->command != CPU_POWER_FREQ_LIST) {
+       if (pkt_freq_list->command != RTE_POWER_FREQ_LIST) {
                RTE_LOG(ERR, GUEST_CLI, "Unexpected message received.\n");
                return -1;
        }
@@ -183,14 +179,14 @@ cmd_query_freq_list_parsed(void *parsed_result,
 {
        struct cmd_freq_list_result *res = parsed_result;
        unsigned int lcore_id;
-       struct channel_packet_freq_list pkt_freq_list;
-       struct channel_packet pkt;
+       struct rte_power_channel_packet_freq_list pkt_freq_list;
+       struct rte_power_channel_packet pkt;
        bool query_list = false;
        int ret;
        char *ep;
 
-       memset(&pkt, 0, sizeof(struct channel_packet));
-       memset(&pkt_freq_list, 0, sizeof(struct channel_packet_freq_list));
+       memset(&pkt, 0, sizeof(pkt));
+       memset(&pkt_freq_list, 0, sizeof(pkt_freq_list));
 
        if (!strcmp(res->cpu_num, "all")) {
 
@@ -203,18 +199,18 @@ cmd_query_freq_list_parsed(void *parsed_result,
                        return;
                }
 
-               pkt.command = CPU_POWER_QUERY_FREQ_LIST;
+               pkt.command = RTE_POWER_QUERY_FREQ_LIST;
                strlcpy(pkt.vm_name, policy.vm_name, sizeof(pkt.vm_name));
                query_list = true;
        } else {
                errno = 0;
                lcore_id = (unsigned int)strtol(res->cpu_num, &ep, 10);
-               if (errno != 0 || lcore_id >= MAX_VCPU_PER_VM ||
+               if (errno != 0 || lcore_id >= RTE_POWER_MAX_VCPU_PER_VM ||
                        ep == res->cpu_num) {
                        cmdline_printf(cl, "Invalid parameter provided.\n");
                        return;
                }
-               pkt.command = CPU_POWER_QUERY_FREQ;
+               pkt.command = RTE_POWER_QUERY_FREQ;
                strlcpy(pkt.vm_name, policy.vm_name, sizeof(pkt.vm_name));
                pkt.resource_id = lcore_id;
        }
@@ -267,19 +263,19 @@ struct cmd_query_caps_result {
 };
 
 static int
-receive_capabilities(struct channel_packet_caps_list *pkt_caps_list,
+receive_capabilities(struct rte_power_channel_packet_caps_list *pkt_caps_list,
                unsigned int lcore_id)
 {
        int ret;
 
        ret = rte_power_guest_channel_receive_msg(pkt_caps_list,
-               sizeof(struct channel_packet_caps_list),
+               sizeof(*pkt_caps_list),
                lcore_id);
        if (ret < 0) {
                RTE_LOG(ERR, GUEST_CLI, "Error receiving message.\n");
                return -1;
        }
-       if (pkt_caps_list->command != CPU_POWER_CAPS_LIST) {
+       if (pkt_caps_list->command != RTE_POWER_CAPS_LIST) {
                RTE_LOG(ERR, GUEST_CLI, "Unexpected message received.\n");
                return -1;
        }
@@ -293,14 +289,14 @@ cmd_query_caps_list_parsed(void *parsed_result,
 {
        struct cmd_query_caps_result *res = parsed_result;
        unsigned int lcore_id;
-       struct channel_packet_caps_list pkt_caps_list;
-       struct channel_packet pkt;
+       struct rte_power_channel_packet_caps_list pkt_caps_list;
+       struct rte_power_channel_packet pkt;
        bool query_list = false;
        int ret;
        char *ep;
 
-       memset(&pkt, 0, sizeof(struct channel_packet));
-       memset(&pkt_caps_list, 0, sizeof(struct channel_packet_caps_list));
+       memset(&pkt, 0, sizeof(pkt));
+       memset(&pkt_caps_list, 0, sizeof(pkt_caps_list));
 
        if (!strcmp(res->cpu_num, "all")) {
 
@@ -313,18 +309,18 @@ cmd_query_caps_list_parsed(void *parsed_result,
                        return;
                }
 
-               pkt.command = CPU_POWER_QUERY_CAPS_LIST;
+               pkt.command = RTE_POWER_QUERY_CAPS_LIST;
                strlcpy(pkt.vm_name, policy.vm_name, sizeof(pkt.vm_name));
                query_list = true;
        } else {
                errno = 0;
                lcore_id = (unsigned int)strtol(res->cpu_num, &ep, 10);
-               if (errno != 0 || lcore_id >= MAX_VCPU_PER_VM ||
+               if (errno != 0 || lcore_id >= RTE_POWER_MAX_VCPU_PER_VM ||
                        ep == res->cpu_num) {
                        cmdline_printf(cl, "Invalid parameter provided.\n");
                        return;
                }
-               pkt.command = CPU_POWER_QUERY_CAPS;
+               pkt.command = RTE_POWER_QUERY_CAPS;
                strlcpy(pkt.vm_name, policy.vm_name, sizeof(pkt.vm_name));
                pkt.resource_id = lcore_id;
        }
@@ -344,13 +340,15 @@ cmd_query_caps_list_parsed(void *parsed_result,
                unsigned int i;
                for (i = 0; i < pkt_caps_list.num_vcpu; ++i)
                        cmdline_printf(cl, "Capabilities of [%d] vcore are:"
-                                       " turbo possibility: %ld, is priority core: %ld.\n",
+                                       " turbo possibility: %" PRId64 ", "
+                                       "is priority core: %" PRId64 ".\n",
                                        i,
                                        pkt_caps_list.turbo[i],
                                        pkt_caps_list.priority[i]);
        } else {
                cmdline_printf(cl, "Capabilities of [%d] vcore are:"
-                               " turbo possibility: %ld, is priority core: %ld.\n",
+                               " turbo possibility: %" PRId64 ", "
+                               "is priority core: %" PRId64 ".\n",
                                lcore_id,
                                pkt_caps_list.turbo[lcore_id],
                                pkt_caps_list.priority[lcore_id]);
@@ -378,7 +376,7 @@ cmdline_parse_inst_t cmd_query_caps_list = {
 static int
 check_response_cmd(unsigned int lcore_id, int *result)
 {
-       struct channel_packet pkt;
+       struct rte_power_channel_packet pkt;
        int ret;
 
        ret = rte_power_guest_channel_receive_msg(&pkt, sizeof pkt, lcore_id);
@@ -386,10 +384,10 @@ check_response_cmd(unsigned int lcore_id, int *result)
                return -1;
 
        switch (pkt.command) {
-       case(CPU_POWER_CMD_ACK):
+       case(RTE_POWER_CMD_ACK):
                *result = 1;
                break;
-       case(CPU_POWER_CMD_NACK):
+       case(RTE_POWER_CMD_NACK):
                *result = 0;
                break;
        default:
@@ -446,7 +444,7 @@ cmdline_parse_token_string_t cmd_set_cpu_freq =
                        set_cpu_freq, "set_cpu_freq");
 cmdline_parse_token_num_t cmd_set_cpu_freq_core_num =
        TOKEN_NUM_INITIALIZER(struct cmd_set_cpu_freq_result,
-                       lcore_id, UINT8);
+                       lcore_id, RTE_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#enable_turbo#disable_turbo");
@@ -471,7 +469,7 @@ struct cmd_send_policy_result {
 };
 
 static inline int
-send_policy(struct channel_packet *pkt, struct cmdline *cl)
+send_policy(struct rte_power_channel_packet *pkt, struct cmdline *cl)
 {
        int ret;