X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=examples%2Fflow_classify%2Fflow_classify.c;h=6185b340600ce596a194fc5fa1e9b45a72c462e1;hb=02179f82b9cc20e71dd9c6d8be998d5255824d63;hp=2130c13d8507f7259295865fb92b953b7b0e1120;hpb=28f90c35834b95af115d2810caa0b1968cd7a81f;p=dpdk.git diff --git a/examples/flow_classify/flow_classify.c b/examples/flow_classify/flow_classify.c index 2130c13d85..6185b34060 100644 --- a/examples/flow_classify/flow_classify.c +++ b/examples/flow_classify/flow_classify.c @@ -59,12 +59,7 @@ static struct{ } parm_config; const char cb_port_delim[] = ":"; -static const struct rte_eth_conf port_conf_default = { - .rxmode = { - .max_rx_pkt_len = RTE_ETHER_MAX_LEN, - }, -}; - +/* Creation of flow classifier object. 8< */ struct flow_classifier { struct rte_flow_classifier *cls; }; @@ -72,9 +67,11 @@ struct flow_classifier { struct flow_classifier_acl { struct flow_classifier cls; } __rte_cache_aligned; +/* >8 End of creation of flow classifier object. */ -/* ACL field definitions for IPv4 5 tuple rule */ +/* Creation of ACL table during initialization of application. 8< */ +/* ACL field definitions for IPv4 5 tuple rule */ enum { PROTO_FIELD_IPV4, SRC_FIELD_IPV4, @@ -146,14 +143,16 @@ static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = { offsetof(struct rte_tcp_hdr, dst_port), }, }; +/* >8 End of creation of ACL table. */ -/* flow classify data */ +/* Flow classify data. 8< */ static int num_classify_rules; static struct rte_flow_classify_rule *rules[MAX_NUM_CLASSIFY]; static struct rte_flow_classify_ipv4_5tuple_stats ntuple_stats; static struct rte_flow_classify_stats classify_stats = { .stats = (void **)&ntuple_stats }; +/* >8 End of flow classify data. */ /* parameters for rte_flow_classify_validate and * rte_flow_classify_table_entry_add functions @@ -188,10 +187,12 @@ static struct rte_flow_attr attr; * Initializes a given port using global settings and with the RX buffers * coming from the mbuf_pool passed as a parameter. */ + +/* Initializing port using global settings. 8< */ static inline int port_init(uint8_t port, struct rte_mempool *mbuf_pool) { - struct rte_eth_conf port_conf = port_conf_default; + struct rte_eth_conf port_conf; struct rte_ether_addr addr; const uint16_t rx_rings = 1, tx_rings = 1; int retval; @@ -202,6 +203,8 @@ port_init(uint8_t port, struct rte_mempool *mbuf_pool) if (!rte_eth_dev_is_valid_port(port)) return -1; + memset(&port_conf, 0, sizeof(struct rte_eth_conf)); + retval = rte_eth_dev_info_get(port, &dev_info); if (retval != 0) { printf("Error during getting device (port %u) info: %s\n", @@ -209,9 +212,9 @@ port_init(uint8_t port, struct rte_mempool *mbuf_pool) return retval; } - if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE) + if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE) port_conf.txmode.offloads |= - DEV_TX_OFFLOAD_MBUF_FAST_FREE; + RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE; /* Configure the Ethernet device. */ retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf); @@ -236,31 +239,37 @@ port_init(uint8_t port, struct rte_mempool *mbuf_pool) return retval; } - /* Start the Ethernet port. */ + /* Start the Ethernet port. 8< */ retval = rte_eth_dev_start(port); + /* >8 End of starting the Ethernet port. */ if (retval < 0) return retval; /* Display the port MAC address. */ - rte_eth_macaddr_get(port, &addr); + retval = rte_eth_macaddr_get(port, &addr); + if (retval != 0) + return retval; + printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n", - port, - addr.addr_bytes[0], addr.addr_bytes[1], - addr.addr_bytes[2], addr.addr_bytes[3], - addr.addr_bytes[4], addr.addr_bytes[5]); + port, RTE_ETHER_ADDR_BYTES(&addr)); /* Enable RX in promiscuous mode for the Ethernet device. */ - rte_eth_promiscuous_enable(port); + retval = rte_eth_promiscuous_enable(port); + if (retval != 0) + return retval; return 0; } +/* >8 End of initializing a given port. */ /* * The lcore main. This is the main thread that does the work, reading from * an input port classifying the packets and writing to an output port. */ -static __attribute__((noreturn)) void + +/* Classifying the packets. 8< */ +static __rte_noreturn void lcore_main(struct flow_classifier *cls_app) { uint16_t port; @@ -279,7 +288,7 @@ lcore_main(struct flow_classifier *cls_app) * for best performance. */ RTE_ETH_FOREACH_DEV(port) - if (rte_eth_dev_socket_id(port) > 0 && + if (rte_eth_dev_socket_id(port) >= 0 && rte_eth_dev_socket_id(port) != (int)rte_socket_id()) { printf("\n\n"); printf("WARNING: port %u is on remote NUMA node\n", @@ -290,7 +299,7 @@ lcore_main(struct flow_classifier *cls_app) printf("\nCore %u forwarding packets. ", rte_lcore_id()); printf("[Ctrl+C to quit]\n"); - /* Run until the application is quit or killed. */ + /* Run until the application is quit or killed. 8< */ for (;;) { /* * Receive packets on a port, classify them and forward them @@ -340,7 +349,9 @@ lcore_main(struct flow_classifier *cls_app) } } } + /* >8 End of main loop. */ } +/* >8 End of lcore main. */ /* * Parse IPv4 5 tuple rules file, ipv4_rules_file.txt. @@ -650,6 +661,7 @@ add_classify_rule(struct rte_eth_ntuple_filter *ntuple_filter, return 0; } +/* Reads file and calls the add_classify_rule function. 8< */ static int add_rules(const char *rule_path, struct flow_classifier *cls_app) { @@ -697,6 +709,7 @@ add_rules(const char *rule_path, struct flow_classifier *cls_app) fclose(fh); return 0; } +/* >8 End of add_rules. */ /* display usage */ static void @@ -766,43 +779,47 @@ main(int argc, char *argv[]) struct rte_flow_classifier_params cls_params; uint32_t size; - /* Initialize the Environment Abstraction Layer (EAL). */ + /* Initialize the Environment Abstraction Layer (EAL). 8< */ ret = rte_eal_init(argc, argv); if (ret < 0) rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); + /* >8 End of initialization of EAL. */ argc -= ret; argv += ret; - /* parse application arguments (after the EAL ones) */ + /* Parse application arguments (after the EAL ones). 8< */ ret = parse_args(argc, argv); if (ret < 0) rte_exit(EXIT_FAILURE, "Invalid flow_classify parameters\n"); + /* >8 End of parse application arguments. */ /* Check that there is an even number of ports to send/receive on. */ nb_ports = rte_eth_dev_count_avail(); if (nb_ports < 2 || (nb_ports & 1)) rte_exit(EXIT_FAILURE, "Error: number of ports must be even\n"); - /* Creates a new mempool in memory to hold the mbufs. */ + /* Creates a new mempool in memory to hold the mbufs. 8< */ mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS * nb_ports, MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); + /* >8 End of creation of new mempool in memory. */ if (mbuf_pool == NULL) rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); - /* Initialize all ports. */ + /* Initialize all ports. 8< */ RTE_ETH_FOREACH_DEV(portid) if (port_init(portid, mbuf_pool) != 0) rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8 "\n", portid); + /* >8 End of initialization of all ports. */ if (rte_lcore_count() > 1) printf("\nWARNING: Too many lcores enabled. Only 1 used.\n"); socket_id = rte_eth_dev_socket_id(0); - /* Memory allocation */ + /* Memory allocation. 8< */ size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct flow_classifier_acl)); cls_app = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE); if (cls_app == NULL) @@ -834,19 +851,26 @@ main(int argc, char *argv[]) rte_free(cls_app); rte_exit(EXIT_FAILURE, "Failed to create classifier table\n"); } + /* >8 End of initialization of table create params. */ /* read file of IPv4 5 tuple rules and initialize parameters * for rte_flow_classify_validate and rte_flow_classify_table_entry_add * API's. */ + + /* Read file of IPv4 tuple rules. 8< */ if (add_rules(parm_config.rule_ipv4_name, cls_app)) { rte_flow_classifier_free(cls_app->cls); rte_free(cls_app); rte_exit(EXIT_FAILURE, "Failed to add rules\n"); } + /* >8 End of reading file of IPv4 5 tuple rules. */ - /* Call lcore_main on the master core only. */ + /* Call lcore_main on the main core only. */ lcore_main(cls_app); + /* clean up the EAL */ + rte_eal_cleanup(); + return 0; }