odp_cli.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2021-2024 Nokia
 */
 
#include <odp_api.h>
#include <odp/helper/odph_api.h>
 
#include <stdio.h>
#include <stdint.h>
#include <signal.h>
 
typedef struct {
    int time;
    char *addr;
    uint16_t port;
} options_t;
 
static void usage(const char *prog)
{
    printf("\n"
           "Usage: %s [options]\n"
           "\n"
           "OPTIONS:\n"
           "  -t, --time <sec>        Keep CLI open for <sec> seconds. (default -1 (infinite))\n"
           "  -a, --address <addr>    Bind listening socket to IP address <addr>.\n"
           "  -p, --port <port>       Bind listening socket to port <port>.\n"
           "\n"
           "ODP helper defaults are used for address and port, if the options are\n"
           "not given.\n"
           "\n",
           prog);
}
 
static void parse_args(int argc, char *argv[], options_t *opt)
{
    static const struct option longopts[] = {
        { "time", required_argument, NULL, 't' },
        { "address", required_argument, NULL, 'a' },
        { "port", required_argument, NULL, 'p' },
        { "help", no_argument, NULL, 'h' },
        { NULL, 0, NULL, 0 }
    };
 
    static const char *shortopts = "+t:a:p:h";
 
    while (1) {
        int c = getopt_long(argc, argv, shortopts, longopts, NULL);
 
        if (c == -1)
            break; /* No more options */
 
        switch (c) {
        case 't':
            opt->time = atoi(optarg);
            break;
        case 'a':
            opt->addr = optarg;
            break;
        case 'p':
            opt->port = atoi(optarg);
            break;
        default:
            usage(argv[0]);
            exit(EXIT_SUCCESS);
            break;
        }
    }
 
    optind = 1; /* reset 'extern optind' from the getopt lib */
}
 
static volatile int shutdown_sig;
 
static void sig_handler(int signo)
{
    (void)signo;
 
    shutdown_sig = 1;
}
 
static void my_cmd(int argc, char *argv[])
{
    odph_cli_log("%s(%d): %s\n", __FILE__, __LINE__, __func__);
 
    for (int i = 0; i < argc; i++)
        odph_cli_log("argv[%d]: %s\n", i, argv[i]);
}
 
static int cli_server(void *arg ODP_UNUSED)
{
    /* Run CLI server. */
    if (odph_cli_run()) {
        ODPH_ERR("odph_cli_run() failed.\n");
        return -1;
    }
 
    return 0;
}
 
int main(int argc, char *argv[])
{
    signal(SIGINT, sig_handler);
 
    odph_helper_options_t helper_options;
 
    /* Let helper collect its own arguments (e.g. --odph_proc) */
    argc = odph_parse_options(argc, argv);
    if (odph_options(&helper_options)) {
        ODPH_ERR("Error: reading ODP helper options failed.\n");
        exit(EXIT_FAILURE);
    }
 
    odp_init_t init;
 
    odp_init_param_init(&init);
    init.mem_model = helper_options.mem_model;
 
    options_t opt = {
        .time = -1,
        .addr = NULL,
        .port = 0,
    };
 
    parse_args(argc, argv, &opt);
 
    /* Initialize ODP. */
 
    odp_instance_t inst;
 
    if (odp_init_global(&inst, &init, NULL)) {
        ODPH_ERR("Global init failed.\n");
        exit(EXIT_FAILURE);
    }
 
    if (odp_init_local(inst, ODP_THREAD_CONTROL)) {
        ODPH_ERR("Local init failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Prepare CLI parameters. */
 
    odph_cli_param_t cli_param;
 
    odph_cli_param_init(&cli_param);
 
    if (opt.addr)
        cli_param.address = opt.addr;
 
    if (opt.port)
        cli_param.port = opt.port;
 
    /* Initialize CLI helper. */
    if (odph_cli_init(&cli_param)) {
        ODPH_ERR("CLI helper initialization failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Register user command. */
    if (odph_cli_register_command("my_command", my_cmd,
                      "Example user command.")) {
        ODPH_ERR("Registering user command failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Create server thread. */
 
    odp_cpumask_t cpumask;
    odph_thread_common_param_t thr_common;
    odph_thread_param_t thr_param;
    odph_thread_t thr_server;
    odph_thread_join_result_t res;
 
    if (odp_cpumask_default_control(&cpumask, 1) != 1) {
        ODPH_ERR("Failed to get default CPU mask.\n");
        exit(EXIT_FAILURE);
    }
 
    odph_thread_common_param_init(&thr_common);
    thr_common.instance = inst;
    thr_common.cpumask = &cpumask;
 
    odph_thread_param_init(&thr_param);
    thr_param.thr_type = ODP_THREAD_CONTROL;
    thr_param.start = cli_server;
 
    memset(&thr_server, 0, sizeof(thr_server));
 
    if (odph_thread_create(&thr_server, &thr_common, &thr_param, 1) != 1) {
        ODPH_ERR("Failed to create server thread.\n");
        exit(EXIT_FAILURE);
    }
 
    printf("CLI server started on %s:%d.\n", cli_param.address,
           cli_param.port);
 
    /* Wait for the given number of seconds. */
    for (int i = 0; (opt.time < 0 || i < opt.time) && !shutdown_sig; i++)
        odp_time_wait_ns(ODP_TIME_SEC_IN_NS);
 
    printf("Stopping CLI server.\n");
 
    /* Stop CLI server. */
    if (odph_cli_stop()) {
        ODPH_ERR("CLI stop failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Wait for server thread to exit. */
    if (odph_thread_join_result(&thr_server, &res, 1) != 1) {
        ODPH_ERR("Failed to join server thread.\n");
        exit(EXIT_FAILURE);
    }
 
    if (res.is_sig || res.ret != 0) {
        ODPH_ERR("Worker thread failure%s: %d.\n", res.is_sig ? " (signaled)" : "",
             res.ret);
        exit(EXIT_FAILURE);
    }
 
    /* Terminate CLI helper. */
    if (odph_cli_term()) {
        ODPH_ERR("CLI helper termination failed.\n");
        exit(EXIT_FAILURE);
    }
 
    /* Terminate ODP. */
 
    if (odp_term_local()) {
        ODPH_ERR("Local term failed.\n");
        exit(EXIT_FAILURE);
    }
 
    if (odp_term_global(inst)) {
        ODPH_ERR("Global term failed.\n");
        exit(EXIT_FAILURE);
    }
 
    return 0;
}