static odp_pktio_t create_pktio(int iface_idx, odp_pktio_input_mode_t imode, odp_pktio_output_mode_t omode) { odp_pktio_t pktio; odp_pktio_param_t pktio_param; const char *iface = iface_name[iface_idx]; odp_pktio_param_init(&pktio_param); pktio_param.in_mode = imode; pktio_param.out_mode = omode; pktio = odp_pktio_open(iface, pool[iface_idx], &pktio_param); if (pktio == ODP_PKTIO_INVALID) pktio = odp_pktio_lookup(iface); CU_ASSERT(pktio != ODP_PKTIO_INVALID); CU_ASSERT(odp_pktio_to_u64(pktio) != odp_pktio_to_u64(ODP_PKTIO_INVALID)); /* Print pktio debug info and test that the odp_pktio_print() function * is implemented. */ if (pktio != ODP_PKTIO_INVALID) odp_pktio_print(pktio); if (wait_for_network) spin_wait(ODP_TIME_SEC_IN_NS / 4); return pktio; }
int build_classifier(int if_count, char **if_names) { odp_pktio_t pktio; odp_cos_t cos_def; odp_cos_t cos_udp; odp_pmr_t pmr_udp; char name[80]; int i; cos_udp = build_cos_w_queue("cos_udp"); if (cos_udp == ODP_COS_INVALID) { OFP_ERR("Failed to create UDP COS"); return -1; } pmr_udp = build_udp_prm(); if (pmr_udp == ODP_PMR_INVAL) { OFP_ERR("Failed to create UDP PRM"); return -1; } for (i = 0; i < if_count; i++) { pktio = odp_pktio_lookup(if_names[i]); if (pktio == ODP_PKTIO_INVALID) { OFP_ERR("Failed to get pktio for interface %s\n", if_names[i]); return -1; } sprintf(name, "cos_default_%s", if_names[i]); cos_def = build_cos_set_queue(name, ofp_pktio_spq_get(pktio)); if (cos_def == ODP_COS_INVALID) { OFP_ERR("Failed to create default COS " "for interface %s\n", if_names[i]); return -1; } if (odp_pktio_default_cos_set(pktio, cos_def) < 0) { OFP_ERR("Failed to set default COS on interface %s\n", if_names[i]); return -1; } if (odp_pktio_error_cos_set(pktio, cos_def) < 0) { OFP_ERR("Failed to set error COS on interface %s\n", if_names[i]); return -1; } if (odp_pktio_pmr_cos(pmr_udp, pktio, cos_udp) < 0) { OFP_ERR("Failed to set UDP PRM on interface %s\n", if_names[i]); return 1; } } return 0; }
void pktio_test_lookup(void) { odp_pktio_t pktio, pktio_inval; odp_pktio_param_t pktio_param; odp_pktio_param_init(&pktio_param); pktio_param.in_mode = ODP_PKTIN_MODE_SCHED; pktio = odp_pktio_open(iface_name[0], default_pkt_pool, &pktio_param); CU_ASSERT(pktio != ODP_PKTIO_INVALID); CU_ASSERT(odp_pktio_lookup(iface_name[0]) == pktio); pktio_inval = odp_pktio_open(iface_name[0], default_pkt_pool, &pktio_param); CU_ASSERT(odp_errno() != 0); CU_ASSERT(pktio_inval == ODP_PKTIO_INVALID); CU_ASSERT(odp_pktio_close(pktio) == 0); CU_ASSERT(odp_pktio_lookup(iface_name[0]) == ODP_PKTIO_INVALID); }
odp_pktio_t odp_pktio_open(const char *dev, odp_pool_t pool) { odp_pktio_t id; id = odp_pktio_lookup(dev); if (id != ODP_PKTIO_INVALID) { /* interface is already open */ __odp_errno = EEXIST; PRINT("odp_pktio_lookup fail.\n"); return ODP_PKTIO_INVALID; } odp_spinlock_lock(&pktio_tbl->lock); id = setup_pktio_entry(dev, pool); odp_spinlock_unlock(&pktio_tbl->lock); return id; }
/** * Main receive function * * @param arg thread arguments of type 'thread_args_t *' */ static void *gen_recv_thread(void *arg) { int thr; odp_pktio_t pktio; thread_args_t *thr_args; odp_packet_t pkt; odp_event_t ev; thr = odp_thread_id(); thr_args = arg; pktio = odp_pktio_lookup(thr_args->pktio_dev); if (pktio == ODP_PKTIO_INVALID) { EXAMPLE_ERR(" [%02i] Error: lookup of pktio %s failed\n", thr, thr_args->pktio_dev); return NULL; } printf(" [%02i] created mode: RECEIVE\n", thr); for (;;) { if (args->appl.number != -1 && odp_atomic_load_u64(&counters.icmp) >= (unsigned int)args->appl.number) { break; } /* Use schedule to get buf from any input queue */ ev = odp_schedule(NULL, ODP_SCHED_WAIT); pkt = odp_packet_from_event(ev); /* Drop packets with errors */ if (odp_unlikely(odp_packet_has_error(pkt))) { odp_packet_free(pkt); continue; } print_pkts(thr, &pkt, 1); odp_packet_free(pkt); } return arg; }
static int send_recv(odp_packet_t packet, int send_nb, int expt_nb) { static int test_id = 0; printf("send_recv %d\n", test_id++); odp_pktio_t pktio; odp_queue_t outq_def; odp_packet_t pkt_tbl[MAX_PKT_BURST]; pktio = odp_pktio_lookup(pktio_valid_name); if (pktio == ODP_PKTIO_INVALID) { printf("Error: lookup of pktio %s failed\n", pktio_valid_name); return 1; } outq_def = odp_pktio_outq_getdef(pktio); if (outq_def == ODP_QUEUE_INVALID) { printf("Error: def output-Q query\n"); return 1; } int i; for ( i = 0; i < send_nb; ++i ) { odp_queue_enq(outq_def, (odp_event_t)packet); } int ret = 0; int start = __k1_read_dsu_timestamp(); while ( ret >= 0 && ret < expt_nb && ( __k1_read_dsu_timestamp() - start ) < 10 * __bsp_frequency ) { int n_pkt = odp_pktio_recv(pktio, pkt_tbl, MAX_PKT_BURST); ret += n_pkt; if (n_pkt > 0) odp_packet_free_multi(pkt_tbl, n_pkt); } test_assert_ret(ret == expt_nb); odp_packet_free(packet); printf("send_recv %d OK\n", test_id); return 0; }
static void *gen_send_thread(void *arg) { int thr; odp_pktio_t pktio; thread_args_t *thr_args; odp_queue_t outq_def; odp_packet_t pkt[PKT_BURST_SZ]; thr = odp_thread_id(); thr_args = arg; pktio = odp_pktio_lookup(thr_args->pktio_dev); if (pktio == ODP_PKTIO_INVALID) { EXAMPLE_ERR(" [%02i] Error: lookup of pktio %s failed\n", thr, thr_args->pktio_dev); return NULL; } outq_def = odp_pktio_outq_getdef(pktio); if (outq_def == ODP_QUEUE_INVALID) { EXAMPLE_ERR(" [%02i] Error: def output-Q query\n", thr); return NULL; } printf(" [%02i] created mode: SEND\n", thr); for (int i = 0; i < PKT_BURST_SZ; ++i) { if (args->appl.mode == APPL_MODE_UDP) pkt[i] = pack_udp_pkt(thr_args->pool); else if (args->appl.mode == APPL_MODE_PING) pkt[i] = pack_icmp_pkt(thr_args->pool); else pkt[i] = ODP_PACKET_INVALID; if (!odp_packet_is_valid(pkt[i])) { EXAMPLE_ERR(" [%2i] alloc_single failed\n", thr); return NULL; } } for (;;) { int err; err = odp_queue_enq_multi(outq_def, (odp_event_t*)pkt, PKT_BURST_SZ); if (err != PKT_BURST_SZ) { /* EXAMPLE_ERR(" [%02i] send pkt err!\n", thr); */ /* return NULL; */ } static uint64_t toto = 0; if (args->appl.interval != 0) { printf(" [%02i] send pkt no:%"PRIu64" seq %"PRIu64"\n", thr, odp_atomic_load_u64(&counters.seq), toto++); usleep(args->appl.interval); /* millisleep(args->appl.interval, */ /* thr_args->tp, */ /* thr_args->tim, */ /* thr_args->tq, */ /* thr_args->tmo_ev); */ } } printf("Done\n"); _exit(0); /* receive number of reply pks until timeout */ if (args->appl.mode == APPL_MODE_PING && args->appl.number > 0) { while (args->appl.timeout >= 0) { if (odp_atomic_load_u64(&counters.icmp) >= (unsigned int)args->appl.number) break; millisleep(DEFAULT_PKT_INTERVAL, thr_args->tp, thr_args->tim, thr_args->tq, thr_args->tmo_ev); args->appl.timeout--; } } return arg; }
/** main() Application entry point * * @param argc int * @param argv[] char* * @return int * */ int main(int argc, char *argv[]) { odph_linux_pthread_t thread_tbl[MAX_WORKERS], dispatcher_thread; appl_args_t params; int core_count, num_workers; odp_cpumask_t cpu_mask; int first_cpu, i; struct pktio_thr_arg pktio_thr_args[MAX_WORKERS]; odp_pktio_param_t pktio_param; odp_pktin_queue_param_t pktin_param; odp_pktout_queue_param_t pktout_param; odp_pktio_t pktio; int port, queue_id; odph_linux_thr_params_t thr_params; odp_instance_t instance; struct pktin_table_s { int num_in_queue; odp_pktin_queue_t in_queue[OFP_PKTIN_QUEUE_MAX]; } pktin_table[OFP_FP_INTERFACE_MAX]; /* Parse and store the application arguments */ parse_args(argc, argv, ¶ms); if (params.if_count > OFP_FP_INTERFACE_MAX) { printf("Error: Invalid number of interfaces: maximum %d\n", OFP_FP_INTERFACE_MAX); exit(EXIT_FAILURE); } if (odp_init_global(&instance, NULL, NULL)) { OFP_ERR("Error: ODP global init failed.\n"); exit(EXIT_FAILURE); } if (odp_init_local(instance, ODP_THREAD_CONTROL)) { OFP_ERR("Error: ODP local init failed.\n"); exit(EXIT_FAILURE); } /* Print both system and application information */ print_info(NO_PATH(argv[0]), ¶ms); core_count = odp_cpu_count(); num_workers = core_count; if (params.core_count && params.core_count < core_count) num_workers = params.core_count; if (num_workers > MAX_WORKERS) num_workers = MAX_WORKERS; /* * By default core #0 runs Linux kernel background tasks. * Start mapping thread from core #1 */ if (num_workers > 1) { num_workers--; first_cpu = 1; } else { OFP_ERR("Burst mode requires multiple cores.\n"); exit(EXIT_FAILURE); } if (num_workers < params.if_count) { OFP_ERR("At least %u fastpath cores required.\n", params.if_count); exit(EXIT_FAILURE); } printf("Num worker threads: %i\n", num_workers); printf("first CPU: %i\n", first_cpu); memset(&app_init_params, 0, sizeof(app_init_params)); app_init_params.linux_core_id = 0; if (ofp_init_global(instance, &app_init_params)) { OFP_ERR("Error: OFP global init failed.\n"); exit(EXIT_FAILURE); } if (ofp_init_local()) { OFP_ERR("Error: OFP local init failed.\n"); exit(EXIT_FAILURE); } odp_pktio_param_init(&pktio_param); pktio_param.in_mode = ODP_PKTIN_MODE_DIRECT; pktio_param.out_mode = ODP_PKTOUT_MODE_DIRECT; odp_pktin_queue_param_init(&pktin_param); pktin_param.op_mode = ODP_PKTIO_OP_MT; pktin_param.hash_enable = 0; pktin_param.hash_proto.all_bits = 0; pktin_param.num_queues = 1; odp_pktout_queue_param_init(&pktout_param); pktout_param.num_queues = 1; pktout_param.op_mode = ODP_PKTIO_OP_MT; for (i = 0; i < params.if_count; i++) { if (ofp_ifnet_create(instance, params.if_names[i], &pktio_param, &pktin_param, &pktout_param) < 0) { OFP_ERR("Failed to init interface %s", params.if_names[i]); exit(EXIT_FAILURE); } pktio = odp_pktio_lookup(params.if_names[i]); if (pktio == ODP_PKTIO_INVALID) { OFP_ERR("Failed locate pktio %s", params.if_names[i]); exit(EXIT_FAILURE); } pktin_table[i].num_in_queue = odp_pktin_queue(pktio, pktin_table[i].in_queue, OFP_PKTIN_QUEUE_MAX); if (pktin_table[i].num_in_queue < 0) { OFP_ERR("Failed get input queues for %s", params.if_names[i]); exit(EXIT_FAILURE); } } memset(thread_tbl, 0, sizeof(thread_tbl)); memset(pktio_thr_args, 0, sizeof(pktio_thr_args)); for (i = 0; i < num_workers; ++i) { pktio_thr_args[i].pkt_func = ofp_eth_vlan_processing; port = i % params.if_count; queue_id = (i / params.if_count) % pktin_table[port].num_in_queue; pktio_thr_args[i].pktin = pktin_table[port].in_queue[queue_id]; odp_cpumask_zero(&cpu_mask); odp_cpumask_set(&cpu_mask, first_cpu + i); thr_params.start = pkt_io_recv; thr_params.arg = &pktio_thr_args[i]; thr_params.thr_type = ODP_THREAD_WORKER; thr_params.instance = instance; odph_linux_pthread_create(&thread_tbl[i], &cpu_mask, &thr_params); } odp_cpumask_zero(&cpu_mask); odp_cpumask_set(&cpu_mask, app_init_params.linux_core_id); thr_params.start = event_dispatcher; thr_params.arg = NULL; thr_params.thr_type = ODP_THREAD_WORKER; thr_params.instance = instance; odph_linux_pthread_create(&dispatcher_thread, &cpu_mask, &thr_params); /* Start CLI */ ofp_start_cli_thread(instance, app_init_params.linux_core_id, params.conf_file); odph_linux_pthread_join(thread_tbl, num_workers); printf("End Main()\n"); return 0; }