X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=examples%2Fvm_power_manager%2Fchannel_monitor.c;h=99f81544d761a92907851246b0022637621d226a;hb=4f72c21fdffa9074f0df9d5855522735ec61f4d7;hp=22f2eb81949e712cbbd64dd33fda6eb8ea829480;hpb=1b897991473fc2fe76a130c527ab0cc93b1ac72a;p=dpdk.git diff --git a/examples/vm_power_manager/channel_monitor.c b/examples/vm_power_manager/channel_monitor.c index 22f2eb8194..99f81544d7 100644 --- a/examples/vm_power_manager/channel_monitor.c +++ b/examples/vm_power_manager/channel_monitor.c @@ -21,17 +21,20 @@ #else #pragma message "Jansson dev libs unavailable, not including JSON parsing" #endif +#include #include #include #include #include #include #include +#ifdef RTE_NET_I40E #include +#endif +#include #include #include "channel_monitor.h" -#include "channel_commands.h" #include "channel_manager.h" #include "power_manager.h" #include "oob_monitor.h" @@ -50,21 +53,21 @@ static volatile unsigned run_loop = 1; static int global_event_fd; static unsigned int policy_is_set; static struct epoll_event *global_events_list; -static struct policy policies[MAX_CLIENTS]; +static struct policy policies[RTE_MAX_LCORE]; #ifdef USE_JANSSON union PFID { - struct ether_addr addr; + struct rte_ether_addr addr; uint64_t pfid; }; static int -str_to_ether_addr(const char *a, struct ether_addr *ether_addr) +str_to_ether_addr(const char *a, struct rte_ether_addr *ether_addr) { int i; char *end; - unsigned long o[ETHER_ADDR_LEN]; + unsigned long o[RTE_ETHER_ADDR_LEN]; i = 0; do { @@ -80,14 +83,14 @@ str_to_ether_addr(const char *a, struct ether_addr *ether_addr) return -1; /* Support the format XX:XX:XX:XX:XX:XX */ - if (i == ETHER_ADDR_LEN) { + if (i == RTE_ETHER_ADDR_LEN) { while (i-- != 0) { if (o[i] > UINT8_MAX) return -1; ether_addr->addr_bytes[i] = (uint8_t)o[i]; } /* Support the format XXXX:XXXX:XXXX */ - } else if (i == ETHER_ADDR_LEN / 2) { + } else if (i == RTE_ETHER_ADDR_LEN / 2) { while (i-- != 0) { if (o[i] > UINT16_MAX) return -1; @@ -104,7 +107,7 @@ str_to_ether_addr(const char *a, struct ether_addr *ether_addr) } static int -set_policy_mac(struct channel_packet *pkt, int idx, char *mac) +set_policy_mac(struct rte_power_channel_packet *pkt, int idx, char *mac) { union PFID pfid; int ret; @@ -129,45 +132,81 @@ set_policy_mac(struct channel_packet *pkt, int idx, char *mac) return 0; } +static char* +get_resource_name_from_chn_path(const char *channel_path) +{ + char *substr = NULL; + + substr = strstr(channel_path, CHANNEL_MGR_FIFO_PATTERN_NAME); + + return substr; +} + +static int +get_resource_id_from_vmname(const char *vm_name) +{ + int result = -1; + int off = 0; + + if (vm_name == NULL) + return -1; + + while (vm_name[off] != '\0') { + if (isdigit(vm_name[off])) + break; + off++; + } + result = atoi(&vm_name[off]); + if ((result == 0) && (vm_name[off] != '0')) + return -1; + + return result; +} static int -parse_json_to_pkt(json_t *element, struct channel_packet *pkt) +parse_json_to_pkt(json_t *element, struct rte_power_channel_packet *pkt, + const char *vm_name) { const char *key; json_t *value; int ret; + int resource_id; - memset(pkt, 0, sizeof(struct channel_packet)); + memset(pkt, 0, sizeof(*pkt)); pkt->nb_mac_to_monitor = 0; pkt->t_boost_status.tbEnabled = false; - pkt->workload = LOW; - pkt->policy_to_use = TIME; - pkt->command = PKT_POLICY; - pkt->core_type = CORE_TYPE_PHYSICAL; + pkt->workload = RTE_POWER_WL_LOW; + pkt->policy_to_use = RTE_POWER_POLICY_TIME; + pkt->command = RTE_POWER_PKT_POLICY; + pkt->core_type = RTE_POWER_CORE_TYPE_PHYSICAL; + + if (vm_name == NULL) { + RTE_LOG(ERR, CHANNEL_MONITOR, + "vm_name is NULL, request rejected !\n"); + return -1; + } json_object_foreach(element, key, value) { if (!strcmp(key, "policy")) { /* Recurse in to get the contents of profile */ - ret = parse_json_to_pkt(value, pkt); + ret = parse_json_to_pkt(value, pkt, vm_name); if (ret) return ret; } else if (!strcmp(key, "instruction")) { /* Recurse in to get the contents of instruction */ - ret = parse_json_to_pkt(value, pkt); + ret = parse_json_to_pkt(value, pkt, vm_name); if (ret) return ret; - } else if (!strcmp(key, "name")) { - strcpy(pkt->vm_name, json_string_value(value)); } else if (!strcmp(key, "command")) { char command[32]; - snprintf(command, 32, "%s", json_string_value(value)); + strlcpy(command, json_string_value(value), 32); if (!strcmp(command, "power")) { - pkt->command = CPU_POWER; + pkt->command = RTE_POWER_CPU_POWER; } else if (!strcmp(command, "create")) { - pkt->command = PKT_POLICY; + pkt->command = RTE_POWER_PKT_POLICY; } else if (!strcmp(command, "destroy")) { - pkt->command = PKT_POLICY_REMOVE; + pkt->command = RTE_POWER_PKT_POLICY_REMOVE; } else { RTE_LOG(ERR, CHANNEL_MONITOR, "Invalid command received in JSON\n"); @@ -175,15 +214,19 @@ parse_json_to_pkt(json_t *element, struct channel_packet *pkt) } } else if (!strcmp(key, "policy_type")) { char command[32]; - snprintf(command, 32, "%s", json_string_value(value)); + strlcpy(command, json_string_value(value), 32); if (!strcmp(command, "TIME")) { - pkt->policy_to_use = TIME; + pkt->policy_to_use = + RTE_POWER_POLICY_TIME; } else if (!strcmp(command, "TRAFFIC")) { - pkt->policy_to_use = TRAFFIC; + pkt->policy_to_use = + RTE_POWER_POLICY_TRAFFIC; } else if (!strcmp(command, "WORKLOAD")) { - pkt->policy_to_use = WORKLOAD; + pkt->policy_to_use = + RTE_POWER_POLICY_WORKLOAD; } else if (!strcmp(command, "BRANCH_RATIO")) { - pkt->policy_to_use = BRANCH_RATIO; + pkt->policy_to_use = + RTE_POWER_POLICY_BRANCH_RATIO; } else { RTE_LOG(ERR, CHANNEL_MONITOR, "Wrong policy_type received in JSON\n"); @@ -191,13 +234,13 @@ parse_json_to_pkt(json_t *element, struct channel_packet *pkt) } } else if (!strcmp(key, "workload")) { char command[32]; - snprintf(command, 32, "%s", json_string_value(value)); + strlcpy(command, json_string_value(value), 32); if (!strcmp(command, "HIGH")) { - pkt->workload = HIGH; + pkt->workload = RTE_POWER_WL_HIGH; } else if (!strcmp(command, "MEDIUM")) { - pkt->workload = MEDIUM; + pkt->workload = RTE_POWER_WL_MEDIUM; } else if (!strcmp(command, "LOW")) { - pkt->workload = LOW; + pkt->workload = RTE_POWER_WL_LOW; } else { RTE_LOG(ERR, CHANNEL_MONITOR, "Wrong workload received in JSON\n"); @@ -221,24 +264,15 @@ parse_json_to_pkt(json_t *element, struct channel_packet *pkt) json_array_get(value, i)); pkt->timer_policy.quiet_hours[i] = hour; } - } else if (!strcmp(key, "core_list")) { - unsigned int i; - size_t size = json_array_size(value); - - for (i = 0; i < size; i++) { - int core = (int)json_integer_value( - json_array_get(value, i)); - pkt->vcpu_to_control[i] = core; - } - pkt->num_vcpu = size; } else if (!strcmp(key, "mac_list")) { unsigned int i; size_t size = json_array_size(value); for (i = 0; i < size; i++) { char mac[32]; - snprintf(mac, 32, "%s", json_string_value( - json_array_get(value, i))); + strlcpy(mac, + json_string_value(json_array_get(value, i)), + 32); set_policy_mac(pkt, i, mac); } pkt->nb_mac_to_monitor = size; @@ -250,31 +284,39 @@ parse_json_to_pkt(json_t *element, struct channel_packet *pkt) (uint32_t)json_integer_value(value); } else if (!strcmp(key, "unit")) { char unit[32]; - snprintf(unit, 32, "%s", json_string_value(value)); + strlcpy(unit, json_string_value(value), 32); if (!strcmp(unit, "SCALE_UP")) { - pkt->unit = CPU_POWER_SCALE_UP; + pkt->unit = RTE_POWER_SCALE_UP; } else if (!strcmp(unit, "SCALE_DOWN")) { - pkt->unit = CPU_POWER_SCALE_DOWN; + pkt->unit = RTE_POWER_SCALE_DOWN; } else if (!strcmp(unit, "SCALE_MAX")) { - pkt->unit = CPU_POWER_SCALE_MAX; + pkt->unit = RTE_POWER_SCALE_MAX; } else if (!strcmp(unit, "SCALE_MIN")) { - pkt->unit = CPU_POWER_SCALE_MIN; + pkt->unit = RTE_POWER_SCALE_MIN; } else if (!strcmp(unit, "ENABLE_TURBO")) { - pkt->unit = CPU_POWER_ENABLE_TURBO; + pkt->unit = RTE_POWER_ENABLE_TURBO; } else if (!strcmp(unit, "DISABLE_TURBO")) { - pkt->unit = CPU_POWER_DISABLE_TURBO; + pkt->unit = RTE_POWER_DISABLE_TURBO; } else { RTE_LOG(ERR, CHANNEL_MONITOR, "Invalid command received in JSON\n"); return -1; } - } else if (!strcmp(key, "resource_id")) { - pkt->resource_id = (uint32_t)json_integer_value(value); } else { RTE_LOG(ERR, CHANNEL_MONITOR, "Unknown key received in JSON string: %s\n", key); } + + resource_id = get_resource_id_from_vmname(vm_name); + if (resource_id < 0) { + RTE_LOG(ERR, CHANNEL_MONITOR, + "Could not get resource_id from vm_name:%s\n", + vm_name); + return -1; + } + strlcpy(pkt->vm_name, vm_name, RTE_POWER_VM_MAX_NAME_SZ); + pkt->resource_id = resource_id; } return 0; } @@ -328,7 +370,7 @@ pcpu_monitor(struct policy *pol, struct core_info *ci, int pcpu, int count) { int ret = 0; - if (pol->pkt.policy_to_use == BRANCH_RATIO) { + if (pol->pkt.policy_to_use == RTE_POWER_POLICY_BRANCH_RATIO) { ci->cd[pcpu].oob_enabled = 1; ret = add_core_to_monitor(pcpu); if (ret == 0) @@ -368,7 +410,7 @@ get_pcpu_to_control(struct policy *pol) * differenciate between them when adding them to the branch monitor. * Virtual cores need to be converted to physical cores. */ - if (pol->pkt.core_type == CORE_TYPE_VIRTUAL) { + if (pol->pkt.core_type == RTE_POWER_CORE_TYPE_VIRTUAL) { /* * If the cores in the policy are virtual, we need to map them * to physical core. We look up the vm info and use that for @@ -400,8 +442,12 @@ get_pfid(struct policy *pol) for (i = 0; i < pol->pkt.nb_mac_to_monitor; i++) { RTE_ETH_FOREACH_DEV(x) { +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_query_vfid_by_mac(x, - (struct ether_addr *)&(pol->pkt.vfid[i])); + (struct rte_ether_addr *)&(pol->pkt.vfid[i])); +#else + ret = -ENOTSUP; +#endif if (ret != -EINVAL) { pol->port[i] = x; break; @@ -420,24 +466,28 @@ get_pfid(struct policy *pol) } static int -update_policy(struct channel_packet *pkt) +update_policy(struct rte_power_channel_packet *pkt) { unsigned int updated = 0; - int i; + unsigned int i; RTE_LOG(INFO, CHANNEL_MONITOR, "Applying policy for %s\n", pkt->vm_name); - for (i = 0; i < MAX_CLIENTS; i++) { + for (i = 0; i < RTE_DIM(policies); i++) { if (strcmp(policies[i].pkt.vm_name, pkt->vm_name) == 0) { /* Copy the contents of *pkt into the policy.pkt */ policies[i].pkt = *pkt; get_pcpu_to_control(&policies[i]); - if (get_pfid(&policies[i]) < 0) { - updated = 1; - break; + /* Check Eth dev only for Traffic policy */ + if (policies[i].pkt.policy_to_use == + RTE_POWER_POLICY_TRAFFIC) { + if (get_pfid(&policies[i]) < 0) { + updated = 1; + break; + } } core_share_status(i); policies[i].enabled = 1; @@ -445,12 +495,18 @@ update_policy(struct channel_packet *pkt) } } if (!updated) { - for (i = 0; i < MAX_CLIENTS; i++) { + for (i = 0; i < RTE_DIM(policies); i++) { if (policies[i].enabled == 0) { policies[i].pkt = *pkt; get_pcpu_to_control(&policies[i]); - if (get_pfid(&policies[i]) < 0) - break; + /* Check Eth dev only for Traffic policy */ + if (policies[i].pkt.policy_to_use == + RTE_POWER_POLICY_TRAFFIC) { + if (get_pfid(&policies[i]) < 0) { + updated = 1; + break; + } + } core_share_status(i); policies[i].enabled = 1; break; @@ -461,15 +517,15 @@ update_policy(struct channel_packet *pkt) } static int -remove_policy(struct channel_packet *pkt __rte_unused) +remove_policy(struct rte_power_channel_packet *pkt __rte_unused) { - int i; + unsigned int i; /* * Disabling the policy is simply a case of setting * enabled to 0 */ - for (i = 0; i < MAX_CLIENTS; i++) { + for (i = 0; i < RTE_DIM(policies); i++) { if (strcmp(policies[i].pkt.vm_name, pkt->vm_name) == 0) { policies[i].enabled = 0; return 0; @@ -487,15 +543,21 @@ get_pkt_diff(struct policy *pol) vsi_pkt_count_prev_total = 0; double rdtsc_curr, rdtsc_diff, diff; int x; +#ifdef RTE_NET_I40E struct rte_eth_stats vf_stats; +#endif for (x = 0; x < pol->pkt.nb_mac_to_monitor; x++) { +#ifdef RTE_NET_I40E /*Read vsi stats*/ if (rte_pmd_i40e_get_vf_stats(x, pol->pfid[x], &vf_stats) == 0) vsi_pkt_count = vf_stats.ipackets; else vsi_pkt_count = -1; +#else + vsi_pkt_count = -1; +#endif vsi_pkt_total += vsi_pkt_count; @@ -558,7 +620,7 @@ apply_time_profile(struct policy *pol) /* Format the date and time, down to a single second. */ strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", ptm); - for (x = 0; x < HOURS; x++) { + for (x = 0; x < RTE_POWER_HOURS_PER_DAY; x++) { if (ptm->tm_hour == pol->pkt.timer_policy.busy_hours[x]) { for (count = 0; count < pol->pkt.num_vcpu; count++) { @@ -591,19 +653,19 @@ apply_workload_profile(struct policy *pol) int count; - if (pol->pkt.workload == HIGH) { + if (pol->pkt.workload == RTE_POWER_WL_HIGH) { for (count = 0; count < pol->pkt.num_vcpu; count++) { if (pol->core_share[count].status != 1) power_manager_scale_core_max( pol->core_share[count].pcpu); } - } else if (pol->pkt.workload == MEDIUM) { + } else if (pol->pkt.workload == RTE_POWER_WL_MEDIUM) { for (count = 0; count < pol->pkt.num_vcpu; count++) { if (pol->core_share[count].status != 1) power_manager_scale_core_med( pol->core_share[count].pcpu); } - } else if (pol->pkt.workload == LOW) { + } else if (pol->pkt.workload == RTE_POWER_WL_LOW) { for (count = 0; count < pol->pkt.num_vcpu; count++) { if (pol->core_share[count].status != 1) power_manager_scale_core_min( @@ -616,20 +678,154 @@ static void apply_policy(struct policy *pol) { - struct channel_packet *pkt = &pol->pkt; + struct rte_power_channel_packet *pkt = &pol->pkt; /*Check policy to use*/ - if (pkt->policy_to_use == TRAFFIC) + if (pkt->policy_to_use == RTE_POWER_POLICY_TRAFFIC) apply_traffic_profile(pol); - else if (pkt->policy_to_use == TIME) + else if (pkt->policy_to_use == RTE_POWER_POLICY_TIME) apply_time_profile(pol); - else if (pkt->policy_to_use == WORKLOAD) + else if (pkt->policy_to_use == RTE_POWER_POLICY_WORKLOAD) apply_workload_profile(pol); } static int -process_request(struct channel_packet *pkt, struct channel_info *chan_info) +write_binary_packet(void *buffer, + size_t buffer_len, + struct channel_info *chan_info) +{ + int ret; + + if (buffer_len == 0 || buffer == NULL) + return -1; + + if (chan_info->fd < 0) { + RTE_LOG(ERR, CHANNEL_MONITOR, "Channel is not connected\n"); + return -1; + } + + while (buffer_len > 0) { + ret = write(chan_info->fd, buffer, buffer_len); + if (ret == -1) { + if (errno == EINTR) + continue; + RTE_LOG(ERR, CHANNEL_MONITOR, "Write function failed due to %s.\n", + strerror(errno)); + return -1; + } + buffer = (char *)buffer + ret; + buffer_len -= ret; + } + return 0; +} + +static int +send_freq(struct rte_power_channel_packet *pkt, + struct channel_info *chan_info, + bool freq_list) +{ + unsigned int vcore_id = pkt->resource_id; + struct rte_power_channel_packet_freq_list channel_pkt_freq_list; + struct vm_info info; + + if (get_info_vm(pkt->vm_name, &info) != 0) + return -1; + + if (!freq_list && vcore_id >= RTE_POWER_MAX_VCPU_PER_VM) + return -1; + + if (!info.allow_query) + return -1; + + channel_pkt_freq_list.command = RTE_POWER_FREQ_LIST; + channel_pkt_freq_list.num_vcpu = info.num_vcpus; + + if (freq_list) { + unsigned int i; + for (i = 0; i < info.num_vcpus; i++) + channel_pkt_freq_list.freq_list[i] = + power_manager_get_current_frequency(info.pcpu_map[i]); + } else { + channel_pkt_freq_list.freq_list[vcore_id] = + power_manager_get_current_frequency(info.pcpu_map[vcore_id]); + } + + return write_binary_packet(&channel_pkt_freq_list, + sizeof(channel_pkt_freq_list), + chan_info); +} + +static int +send_capabilities(struct rte_power_channel_packet *pkt, + struct channel_info *chan_info, + bool list_requested) { + unsigned int vcore_id = pkt->resource_id; + struct rte_power_channel_packet_caps_list channel_pkt_caps_list; + struct vm_info info; + struct rte_power_core_capabilities caps; + int ret; + + if (get_info_vm(pkt->vm_name, &info) != 0) + return -1; + + if (!list_requested && vcore_id >= RTE_POWER_MAX_VCPU_PER_VM) + return -1; + + if (!info.allow_query) + return -1; + + channel_pkt_caps_list.command = RTE_POWER_CAPS_LIST; + channel_pkt_caps_list.num_vcpu = info.num_vcpus; + + if (list_requested) { + unsigned int i; + for (i = 0; i < info.num_vcpus; i++) { + ret = rte_power_get_capabilities(info.pcpu_map[i], + &caps); + if (ret == 0) { + channel_pkt_caps_list.turbo[i] = + caps.turbo; + channel_pkt_caps_list.priority[i] = + caps.priority; + } else + return -1; + + } + } else { + ret = rte_power_get_capabilities(info.pcpu_map[vcore_id], + &caps); + if (ret == 0) { + channel_pkt_caps_list.turbo[vcore_id] = + caps.turbo; + channel_pkt_caps_list.priority[vcore_id] = + caps.priority; + } else + return -1; + } + + return write_binary_packet(&channel_pkt_caps_list, + sizeof(channel_pkt_caps_list), + chan_info); +} + +static int +send_ack_for_received_cmd(struct rte_power_channel_packet *pkt, + struct channel_info *chan_info, + uint32_t command) +{ + pkt->command = command; + return write_binary_packet(pkt, + sizeof(*pkt), + chan_info); +} + +static int +process_request(struct rte_power_channel_packet *pkt, + struct channel_info *chan_info) +{ + int ret; + if (chan_info == NULL) return -1; @@ -637,49 +833,101 @@ process_request(struct channel_packet *pkt, struct channel_info *chan_info) CHANNEL_MGR_CHANNEL_PROCESSING) == 0) return -1; - if (pkt->command == CPU_POWER) { + if (pkt->command == RTE_POWER_CPU_POWER) { unsigned int core_num; - if (pkt->core_type == CORE_TYPE_VIRTUAL) + if (pkt->core_type == RTE_POWER_CORE_TYPE_VIRTUAL) core_num = get_pcpu(chan_info, pkt->resource_id); else core_num = pkt->resource_id; + RTE_LOG(DEBUG, CHANNEL_MONITOR, "Processing requested cmd for cpu:%d\n", + core_num); + + int scale_res; + bool valid_unit = true; + switch (pkt->unit) { - case(CPU_POWER_SCALE_MIN): - power_manager_scale_core_min(core_num); + case(RTE_POWER_SCALE_MIN): + scale_res = power_manager_scale_core_min(core_num); break; - case(CPU_POWER_SCALE_MAX): - power_manager_scale_core_max(core_num); + case(RTE_POWER_SCALE_MAX): + scale_res = power_manager_scale_core_max(core_num); break; - case(CPU_POWER_SCALE_DOWN): - power_manager_scale_core_down(core_num); + case(RTE_POWER_SCALE_DOWN): + scale_res = power_manager_scale_core_down(core_num); break; - case(CPU_POWER_SCALE_UP): - power_manager_scale_core_up(core_num); + case(RTE_POWER_SCALE_UP): + scale_res = power_manager_scale_core_up(core_num); break; - case(CPU_POWER_ENABLE_TURBO): - power_manager_enable_turbo_core(core_num); + case(RTE_POWER_ENABLE_TURBO): + scale_res = power_manager_enable_turbo_core(core_num); break; - case(CPU_POWER_DISABLE_TURBO): - power_manager_disable_turbo_core(core_num); + case(RTE_POWER_DISABLE_TURBO): + scale_res = power_manager_disable_turbo_core(core_num); break; default: + valid_unit = false; break; } + + if (valid_unit) { + ret = send_ack_for_received_cmd(pkt, + chan_info, + scale_res >= 0 ? + RTE_POWER_CMD_ACK : + RTE_POWER_CMD_NACK); + if (ret < 0) + RTE_LOG(ERR, CHANNEL_MONITOR, "Error during sending ack command.\n"); + } else + RTE_LOG(ERR, CHANNEL_MONITOR, "Unexpected unit type.\n"); + } - if (pkt->command == PKT_POLICY) { + if (pkt->command == RTE_POWER_PKT_POLICY) { RTE_LOG(INFO, CHANNEL_MONITOR, "Processing policy request %s\n", pkt->vm_name); + int ret = send_ack_for_received_cmd(pkt, + chan_info, + RTE_POWER_CMD_ACK); + if (ret < 0) + RTE_LOG(ERR, CHANNEL_MONITOR, "Error during sending ack command.\n"); update_policy(pkt); policy_is_set = 1; } - if (pkt->command == PKT_POLICY_REMOVE) { + if (pkt->command == RTE_POWER_PKT_POLICY_REMOVE) { + ret = remove_policy(pkt); + if (ret == 0) + RTE_LOG(INFO, CHANNEL_MONITOR, + "Removed policy %s\n", pkt->vm_name); + else + RTE_LOG(INFO, CHANNEL_MONITOR, + "Policy %s does not exist\n", pkt->vm_name); + } + + if (pkt->command == RTE_POWER_QUERY_FREQ_LIST || + pkt->command == RTE_POWER_QUERY_FREQ) { + RTE_LOG(INFO, CHANNEL_MONITOR, - "Removing policy %s\n", pkt->vm_name); - remove_policy(pkt); + "Frequency for %s requested.\n", pkt->vm_name); + int ret = send_freq(pkt, + chan_info, + pkt->command == RTE_POWER_QUERY_FREQ_LIST); + if (ret < 0) + RTE_LOG(ERR, CHANNEL_MONITOR, "Error during frequency sending.\n"); + } + + if (pkt->command == RTE_POWER_QUERY_CAPS_LIST || + pkt->command == RTE_POWER_QUERY_CAPS) { + + RTE_LOG(INFO, CHANNEL_MONITOR, + "Capabilities for %s requested.\n", pkt->vm_name); + int ret = send_capabilities(pkt, + chan_info, + pkt->command == RTE_POWER_QUERY_CAPS_LIST); + if (ret < 0) + RTE_LOG(ERR, CHANNEL_MONITOR, "Error during sending capabilities.\n"); } /* @@ -746,7 +994,7 @@ channel_monitor_init(void) static void read_binary_packet(struct channel_info *chan_info) { - struct channel_packet pkt; + struct rte_power_channel_packet pkt; void *buffer = &pkt; int buffer_len = sizeof(pkt); int n_bytes, err = 0; @@ -777,10 +1025,14 @@ read_binary_packet(struct channel_info *chan_info) static void read_json_packet(struct channel_info *chan_info) { - struct channel_packet pkt; + struct rte_power_channel_packet pkt; int n_bytes, ret; json_t *root; json_error_t error; + const char *resource_name; + char *start, *end; + uint32_t n; + /* read opening brace to closing brace */ do { @@ -796,18 +1048,13 @@ read_json_packet(struct channel_info *chan_info) indent--; if ((indent > 0) || (idx > 0)) idx++; - if (indent == 0) + if (indent <= 0) json_data[idx] = 0; if (idx >= MAX_JSON_STRING_LEN-1) break; } while (indent > 0); - if (indent > 0) - /* - * We've broken out of the read loop without getting - * a closing brace, so throw away the data - */ - json_data[idx] = 0; + json_data[idx] = '\0'; if (strlen(json_data) == 0) continue; @@ -817,20 +1064,42 @@ read_json_packet(struct channel_info *chan_info) root = json_loads(json_data, 0, &error); if (root) { + resource_name = get_resource_name_from_chn_path( + chan_info->channel_path); /* * Because our data is now in the json * object, we can overwrite the pkt - * with a channel_packet struct, using + * with a rte_power_channel_packet struct, using * parse_json_to_pkt() */ - ret = parse_json_to_pkt(root, &pkt); + ret = parse_json_to_pkt(root, &pkt, resource_name); json_decref(root); if (ret) { RTE_LOG(ERR, CHANNEL_MONITOR, "Error validating JSON profile data\n"); break; } - process_request(&pkt, chan_info); + start = strstr(pkt.vm_name, + CHANNEL_MGR_FIFO_PATTERN_NAME); + if (start != NULL) { + /* move past pattern to start of fifo id */ + start += strlen(CHANNEL_MGR_FIFO_PATTERN_NAME); + + end = start; + n = (uint32_t)strtoul(start, &end, 10); + + if (end[0] == '\0') { + /* Add core id to core list */ + pkt.num_vcpu = 1; + pkt.vcpu_to_control[0] = n; + process_request(&pkt, chan_info); + } else { + RTE_LOG(ERR, CHANNEL_MONITOR, + "Cannot extract core id from fifo name\n"); + } + } else { + process_request(&pkt, chan_info); + } } else { RTE_LOG(ERR, CHANNEL_MONITOR, "JSON error on line %d: %s\n", @@ -880,9 +1149,9 @@ run_channel_monitor(void) } rte_delay_us(time_period_ms*1000); if (policy_is_set) { - int j; + unsigned int j; - for (j = 0; j < MAX_CLIENTS; j++) { + for (j = 0; j < RTE_DIM(policies); j++) { if (policies[j].enabled == 1) apply_policy(&policies[j]); }