From patchwork Mon Jun 1 10:41:44 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Maxim Uvarov X-Patchwork-Id: 49292 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-lb0-f199.google.com (mail-lb0-f199.google.com [209.85.217.199]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id D195521580 for ; Mon, 1 Jun 2015 10:43:56 +0000 (UTC) Received: by lbcak1 with SMTP id ak1sf33465282lbc.2 for ; Mon, 01 Jun 2015 03:43:54 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:delivered-to:from:to:date :message-id:in-reply-to:references:subject:precedence:list-id :list-unsubscribe:list-archive:list-post:list-help:list-subscribe :mime-version:content-type:content-transfer-encoding:errors-to :sender:x-original-sender:x-original-authentication-results :mailing-list; bh=O0wc8TuockAfUSz/yycPRJZZ56gFWpylHM5CBRmFm4Q=; b=j3BMFGsLXJFxlgZWzLY6BQM5NcCSXq/WHf3npZHmvwy2ft7n5rL78quTzu2Y8zqO7U 5lYSsuvdN0+5RlI7EyOgckH8p8cvIcCc0M5Ysg1KcT9iyVhr70QwO5gTEf0VW3skw+84 sE2RKvHzi1sK5HUh+6adiuEZLjBHmEvkSwVXhl51vCpfqF5vr0EXiEhY+CyRAWTh8VhG qbgGx+gRGfaB2xNXyvtthvqsE6BTZznbkcQMkhMvI5pLnp/1n4z6KBbkGOvqf0Ncbgv3 aKk1ggHnH2k9hKdWAEKDrYiz1OSZmuOGTwKYjNDN9W1NF+kpm7n3KdtbO8jfxs1N2qo8 VBNQ== X-Gm-Message-State: ALoCoQnF1NfELGzL7G6ODKVnoJlUVUSiHbjQwUlh16tV1X/tR1XzUlXDopYJARTsc3Tbtr5LfT+u X-Received: by 10.112.42.236 with SMTP id r12mr20422050lbl.2.1433155433923; Mon, 01 Jun 2015 03:43:53 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.88.105 with SMTP id bf9ls36363lab.103.gmail; Mon, 01 Jun 2015 03:43:53 -0700 (PDT) X-Received: by 10.112.83.135 with SMTP id q7mr20620652lby.13.1433155433688; Mon, 01 Jun 2015 03:43:53 -0700 (PDT) Received: from mail-lb0-f177.google.com (mail-lb0-f177.google.com. [209.85.217.177]) by mx.google.com with ESMTPS id h3si12003555lag.12.2015.06.01.03.43.53 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 01 Jun 2015 03:43:53 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.177 as permitted sender) client-ip=209.85.217.177; Received: by lbbuc2 with SMTP id uc2so81617944lbb.2 for ; Mon, 01 Jun 2015 03:43:53 -0700 (PDT) X-Received: by 10.152.4.72 with SMTP id i8mr20900446lai.32.1433155433415; Mon, 01 Jun 2015 03:43:53 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.108.230 with SMTP id hn6csp2217122lbb; Mon, 1 Jun 2015 03:43:52 -0700 (PDT) X-Received: by 10.55.20.17 with SMTP id e17mr36743400qkh.102.1433155431606; Mon, 01 Jun 2015 03:43:51 -0700 (PDT) Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id q22si12650607qkh.117.2015.06.01.03.43.49; Mon, 01 Jun 2015 03:43:51 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Received: by lists.linaro.org (Postfix, from userid 109) id A875861D15; Mon, 1 Jun 2015 10:43:49 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252.ec2.internal X-Spam-Level: X-Spam-Status: No, score=-2.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from ip-10-142-244-252.ec2.internal (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id 36DB461D1D; Mon, 1 Jun 2015 10:42:56 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 488A561D30; Mon, 1 Jun 2015 10:42:50 +0000 (UTC) Received: from mail-wg0-f53.google.com (mail-wg0-f53.google.com [74.125.82.53]) by lists.linaro.org (Postfix) with ESMTPS id CEB1D61CEB for ; Mon, 1 Jun 2015 10:42:01 +0000 (UTC) Received: by wgv5 with SMTP id 5so110465521wgv.1 for ; Mon, 01 Jun 2015 03:42:01 -0700 (PDT) X-Received: by 10.180.99.69 with SMTP id eo5mr19116790wib.92.1433155321095; Mon, 01 Jun 2015 03:42:01 -0700 (PDT) Received: from localhost.localdomain ([87.120.178.39]) by mx.google.com with ESMTPSA id fb3sm16014528wib.21.2015.06.01.03.41.59 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 01 Jun 2015 03:42:00 -0700 (PDT) From: Maxim Uvarov To: lng-odp@lists.linaro.org Date: Mon, 1 Jun 2015 13:41:44 +0300 Message-Id: <1433155304-24149-6-git-send-email-maxim.uvarov@linaro.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1433155304-24149-1-git-send-email-maxim.uvarov@linaro.org> References: <1433155304-24149-1-git-send-email-maxim.uvarov@linaro.org> X-Topics: patch Subject: [lng-odp] [PATCHv7 5/5] ipc: example app X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: , List-Help: , List-Subscribe: , MIME-Version: 1.0 Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: maxim.uvarov@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.177 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 Simple example app creates one packet i/o to external interface and one ipc pktio to other process. Then transfer packet from external interface to other process and back thought ipc queue. Signed-off-by: Maxim Uvarov --- configure.ac | 1 + example/Makefile.am | 2 +- example/ipc/.gitignore | 1 + example/ipc/Makefile.am | 7 + example/ipc/odp_ipc.c | 542 ++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 552 insertions(+), 1 deletion(-) create mode 100644 example/ipc/.gitignore create mode 100644 example/ipc/Makefile.am create mode 100644 example/ipc/odp_ipc.c diff --git a/configure.ac b/configure.ac index d20bad2..1ceb922 100644 --- a/configure.ac +++ b/configure.ac @@ -274,6 +274,7 @@ AC_CONFIG_FILES([Makefile example/Makefile example/classifier/Makefile example/generator/Makefile + example/ipc/Makefile example/ipsec/Makefile example/packet/Makefile example/timer/Makefile diff --git a/example/Makefile.am b/example/Makefile.am index 353f397..506963f 100644 --- a/example/Makefile.am +++ b/example/Makefile.am @@ -1 +1 @@ -SUBDIRS = classifier generator ipsec packet timer +SUBDIRS = classifier generator ipc ipsec packet timer diff --git a/example/ipc/.gitignore b/example/ipc/.gitignore new file mode 100644 index 0000000..963d99d --- /dev/null +++ b/example/ipc/.gitignore @@ -0,0 +1 @@ +odp_ipc diff --git a/example/ipc/Makefile.am b/example/ipc/Makefile.am new file mode 100644 index 0000000..3da9549 --- /dev/null +++ b/example/ipc/Makefile.am @@ -0,0 +1,7 @@ +include $(top_srcdir)/example/Makefile.inc + +bin_PROGRAMS = odp_ipc +odp_ipc_LDFLAGS = $(AM_LDFLAGS) -static +odp_ipc_CFLAGS = $(AM_CFLAGS) -I${top_srcdir}/example + +dist_odp_ipc_SOURCES = odp_ipc.c diff --git a/example/ipc/odp_ipc.c b/example/ipc/odp_ipc.c new file mode 100644 index 0000000..37eaf61 --- /dev/null +++ b/example/ipc/odp_ipc.c @@ -0,0 +1,542 @@ +/* Copyright (c) 2015, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/** + * @file + * + * @example odp_ipc.c ODP IPC example application. + * This example application uses fork() at early start to create 2 + * completely separate processes. Then in main process it + * allocates packet with head and tail magic numbers and packet + * sequence counter inside. Then it sends that packet to second + * process which verifies head magic and modifies that head magic + * to new number. Then packet sent back to main process. Then main + * process validates modified head magic number, tail magic number + * and sequence counter. Master process also prints packet per + * second statistic and packet counters. + */ + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include + +/** @def SHM_PKT_POOL_SIZE + * @brief Size of the shared memory block + */ +#define SHM_PKT_POOL_SIZE (512 * 2048) + +/** @def SHM_PKT_POOL_BUF_SIZE + * @brief Buffer size of the packet pool buffer + */ +#define SHM_PKT_POOL_BUF_SIZE 1856 + +/** @def MAX_PKT_BURST + * @brief Maximum number of packet bursts + */ +#define MAX_PKT_BURST 16 + +/** Get rid of path in filename - only for unix-type paths using '/' */ +#define NO_PATH(file_name) (strrchr((file_name), '/') ? \ + strrchr((file_name), '/') + 1 : (file_name)) + +#define TEST_SEQ_MAGIC 0x92749451 +#define TEST_SEQ_MAGIC_2 0x81638340 + +/** Application argument */ +static char *pktio_name; + +/** magic number and sequence at start of packet payload */ +typedef struct ODP_PACKED { + uint32be_t magic; + uint32be_t seq; +} pkt_head_t; + +/** magic number at end of packet payload */ +typedef struct ODP_PACKED { + uint32be_t magic; +} pkt_tail_t; + +/* helper funcs */ +static void parse_args(int argc, char *argv[]); +static void print_info(char *progname); +static void usage(char *progname); + +static void busy_sleep(int sec) +{ + uint64_t start_cycle; + uint64_t cycle; + uint64_t diff; + uint64_t wait; + + wait = odp_time_ns_to_cycles(sec * ODP_TIME_SEC); + + start_cycle = odp_time_cycles(); + while (1) { + cycle = odp_time_cycles(); + diff = odp_time_diff_cycles(start_cycle, cycle); + if (wait < diff) + break; + } +} + +/** + * Create a pktio handle. + * + * @param dev Name of device to open + * @param pool Pool to associate with device for packet RX/TX + * + * @return The handle of the created pktio object. + * @retval ODP_PKTIO_INVALID if the create fails. + */ +static odp_pktio_t create_pktio(const char *dev, odp_pool_t pool) +{ + odp_pktio_t pktio; + odp_pktio_t ipc_pktio; + + /* Open a packet IO instance */ + pktio = odp_pktio_open(dev, pool); + if (pktio == ODP_PKTIO_INVALID) + EXAMPLE_ABORT("Error: pktio create failed for %s\n", dev); + + printf("pid: %d, create IPC pktio\n", getpid()); + ipc_pktio = odp_pktio_open("ipc_pktio", pool); + if (ipc_pktio == ODP_PKTIO_INVALID) + EXAMPLE_ABORT("Error: ipc pktio create failed.\n"); + + return pktio; +} + +/** + * Packet IO loopback worker thread using bursts from/to IO resources + * + * @param arg thread arguments of type 'thread_args_t *' + */ +static void *pktio_run_loop(odp_pool_t pool) +{ + int thr; + int pkts; + odp_pktio_t pktio; + odp_pktio_t ipc_pktio; + odp_packet_t pkt_tbl[MAX_PKT_BURST]; + uint64_t cnt = 0; /* increasing counter on each send packet */ + uint64_t cnt_recv = 0; /* increasing counter to validate + cnt on receive */ + uint64_t stat_pkts = 0; + uint64_t stat_pkts_prev = 0; + uint64_t stat_errors = 0; + uint64_t start_cycle; + uint64_t cycle; + uint64_t diff; + uint64_t onesec_cycles; + + thr = odp_thread_id(); + + pktio = odp_pktio_lookup(pktio_name); + if (pktio == ODP_PKTIO_INVALID) { + EXAMPLE_ERR(" [%02i] Error: lookup of pktio %s failed\n", + thr, pktio_name); + return NULL; + } + + printf(" [%02i] looked up pktio:%02" PRIu64 ", burst mode\n", + thr, odp_pktio_to_u64(pktio)); + + ipc_pktio = odp_pktio_lookup("ipc_pktio"); + if (pktio == ODP_PKTIO_INVALID) { + EXAMPLE_ERR(" [%02i] Error: lookup of pktio %s failed\n", + thr, "ipc_pktio"); + return NULL; + } + printf(" [%02i] looked up ipc_pktio:%02" PRIu64 ", burst mode\n", + thr, odp_pktio_to_u64(ipc_pktio)); + + onesec_cycles = odp_time_ns_to_cycles(ODP_TIME_SEC); + start_cycle = odp_time_cycles(); + + /* packets loop */ + for (;;) { + int i; + int sent; + int ret; + + /* 1. emulate that pkts packets were recieved */ + odp_random_data((uint8_t *)&pkts, sizeof(pkts), 0); + pkts = ((pkts & 0xffff) % MAX_PKT_BURST) + 1; + + for (i = 0; i < pkts; i++) { + odp_packet_t pkt; + + pkt = odp_packet_alloc(pool, SHM_PKT_POOL_BUF_SIZE); + if (pkt == ODP_PACKET_INVALID) { + pkts = i; + printf("unable to alloc packet\n"); + break; + } + odp_packet_l4_offset_set(pkt, 30); + + pkt_tbl[i] = pkt; + } + + /* 2. Copy counter and magic numbers to that packets */ + for (i = 0; i < pkts; i++) { + pkt_head_t head; + pkt_tail_t tail; + size_t off; + odp_packet_t pkt = pkt_tbl[i]; + + off = odp_packet_l4_offset(pkt); + if (off == ODP_PACKET_OFFSET_INVALID) + EXAMPLE_ABORT("packet L4 offset not set"); + + head.magic = TEST_SEQ_MAGIC; + head.seq = cnt++; + + off += ODPH_UDPHDR_LEN; + ret = odp_packet_copydata_in(pkt, off, sizeof(head), + &head); + if (ret) + EXAMPLE_ABORT("unable to copy in head data"); + + tail.magic = TEST_SEQ_MAGIC; + off = odp_packet_len(pkt) - sizeof(pkt_tail_t); + ret = odp_packet_copydata_in(pkt, off, sizeof(tail), + &tail); + if (ret) + EXAMPLE_ABORT("unable to copy in tail data"); + } + + /* 3. Send packets to ipc_pktio */ + sent = odp_pktio_send(ipc_pktio, pkt_tbl, pkts); + if (sent < 0) + fprintf(stderr, "error sending to ipc pktio\n"); + + /* 4. Receive packets back from ipc_pktio, validate magic + * number sequence counter and free that packet + */ + while (1) { + pkts = odp_pktio_recv(ipc_pktio, pkt_tbl, + MAX_PKT_BURST); + if (pkts <= 0) + break; + + for (i = 0; i < pkts; i++) { + odp_packet_t pkt = pkt_tbl[i]; + pkt_head_t head; + pkt_tail_t tail; + size_t off; + int err = 0; + + off = odp_packet_l4_offset(pkt); + if (off == ODP_PACKET_OFFSET_INVALID) + EXAMPLE_ABORT("invalid l4 offset\n"); + + off += ODPH_UDPHDR_LEN; + ret = odp_packet_copydata_out(pkt, off, + sizeof(head), + &head); + if (ret) + EXAMPLE_ABORT("unable copy out head data"); + + if (head.magic != TEST_SEQ_MAGIC_2) + err++; + + off = odp_packet_len(pkt) - sizeof(pkt_tail_t); + ret = odp_packet_copydata_out(pkt, off, + sizeof(tail), + &tail); + if (ret) + EXAMPLE_ABORT("unable copy out tail data"); + + if (tail.magic != TEST_SEQ_MAGIC) + err++; + + if (head.seq != cnt_recv++) + err++; + + if (odp_unlikely(err)) + stat_errors++; + else + stat_pkts++; + + odp_packet_free(pkt); + } + } + + /* 5. Print stats */ + cycle = odp_time_cycles(); + diff = odp_time_diff_cycles(start_cycle, cycle); + if (onesec_cycles < diff) { + start_cycle = cycle; + printf("pkts: %" PRIu64 ", errors %" PRIu64 ", pps %" PRIu64 ".\n", + stat_pkts, stat_errors, + (stat_pkts - stat_pkts_prev)); + stat_pkts_prev = stat_pkts; + } + + } + +/* unreachable */ + return NULL; +} + +static int ipc_second_process(void) +{ + odp_pktio_t pktio; + odp_packet_t pkt_tbl[MAX_PKT_BURST]; + int pkts; + int ret; + int i; + + /* linux shared memory can already have objects with names which + * second process can try to connect. That might be even interrupted + * current application. Might be later I will add magic numbers to + * each ipc object in linux-generic. HW platform should not have that + * problem. So just wait a little while master process will create + * all ipc objects before connecting to them. + */ + busy_sleep(3); + + /* Do lookup packet I/O in IPC shared memory, + * and link it to local pool. */ + while (1) { + pktio = odp_pktio_open("ipc_pktio", ODP_POOL_INVALID); + if (pktio == ODP_PKTIO_INVALID) { + busy_sleep(1); + printf("%s() pid %d: looking for ipc_pktio\n", + __func__, getpid()); + continue; + } + break; + } + + for (;;) { + pkts = odp_pktio_recv(pktio, pkt_tbl, MAX_PKT_BURST); + if (pkts <= 0) + continue; + + for (i = 0; i < pkts; i++) { + odp_packet_t pkt = pkt_tbl[i]; + pkt_head_t head; + size_t off; + + off = odp_packet_l4_offset(pkt); + if (off == ODP_PACKET_OFFSET_INVALID) + EXAMPLE_ABORT("invalid l4 offset\n"); + + off += ODPH_UDPHDR_LEN; + ret = odp_packet_copydata_out(pkt, off, sizeof(head), + &head); + if (ret) + EXAMPLE_ABORT("unable copy out head data"); + + if (head.magic != TEST_SEQ_MAGIC) + EXAMPLE_ABORT("Wrong head magic!"); + + /* Modify magic number in packet */ + head.magic = TEST_SEQ_MAGIC_2; + ret = odp_packet_copydata_in(pkt, off, sizeof(head), + &head); + if (ret) + EXAMPLE_ABORT("unable to copy in head data"); + } + + odp_pktio_send(pktio, pkt_tbl, pkts); + } + + EXAMPLE_ERR("Unexpected close."); + return 0; +} + +/** + * ODP packet example main function + */ +int main(int argc, char *argv[]) +{ + odp_pool_t pool; + odp_pool_param_t params; + int f; + + /* Parse and store the application arguments */ + parse_args(argc, argv); + + /* Use fork() before odp_init_global() to have 2 isolated + * processes which need communicate to each other with + * shared memory. + */ + f = fork(); + if (f) { + printf("Process one pid: %d\n", getpid()); + /* Init ODP before calling anything else */ + if (odp_init_global(NULL, NULL)) { + EXAMPLE_ERR("Error: ODP global init failed.\n"); + exit(EXIT_FAILURE); + } + + /* Init this thread */ + if (odp_init_local()) { + EXAMPLE_ERR("Error: ODP local init failed.\n"); + exit(EXIT_FAILURE); + } + + ipc_second_process(); + } else { + printf("Process two pid: %d\n", getpid()); + } + + /* Init ODP before calling anything else */ + if (odp_init_global(NULL, NULL)) { + EXAMPLE_ERR("Error: ODP global init failed.\n"); + exit(EXIT_FAILURE); + } + + /* Init this thread */ + if (odp_init_local()) { + EXAMPLE_ERR("Error: ODP local init failed.\n"); + exit(EXIT_FAILURE); + } + + /* Print both system and application information */ + print_info(NO_PATH(argv[0])); + + /* Create packet pool */ + memset(¶ms, 0, sizeof(params)); + params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE; + params.pkt.len = SHM_PKT_POOL_BUF_SIZE; + params.pkt.num = SHM_PKT_POOL_SIZE / SHM_PKT_POOL_BUF_SIZE; + params.type = ODP_POOL_PACKET; + + pool = odp_pool_create("packet_pool", ODP_SHM_NULL, ¶ms); + if (pool == ODP_POOL_INVALID) { + EXAMPLE_ERR("Error: packet pool create failed.\n"); + exit(EXIT_FAILURE); + } + + odp_pool_print(pool); + + create_pktio(pktio_name, pool); + + pktio_run_loop(pool); + + return 0; +} + +/** + * Parse and store the command line arguments + * + * @param argc argument count + * @param argv[] argument vector + * @param appl_args Store application arguments here + */ +static void parse_args(int argc, char *argv[]) +{ + int opt; + int long_index; + size_t len; + static struct option longopts[] = { + {"interface", required_argument, NULL, 'i'}, /* return 'i' */ + {"help", no_argument, NULL, 'h'}, /* return 'h' */ + {NULL, 0, NULL, 0} + }; + + while (1) { + opt = getopt_long(argc, argv, "i:h", + longopts, &long_index); + + if (opt == -1) + break; /* No more options */ + + switch (opt) { + case 'i': + len = strlen(optarg); + if (len == 0) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + len += 1; /* add room for '\0' */ + + pktio_name = malloc(len); + if (!pktio_name) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + strcpy(pktio_name, optarg); + + break; + case 'h': + usage(argv[0]); + exit(EXIT_SUCCESS); + break; + + default: + break; + } + } + + if (!pktio_name) { + usage(argv[0]); + exit(EXIT_FAILURE); + } + + optind = 1; /* reset 'extern optind' from the getopt lib */ +} + +/** + * Print system and application info + */ +static void print_info(char *progname) +{ + printf("\n" + "ODP system info\n" + "---------------\n" + "ODP API version: %s\n" + "CPU model: %s\n" + "CPU freq (hz): %"PRIu64"\n" + "Cache line size: %i\n" + "CPU count: %i\n" + "\n", + odp_version_api_str(), odp_sys_cpu_model_str(), odp_sys_cpu_hz(), + odp_sys_cache_line_size(), odp_cpu_count()); + + printf("Running ODP appl: \"%s\"\n" + "-----------------\n" + "Using IF: %s\n", + progname, pktio_name); + printf("\n\n"); + fflush(NULL); +} + +/** + * Prinf usage information + */ +static void usage(char *progname) +{ + printf("\n" + "Usage: %s OPTIONS\n" + " E.g. %s -i eth0\n" + "\n" + "OpenDataPlane example application.\n" + "\n" + "Mandatory OPTIONS:\n" + " -i, --interface Eth interface\n" + "\n" + "Optional OPTIONS\n" + " -h, --help Display help and exit.\n" + " environment variables: ODP_PKTIO_DISABLE_SOCKET_MMAP\n" + " ODP_PKTIO_DISABLE_SOCKET_MMSG\n" + " ODP_PKTIO_DISABLE_SOCKET_BASIC\n" + " can be used to advanced pkt I/O selection for linux-generic\n" + "\n", NO_PATH(progname), NO_PATH(progname) + ); +}