From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from tama500.ecl.ntt.co.jp (tama500.ecl.ntt.co.jp [129.60.39.148]) by dpdk.org (Postfix) with ESMTP id 7B43B1B42C for ; Tue, 25 Dec 2018 08:37:49 +0100 (CET) Received: from vc1.ecl.ntt.co.jp (vc1.ecl.ntt.co.jp [129.60.86.153]) by tama500.ecl.ntt.co.jp (8.13.8/8.13.8) with ESMTP id wBP7blos000570; Tue, 25 Dec 2018 16:37:47 +0900 Received: from vc1.ecl.ntt.co.jp (localhost [127.0.0.1]) by vc1.ecl.ntt.co.jp (Postfix) with ESMTP id B731CEA7D53; Tue, 25 Dec 2018 16:37:47 +0900 (JST) Received: from localhost.localdomain (lobster.nslab.ecl.ntt.co.jp [129.60.13.95]) by vc1.ecl.ntt.co.jp (Postfix) with ESMTP id A4320EA7D4A; Tue, 25 Dec 2018 16:37:47 +0900 (JST) From: ogawa.yasufumi@lab.ntt.co.jp To: ferruh.yigit@intel.com, spp@dpdk.org, ogawa.yasufumi@lab.ntt.co.jp Date: Tue, 25 Dec 2018 16:35:33 +0900 Message-Id: <1545723335-3547-3-git-send-email-ogawa.yasufumi@lab.ntt.co.jp> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1545723335-3547-1-git-send-email-ogawa.yasufumi@lab.ntt.co.jp> References: <1545723335-3547-1-git-send-email-ogawa.yasufumi@lab.ntt.co.jp> X-TM-AS-MML: disable Subject: [spp] [PATCH 2/4] spp_nfv: add header files of params and funcs X-BeenThere: spp@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Soft Patch Panel List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 25 Dec 2018 07:37:50 -0000 From: Yasufumi Ogawa Add header files for moved variables and functions from spp_nfv. You should keep in mind of the order of headers other than `nfv.h`, or just include `nfv.h`. You should include `common.h` before all of these header files. * src/nfv/params.h # define params and structs * src/nfv/command_utils.h # util functions for cmds * src/nfv/commands.h # spp_nfv cmds, add, del, or etc. * src/nfv/nfv.h # you include this file for all of others Signed-off-by: Yasufumi Ogawa --- src/nfv/command_utils.h | 140 +++++++++++ src/nfv/commands.h | 621 ++++++++++++++++++++++++++++++++++++++++++++++++ src/nfv/nfv.h | 13 + src/nfv/params.h | 41 ++++ 4 files changed, 815 insertions(+) create mode 100644 src/nfv/command_utils.h create mode 100644 src/nfv/commands.h create mode 100644 src/nfv/nfv.h create mode 100644 src/nfv/params.h diff --git a/src/nfv/command_utils.h b/src/nfv/command_utils.h new file mode 100644 index 0000000..e84eaa7 --- /dev/null +++ b/src/nfv/command_utils.h @@ -0,0 +1,140 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Nippon Telegraph and Telephone Corporation. + */ + +#ifndef NFV_COMMAND_UTILS_H +#define NFV_COMMAND_UTILS_H + +#include "common.h" +#include "nfv.h" + +static void +forward_array_init_one(unsigned int i) +{ + ports_fwd_array[i].in_port_id = PORT_RESET; + ports_fwd_array[i].out_port_id = PORT_RESET; +} + +static void +forward_array_remove(int port_id) +{ + unsigned int i; + + /* Update ports_fwd_array */ + forward_array_init_one(port_id); + + for (i = 0; i < RTE_MAX_ETHPORTS; i++) { + if (ports_fwd_array[i].in_port_id == PORT_RESET) + continue; + + if (ports_fwd_array[i].out_port_id == port_id) { + ports_fwd_array[i].out_port_id = PORT_RESET; + break; + } + } +} + +static void +port_map_init_one(unsigned int i) +{ + port_map[i].id = PORT_RESET; + port_map[i].port_type = UNDEF; + port_map[i].stats = &port_map[i].default_stats; +} + +static void +port_map_init(void) +{ + unsigned int i; + + for (i = 0; i < RTE_MAX_ETHPORTS; i++) + port_map_init_one(i); +} + +/* Return 0 if invalid */ +static int +is_valid_port(uint16_t port_id) +{ + if (port_id > RTE_MAX_ETHPORTS) + return 0; + + return port_map[port_id].id != PORT_RESET; +} + +/* + * Create an empty rx pcap file to given path if it does not exit + * Return 0 for succeeded, or -1 for failed. + */ +static int +create_pcap_rx(char *rx_fpath) +{ + int res; + FILE *tmp_fp; + char cmd_str[256]; + + // empty file is required for 'text2pcap' command for + // creating a pcap file. + char template[] = "/tmp/spp-emptyfile.txt"; + + // create empty file if it is not exist + tmp_fp = fopen(template, "r"); + if (tmp_fp == NULL) { + (tmp_fp = fopen(template, "w")); + if (tmp_fp == NULL) { + RTE_LOG(ERR, APP, "Failed to open %s\n", template); + return -1; + } + } + + sprintf(cmd_str, "text2pcap %s %s", template, rx_fpath); + res = system(cmd_str); + if (res != 0) { + RTE_LOG(ERR, APP, + "Failed to create pcap device %s\n", + rx_fpath); + return -1; + } + RTE_LOG(INFO, APP, "PCAP device created\n"); + fclose(tmp_fp); + return 0; +} + +/* initialize forward array with default value*/ +static void +forward_array_init(void) +{ + unsigned int i; + + /* initialize port forward array*/ + for (i = 0; i < RTE_MAX_ETHPORTS; i++) + forward_array_init_one(i); +} + +static void +forward_array_reset(void) +{ + unsigned int i; + + /* initialize port forward array*/ + for (i = 0; i < RTE_MAX_ETHPORTS; i++) { + if (ports_fwd_array[i].in_port_id != PORT_RESET) { + ports_fwd_array[i].out_port_id = PORT_RESET; + RTE_LOG(INFO, APP, "Port ID %d\n", i); + RTE_LOG(INFO, APP, "out_port_id %d\n", + ports_fwd_array[i].out_port_id); + } + } +} + +/* Return a type of port as a enum member of porttype_map structure. */ +static enum port_type get_port_type(char *portname) +{ + for (int i = 0; portmap[i].port_name != NULL; i++) { + const char *port_name = portmap[i].port_name; + if (strncmp(portname, port_name, strlen(port_name)) == 0) + return portmap[i].port_type; + } + return UNDEF; +} + +#endif diff --git a/src/nfv/commands.h b/src/nfv/commands.h new file mode 100644 index 0000000..89dfd31 --- /dev/null +++ b/src/nfv/commands.h @@ -0,0 +1,621 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Nippon Telegraph and Telephone Corporation. + */ + +#ifndef NFV_COMMANDS_H +#define NFV_COMMANDS_H + +#include "common.h" +#include "nfv.h" +#include "command_utils.h" + +/* + * Return actual port ID which is assigned by system internally, or PORT_RESET + * if port is not found. + */ +static uint16_t +find_port_id(int id, enum port_type type) +{ + uint16_t port_id = PORT_RESET; + uint16_t i; + + for (i = 0; i < RTE_MAX_ETHPORTS; i++) { + if (port_map[i].port_type != type) + continue; + + if (port_map[i].id == id) { + port_id = i; + break; + } + } + + return port_id; +} + +static int +do_del(char *res_uid) +{ + uint16_t port_id = PORT_RESET; + char *p_type; + int p_id; + int res; + + res = parse_resource_uid(res_uid, &p_type, &p_id); + if (res < 0) { + RTE_LOG(ERR, APP, + "Failed to parse resource UID\n"); + return -1; + } + + if (!strcmp(p_type, "vhost")) { + port_id = find_port_id(p_id, VHOST); + if (port_id == PORT_RESET) + return -1; + + } else if (!strcmp(p_type, "ring")) { + RTE_LOG(DEBUG, APP, "Del ring id %d\n", p_id); + port_id = find_port_id(p_id, RING); + if (port_id == PORT_RESET) + return -1; + + dev_detach_by_port_id(port_id); + + } else if (!strcmp(p_type, "pcap")) { + port_id = find_port_id(p_id, PCAP); + if (port_id == PORT_RESET) + return -1; + + dev_detach_by_port_id(port_id); + + } else if (!strcmp(p_type, "nullpmd")) { + port_id = find_port_id(p_id, NULLPMD); + if (port_id == PORT_RESET) + return -1; + + dev_detach_by_port_id(port_id); + + } + + forward_array_remove(port_id); + port_map_init_one(port_id); + + return 0; +} + +/* Return -1 as an error if given patch is invalid */ +static int +add_patch(uint16_t in_port, uint16_t out_port) +{ + if (!is_valid_port(in_port) || !is_valid_port(out_port)) + return -1; + + /* Populate in port data */ + ports_fwd_array[in_port].in_port_id = in_port; + ports_fwd_array[in_port].rx_func = &rte_eth_rx_burst; + ports_fwd_array[in_port].tx_func = &rte_eth_tx_burst; + ports_fwd_array[in_port].out_port_id = out_port; + + /* Populate out port data */ + ports_fwd_array[out_port].in_port_id = out_port; + ports_fwd_array[out_port].rx_func = &rte_eth_rx_burst; + ports_fwd_array[out_port].tx_func = &rte_eth_tx_burst; + + RTE_LOG(DEBUG, APP, "STATUS: in port %d in_port_id %d\n", in_port, + ports_fwd_array[in_port].in_port_id); + RTE_LOG(DEBUG, APP, "STATUS: in port %d patch out port id %d\n", + in_port, ports_fwd_array[in_port].out_port_id); + RTE_LOG(DEBUG, APP, "STATUS: outport %d in_port_id %d\n", out_port, + ports_fwd_array[out_port].in_port_id); + + return 0; +} + +/* + * Create ring PMD with given ring_id. + */ +static int +add_ring_pmd(int ring_id) +{ + struct rte_ring *ring; + int res; + char rx_queue_name[32]; /* Prefix and number like as 'eth_ring_0' */ + + memset(rx_queue_name, '\0', sizeof(rx_queue_name)); + sprintf(rx_queue_name, "%s", get_rx_queue_name(ring_id)); + + /* Look up ring with provided ring_id */ + ring = rte_ring_lookup(rx_queue_name); + if (ring == NULL) { + RTE_LOG(ERR, APP, + "Failed to get RX ring %s - is primary running?\n", + rx_queue_name); + return -1; + } + RTE_LOG(INFO, APP, "Looked up ring '%s'\n", rx_queue_name); + + /* create ring pmd*/ + res = rte_eth_from_ring(ring); + if (res < 0) { + RTE_LOG(ERR, APP, + "Cannot create eth dev with rte_eth_from_ring()\n"); + return -1; + } + RTE_LOG(INFO, APP, "Created ring PMD: %d\n", res); + + return res; +} + +static int +add_vhost_pmd(int index) +{ + struct rte_eth_conf port_conf = { + .rxmode = { .max_rx_pkt_len = ETHER_MAX_LEN } + }; + struct rte_mempool *mp; + uint16_t vhost_port_id; + int nr_queues = 1; + const char *name; + char devargs[64]; + char *iface; + uint16_t q; + int ret; +#define NR_DESCS 128 + + mp = rte_mempool_lookup(PKTMBUF_POOL_NAME); + if (mp == NULL) + rte_exit(EXIT_FAILURE, "Cannot get mempool for mbufs\n"); + + /* eth_vhost0 index 0 iface /tmp/sock0 on numa 0 */ + name = get_vhost_backend_name(index); + iface = get_vhost_iface_name(index); + + sprintf(devargs, "%s,iface=%s,queues=%d", name, iface, nr_queues); + ret = dev_attach_by_devargs(devargs, &vhost_port_id); + if (ret < 0) + return ret; + + ret = rte_eth_dev_configure(vhost_port_id, nr_queues, nr_queues, + &port_conf); + if (ret < 0) + return ret; + + /* Allocate and set up 1 RX queue per Ethernet port. */ + for (q = 0; q < nr_queues; q++) { + ret = rte_eth_rx_queue_setup(vhost_port_id, q, NR_DESCS, + rte_eth_dev_socket_id(vhost_port_id), NULL, mp); + if (ret < 0) + return ret; + } + + /* Allocate and set up 1 TX queue per Ethernet port. */ + for (q = 0; q < nr_queues; q++) { + ret = rte_eth_tx_queue_setup(vhost_port_id, q, NR_DESCS, + rte_eth_dev_socket_id(vhost_port_id), NULL); + if (ret < 0) + return ret; + } + + /* Start the Ethernet port. */ + ret = rte_eth_dev_start(vhost_port_id); + if (ret < 0) + return ret; + + RTE_LOG(DEBUG, APP, "vhost port id %d\n", vhost_port_id); + + return vhost_port_id; +} + +/* + * Open pcap files with given index for rx and tx. + * Index is given as a argument of 'patch' command. + * This function returns a port ID if it is succeeded, + * or negative int if failed. + */ +static int +add_pcap_pmd(int index) +{ + struct rte_eth_conf port_conf = { + .rxmode = { .max_rx_pkt_len = ETHER_MAX_LEN } + }; + + struct rte_mempool *mp; + const char *name; + char devargs[256]; + uint16_t pcap_pmd_port_id; + uint16_t nr_queues = 1; + int ret; + + // PCAP file path + char rx_fpath[128]; + char tx_fpath[128]; + + FILE *rx_fp; + + sprintf(rx_fpath, PCAP_IFACE_RX, index); + sprintf(tx_fpath, PCAP_IFACE_TX, index); + + // create rx pcap file if it does not exist + rx_fp = fopen(rx_fpath, "r"); + if (rx_fp == NULL) { + ret = create_pcap_rx(rx_fpath); + if (ret < 0) + return ret; + } + + mp = rte_mempool_lookup(PKTMBUF_POOL_NAME); + if (mp == NULL) + rte_exit(EXIT_FAILURE, "Cannon get mempool for mbuf\n"); + + name = get_pcap_pmd_name(index); + sprintf(devargs, + "%s,rx_pcap=%s,tx_pcap=%s", + name, rx_fpath, tx_fpath); + ret = dev_attach_by_devargs(devargs, &pcap_pmd_port_id); + + if (ret < 0) + return ret; + + ret = rte_eth_dev_configure( + pcap_pmd_port_id, nr_queues, nr_queues, &port_conf); + + if (ret < 0) + return ret; + + /* Allocate and set up 1 RX queue per Ethernet port. */ + uint16_t q; + for (q = 0; q < nr_queues; q++) { + ret = rte_eth_rx_queue_setup( + pcap_pmd_port_id, q, NR_DESCS, + rte_eth_dev_socket_id(pcap_pmd_port_id), + NULL, mp); + if (ret < 0) + return ret; + } + + /* Allocate and set up 1 TX queue per Ethernet port. */ + for (q = 0; q < nr_queues; q++) { + ret = rte_eth_tx_queue_setup( + pcap_pmd_port_id, q, NR_DESCS, + rte_eth_dev_socket_id(pcap_pmd_port_id), + NULL); + if (ret < 0) + return ret; + } + + ret = rte_eth_dev_start(pcap_pmd_port_id); + + if (ret < 0) + return ret; + + RTE_LOG(DEBUG, APP, "pcap port id %d\n", pcap_pmd_port_id); + + return pcap_pmd_port_id; +} + +static int +add_null_pmd(int index) +{ + struct rte_eth_conf port_conf = { + .rxmode = { .max_rx_pkt_len = ETHER_MAX_LEN } + }; + + struct rte_mempool *mp; + const char *name; + char devargs[64]; + uint16_t null_pmd_port_id; + uint16_t nr_queues = 1; + + int ret; + + mp = rte_mempool_lookup(PKTMBUF_POOL_NAME); + if (mp == NULL) + rte_exit(EXIT_FAILURE, "Cannon get mempool for mbuf\n"); + + name = get_null_pmd_name(index); + sprintf(devargs, "%s", name); + ret = dev_attach_by_devargs(devargs, &null_pmd_port_id); + if (ret < 0) + return ret; + + ret = rte_eth_dev_configure( + null_pmd_port_id, nr_queues, nr_queues, + &port_conf); + if (ret < 0) + return ret; + + /* Allocate and set up 1 RX queue per Ethernet port. */ + uint16_t q; + for (q = 0; q < nr_queues; q++) { + ret = rte_eth_rx_queue_setup( + null_pmd_port_id, q, NR_DESCS, + rte_eth_dev_socket_id( + null_pmd_port_id), NULL, mp); + if (ret < 0) + return ret; + } + + /* Allocate and set up 1 TX queue per Ethernet port. */ + for (q = 0; q < nr_queues; q++) { + ret = rte_eth_tx_queue_setup( + null_pmd_port_id, q, NR_DESCS, + rte_eth_dev_socket_id( + null_pmd_port_id), + NULL); + if (ret < 0) + return ret; + } + + ret = rte_eth_dev_start(null_pmd_port_id); + if (ret < 0) + return ret; + + RTE_LOG(DEBUG, APP, "null port id %d\n", null_pmd_port_id); + + return null_pmd_port_id; +} + +/** + * Add a port to this process. Port is described with resource UID which is a + * combination of port type and ID like as 'ring:0'. + */ +static int +do_add(char *res_uid) +{ + enum port_type type = UNDEF; + uint16_t port_id = PORT_RESET; + char *p_type; + int p_id; + int res; + + res = parse_resource_uid(res_uid, &p_type, &p_id); + if (res < 0) + return -1; + + if (!strcmp(p_type, "vhost")) { + type = VHOST; + res = add_vhost_pmd(p_id); + + } else if (!strcmp(p_type, "ring")) { + type = RING; + res = add_ring_pmd(p_id); + + } else if (!strcmp(p_type, "pcap")) { + type = PCAP; + res = add_pcap_pmd(p_id); + + } else if (!strcmp(p_type, "nullpmd")) { + type = NULLPMD; + res = add_null_pmd(p_id); + } + + if (res < 0) + return -1; + + port_id = (uint16_t) res; + port_map[port_id].id = p_id; + port_map[port_id].port_type = type; + port_map[port_id].stats = &ports->client_stats[p_id]; + + /* Update ports_fwd_array with port id */ + ports_fwd_array[port_id].in_port_id = port_id; + + return 0; +} + +static int +do_connection(int *connected, int *sock) +{ + static struct sockaddr_in servaddr; + int ret = 0; + + if (*connected == 0) { + if (*sock < 0) { + RTE_LOG(INFO, APP, "Creating socket...\n"); + *sock = socket(AF_INET, SOCK_STREAM, 0); + if (*sock < 0) + rte_exit(EXIT_FAILURE, "socket error\n"); + + /*Create of the tcp socket*/ + memset(&servaddr, 0, sizeof(servaddr)); + servaddr.sin_family = AF_INET; + servaddr.sin_addr.s_addr = inet_addr(server_ip); + servaddr.sin_port = htons(server_port); + } + + RTE_LOG(INFO, APP, "Trying to connect ... socket %d\n", *sock); + ret = connect(*sock, (struct sockaddr *) &servaddr, + sizeof(servaddr)); + if (ret < 0) { + RTE_LOG(ERR, APP, "Connection Error"); + return ret; + } + + RTE_LOG(INFO, APP, "Connected\n"); + *connected = 1; + } + + return ret; +} + +/* Return -1 if exit command is called to terminate the process */ +static int +parse_command(char *str) +{ + char *token_list[MAX_PARAMETER] = {NULL}; + int max_token = 0; + int ret = 0; + + if (!str) + return 0; + + /* tokenize user command from controller */ + token_list[max_token] = strtok(str, " "); + while (token_list[max_token] != NULL) { + RTE_LOG(DEBUG, APP, "token %d = %s\n", max_token, + token_list[max_token]); + max_token++; + token_list[max_token] = strtok(NULL, " "); + } + + if (max_token == 0) + return 0; + + if (!strcmp(token_list[0], "status")) { + RTE_LOG(DEBUG, APP, "status\n"); + memset(str, '\0', MSG_SIZE); + if (cmd == FORWARD) + get_sec_stats_json(str, client_id, "running", + ports_fwd_array, port_map); + else + get_sec_stats_json(str, client_id, "idling", + ports_fwd_array, port_map); + + } else if (!strcmp(token_list[0], "_get_client_id")) { + memset(str, '\0', MSG_SIZE); + sprintf(str, "%d", client_id); + + } else if (!strcmp(token_list[0], "_set_client_id")) { + int id; + + if (spp_atoi(token_list[1], &id) >= 0) + client_id = id; + + } else if (!strcmp(token_list[0], "exit")) { + RTE_LOG(DEBUG, APP, "exit\n"); + RTE_LOG(DEBUG, APP, "stop\n"); + cmd = STOP; + ret = -1; + + } else if (!strcmp(token_list[0], "stop")) { + RTE_LOG(DEBUG, APP, "stop\n"); + cmd = STOP; + + } else if (!strcmp(token_list[0], "forward")) { + RTE_LOG(DEBUG, APP, "forward\n"); + cmd = FORWARD; + + } else if (!strcmp(token_list[0], "add")) { + RTE_LOG(DEBUG, APP, "Received add command\n"); + if (do_add(token_list[1]) < 0) + RTE_LOG(ERR, APP, "Failed to do_add()\n"); + + } else if (!strcmp(token_list[0], "patch")) { + RTE_LOG(DEBUG, APP, "patch\n"); + + if (max_token <= 1) + return 0; + + if (strncmp(token_list[1], "reset", 5) == 0) { + /* reset forward array*/ + forward_array_reset(); + } else { + uint16_t in_port; + uint16_t out_port; + + if (max_token <= 2) + return 0; + + char *in_p_type; + char *out_p_type; + int in_p_id; + int out_p_id; + + parse_resource_uid(token_list[1], &in_p_type, &in_p_id); + in_port = find_port_id(in_p_id, + get_port_type(in_p_type)); + + parse_resource_uid(token_list[2], + &out_p_type, &out_p_id); + out_port = find_port_id(out_p_id, + get_port_type(out_p_type)); + + if (in_port == PORT_RESET && out_port == PORT_RESET) { + char err_msg[128]; + memset(err_msg, '\0', sizeof(err_msg)); + sprintf(err_msg, "%s '%s:%d' and '%s:%d'", + "Patch not found, both of", + in_p_type, in_p_id, + out_p_type, out_p_id); + RTE_LOG(ERR, APP, "%s\n", err_msg); + } else if (in_port == PORT_RESET) { + char err_msg[128]; + memset(err_msg, '\0', sizeof(err_msg)); + sprintf(err_msg, "%s '%s:%d'", + "Patch not found, in_port", + in_p_type, in_p_id); + RTE_LOG(ERR, APP, "%s\n", err_msg); + } else if (out_port == PORT_RESET) { + char err_msg[128]; + memset(err_msg, '\0', sizeof(err_msg)); + sprintf(err_msg, "%s '%s:%d'", + "Patch not found, out_port", + out_p_type, out_p_id); + RTE_LOG(ERR, APP, "%s\n", err_msg); + } + + if (add_patch(in_port, out_port) == 0) + RTE_LOG(INFO, APP, + "Patched '%s:%d' and '%s:%d'\n", + in_p_type, in_p_id, + out_p_type, out_p_id); + + else + RTE_LOG(ERR, APP, "Failed to patch\n"); + ret = 0; + } + + } else if (!strcmp(token_list[0], "del")) { + RTE_LOG(DEBUG, APP, "Received del command\n"); + + cmd = STOP; + + if (do_del(token_list[1]) < 0) + RTE_LOG(ERR, APP, "Failed to do_del()\n"); + } + + return ret; +} + +static int +do_receive(int *connected, int *sock, char *str) +{ + int ret; + + memset(str, '\0', MSG_SIZE); + + ret = recv(*sock, str, MSG_SIZE, 0); + if (ret <= 0) { + RTE_LOG(DEBUG, APP, "Receive count: %d\n", ret); + if (ret < 0) + RTE_LOG(ERR, APP, "Receive Fail"); + else + RTE_LOG(INFO, APP, "Receive 0\n"); + + RTE_LOG(INFO, APP, "Assume Server closed connection\n"); + close(*sock); + *sock = SOCK_RESET; + *connected = 0; + return -1; + } + + return 0; +} + +static int +do_send(int *connected, int *sock, char *str) +{ + int ret; + + ret = send(*sock, str, MSG_SIZE, 0); + if (ret == -1) { + RTE_LOG(ERR, APP, "send failed"); + *connected = 0; + return -1; + } + + RTE_LOG(INFO, APP, "To Server: %s\n", str); + + return 0; +} + +#endif diff --git a/src/nfv/nfv.h b/src/nfv/nfv.h new file mode 100644 index 0000000..a8e037d --- /dev/null +++ b/src/nfv/nfv.h @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Nippon Telegraph and Telephone Corporation. + */ + +#ifndef NFV_H +#define NFV_H + +#include "common.h" +#include "params.h" +#include "command_utils.h" +#include "commands.h" + +#endif diff --git a/src/nfv/params.h b/src/nfv/params.h new file mode 100644 index 0000000..f7525ae --- /dev/null +++ b/src/nfv/params.h @@ -0,0 +1,41 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Nippon Telegraph and Telephone Corporation. + */ + +#ifndef NFV_PARAMS_H +#define NFV_PARAMS_H + +/* It is used to convert port name from string type to enum */ +struct porttype_map { + const char *port_name; + enum port_type port_type; +}; + +struct porttype_map portmap[] = { + { .port_name = "phy", .port_type = PHY, }, + { .port_name = "ring", .port_type = RING, }, + { .port_name = "vhost", .port_type = VHOST, }, + { .port_name = "pcap", .port_type = PCAP, }, + { .port_name = "nullpmd", .port_type = NULLPMD, }, + { .port_name = NULL, .port_type = UNDEF, }, +}; + +static struct port ports_fwd_array[RTE_MAX_ETHPORTS]; + +static uint16_t client_id; + +/* the port details */ +struct port_info *ports; + +/* + * our client id number - tells us which rx queue to read, and NIC TX + * queue to write to. + */ +static char *server_ip; +static int server_port; + +static enum cmd_type cmd; + +static struct port_map port_map[RTE_MAX_ETHPORTS]; + +#endif -- 2.7.4