path: root/example/debug/odp_debug.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2020-2022 Nokia
 */

/**
 * @example odp_debug.c
 *
 * This example application demonstrates the usage of various debug print functions of ODP API.
 *
 * @cond _ODP_HIDE_FROM_DOXYGEN_
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <getopt.h>

#include <odp_api.h>
#include <odp/helper/odph_api.h>

#define MAX_NAME_LEN 128

typedef struct test_global_t {
	int system;
	int shm;
	int pool;
	int queue;
	int pktio;
	int ipsec;
	int timer;
	int stash;
	char pktio_name[MAX_NAME_LEN];

} test_global_t;

static test_global_t test_global;

static void print_usage(void)
{
	printf("This example prints out debug information on various ODP objects.\n"
	       "Select debug functions to be called with options. All listed functions\n"
	       "are called when no options are given.\n"
	       "\n"
	       "OPTIONS:\n"
	       "  -S, --system            Call odp_sys_info_print() and odp_sys_config_print()\n"
	       "  -s, --shm               Create a SHM and call odp_shm_print()\n"
	       "  -p, --pool              Create various types of pools and call odp_pool_print()\n"
	       "  -q, --queue             Create various types of queues and call odp_queue_print()\n"
	       "  -i, --interface <name>  Start a packet IO interface, and call odp_pktio_print(),\n"
	       "                          odp_pktio_extra_stats_print(), etc. Uses loop interface by default.\n"
	       "  -I, --ipsec             Call odp_ipsec_print()\n"
	       "  -t, --timer             Call timer pool, timer and timeout print functions\n"
	       "  -a, --stash             Create stash and call odp_stash_print()\n"
	       "  -h, --help              Display help and exit.\n\n");
}

static int parse_options(int argc, char *argv[], test_global_t *global)
{
	int opt, long_index;
	char *str;
	uint32_t str_len = 0;

	const struct option longopts[] = {
		{"system",      no_argument,       NULL, 'S'},
		{"shm",         no_argument,       NULL, 's'},
		{"pool",        no_argument,       NULL, 'p'},
		{"queue",       no_argument,       NULL, 'q'},
		{"interface",   required_argument, NULL, 'i'},
		{"ipsec",       no_argument,       NULL, 'I'},
		{"timer",       no_argument,       NULL, 't'},
		{"stash",       no_argument,       NULL, 'a'},
		{"help",        no_argument,       NULL, 'h'},
		{NULL, 0, NULL, 0}
	};
	const char *shortopts =  "+Sspqi:Itah";
	int ret = 0;

	while (1) {
		opt = getopt_long(argc, argv, shortopts, longopts, &long_index);

		if (opt == -1)
			break;	/* No more options */

		switch (opt) {
		case 'S':
			global->system = 1;
			break;
		case 's':
			global->shm = 1;
			break;
		case 'p':
			global->pool = 1;
			break;
		case 'q':
			global->queue = 1;
			break;
		case 'i':
			global->pktio = 1;
			str = optarg;
			str_len = strlen(str);

			if (str_len && str_len < MAX_NAME_LEN)
				strcpy(global->pktio_name, str);
			break;
		case 'I':
			global->ipsec = 1;
			break;
		case 't':
			global->timer = 1;
			break;
		case 'a':
			global->stash = 1;
			break;
		case 'h':
		default:
			print_usage();
			return -1;
		}
	}

	if (global->pktio && (str_len == 0 || str_len >= MAX_NAME_LEN)) {
		ODPH_ERR("Bad interface name length: %u\n", str_len);
		ret = -1;
	}

	return ret;
}

static int shm_debug(void)
{
	const char *name = "debug_shm";
	odp_shm_t shm = ODP_SHM_INVALID;

	shm = odp_shm_reserve(name, 8 * 1024, 64, 0);
	if (shm == ODP_SHM_INVALID) {
		ODPH_ERR("SHM reserve failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_shm_print_all();

	printf("\n");
	odp_shm_print(shm);

	if (odp_shm_free(shm)) {
		ODPH_ERR("SHM free failed: %s\n", name);
		return -1;
	}

	return 0;
}

static int buffer_debug(odp_pool_t pool)
{
	odp_buffer_t buf = odp_buffer_alloc(pool);

	if (buf == ODP_BUFFER_INVALID) {
		ODPH_ERR("Buffer alloc failed\n");
		return -1;
	}

	printf("\n");
	odp_buffer_print(buf);

	odp_buffer_free(buf);

	return 0;
}

static int packet_debug(odp_pool_t pool, int len)
{
	odp_packet_t pkt = odp_packet_alloc(pool, len);

	if (pkt == ODP_PACKET_INVALID) {
		ODPH_ERR("Packet alloc failed\n");
		return -1;
	}

	printf("\n");
	odp_packet_print(pkt);

	printf("\n");
	odp_packet_print_data(pkt, 0, len);

	odp_packet_free(pkt);

	return 0;
}

static int pool_debug(void)
{
	odp_pool_t pool;
	odp_pool_param_t param;
	const char *name;
	int pkt_len = 100;

	name = "debug_buffer_pool";
	odp_pool_param_init(&param);
	param.type = ODP_POOL_BUFFER;
	param.buf.num  = 10;
	param.buf.size = 1000;

	pool = odp_pool_create(name, &param);

	if (pool == ODP_POOL_INVALID) {
		ODPH_ERR("Pool create failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_pool_print(pool);

	if (buffer_debug(pool))
		return -1;

	if (odp_pool_destroy(pool)) {
		ODPH_ERR("Pool destroy failed: %s\n", name);
		return -1;
	}

	name = "debug_packet_pool";
	odp_pool_param_init(&param);
	param.type = ODP_POOL_PACKET;
	param.pkt.num     = 10;
	param.pkt.len     = pkt_len;
	param.pkt.max_len = 1000;

	pool = odp_pool_create(name, &param);

	if (pool == ODP_POOL_INVALID) {
		ODPH_ERR("Pool create failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_pool_print(pool);

	if (packet_debug(pool, pkt_len))
		return -1;

	if (odp_pool_destroy(pool)) {
		ODPH_ERR("Pool destroy failed: %s\n", name);
		return -1;
	}

	name = "debug_tmo_pool";
	odp_pool_param_init(&param);
	param.type = ODP_POOL_TIMEOUT;
	param.tmo.num = 10;

	pool = odp_pool_create(name, &param);

	if (pool == ODP_POOL_INVALID) {
		ODPH_ERR("Pool create failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_pool_print(pool);

	if (odp_pool_destroy(pool)) {
		ODPH_ERR("Pool destroy failed: %s\n", name);
		return -1;
	}

	return 0;
}

static int queue_debug(void)
{
	odp_queue_param_t param;
	const char *name;
	int i;
	int num = 3;
	odp_queue_t queue[num];

	name = "plain_queue";
	odp_queue_param_init(&param);
	param.type = ODP_QUEUE_TYPE_PLAIN;

	queue[0] = odp_queue_create(name, &param);

	if (queue[0] == ODP_QUEUE_INVALID) {
		ODPH_ERR("Queue create failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_queue_print(queue[0]);

	name = "parallel_sched_queue";
	odp_queue_param_init(&param);
	param.type = ODP_QUEUE_TYPE_SCHED;

	queue[1] = odp_queue_create(name, &param);

	if (queue[1] == ODP_QUEUE_INVALID) {
		ODPH_ERR("Queue create failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_queue_print(queue[1]);

	name = "atomic_sched_queue";
	param.sched.sync = ODP_SCHED_SYNC_ATOMIC;
	param.sched.prio = odp_schedule_max_prio();

	queue[2] = odp_queue_create(name, &param);

	if (queue[2] == ODP_QUEUE_INVALID) {
		ODPH_ERR("Queue create failed: %s\n", name);
		return -1;
	}

	printf("\n");
	odp_queue_print(queue[2]);

	printf("\n");
	odp_queue_print_all();

	printf("\n");
	odp_schedule_print();

	for (i = 0; i < num; i++) {
		if (odp_queue_destroy(queue[i])) {
			ODPH_ERR("Queue destroy failed: %i\n", i);
			return -1;
		}
	}

	return 0;
}

static int pktio_debug(test_global_t *global)
{
	odp_pool_t pool;
	odp_pool_param_t pool_param;
	odp_pktio_t pktio;
	odp_pktio_link_info_t info;
	uint8_t mac[ODPH_ETHADDR_LEN];
	int pkt_len = 100;

	odp_pool_param_init(&pool_param);
	pool_param.type = ODP_POOL_PACKET;
	pool_param.pkt.num = 10;
	pool_param.pkt.len = pkt_len;

	pool = odp_pool_create("debug_pktio_pool", &pool_param);

	if (pool == ODP_POOL_INVALID) {
		ODPH_ERR("Pool create failed\n");
		return -1;
	}

	pktio = odp_pktio_open(global->pktio_name, pool, NULL);

	if (pktio == ODP_PKTIO_INVALID) {
		ODPH_ERR("Pktio open failed\n");
		return -1;
	}

	/* Start interface with default config */
	if (odp_pktin_queue_config(pktio, NULL)) {
		ODPH_ERR("Packet input queue config failed\n");
		return -1;
	}

	if (odp_pktout_queue_config(pktio, NULL)) {
		ODPH_ERR("Packet output queue config failed\n");
		return -1;
	}

	if (odp_pktio_start(pktio)) {
		ODPH_ERR("Pktio start failed\n");
		return -1;
	}

	printf("\nWaiting link up");

	/* Wait max 5 seconds for link up */
	for (int i = 0; i < 25; i++) {
		if (odp_pktio_link_status(pktio) == ODP_PKTIO_LINK_STATUS_UP)
			break;

		odp_time_wait_ns(200 * ODP_TIME_MSEC_IN_NS);
		printf(".");
		fflush(NULL);
	}

	printf("\n\n");

	printf("Packet IO\n---------\n");
	printf("  index:         %i\n", odp_pktio_index(pktio));
	printf("  handle:        0x%" PRIx64 "\n", odp_pktio_to_u64(pktio));

	if (odp_pktio_mac_addr(pktio, mac, ODPH_ETHADDR_LEN) == ODPH_ETHADDR_LEN) {
		printf("  mac address:   %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2],
		       mac[3], mac[4], mac[5]);
	}

	printf("  input maxlen:  %u\n", odp_pktin_maxlen(pktio));
	printf("  output maxlen: %u\n", odp_pktout_maxlen(pktio));
	printf("  promisc mode:  %i\n", odp_pktio_promisc_mode(pktio));
	printf("  timestamp res: %" PRIu64 " Hz\n\n", odp_pktio_ts_res(pktio));

	if (odp_pktio_link_info(pktio, &info) == 0) {
		printf("Link info\n---------\n");
		printf("  auto neg:  %i\n", info.autoneg);
		printf("  duplex:    %i\n", info.duplex);
		printf("  media:     %s\n", info.media);
		printf("  pause_rx:  %i\n", info.pause_rx);
		printf("  pause_tx:  %i\n", info.pause_tx);
		printf("  speed:     %u Mbit/s\n", info.speed);
		printf("  status:    %i\n", info.status);
	}

	printf("\n");
	odp_pktio_print(pktio);

	printf("\n");
	odp_pktio_extra_stats_print(pktio);

	if (odp_pktio_stop(pktio)) {
		ODPH_ERR("Pktio stop failed\n");
		return -1;
	}

	if (odp_pktio_close(pktio)) {
		ODPH_ERR("Pktio close failed\n");
		return -1;
	}

	if (odp_pool_destroy(pool)) {
		ODPH_ERR("Pool destroy failed\n");
		return -1;
	}

	return 0;
}

static int ipsec_debug(void)
{
	printf("\n");
	odp_ipsec_print();

	return 0;
}

static int timer_debug(void)
{
	odp_pool_t pool;
	odp_pool_param_t pool_param;
	odp_timeout_t timeout;
	odp_timer_res_capability_t timer_res_capa;
	odp_timer_capability_t timer_capa;
	odp_timer_pool_t timer_pool;
	odp_timer_pool_param_t timer_param;
	odp_timer_start_t start_param;
	odp_timer_t timer;
	odp_queue_t queue;
	odp_queue_param_t queue_param;
	odp_event_t event;
	uint64_t tick;
	uint64_t max_tmo = ODP_TIME_SEC_IN_NS;
	uint64_t res     = 100 * ODP_TIME_MSEC_IN_NS;
	int started = 0;

	odp_pool_param_init(&pool_param);
	pool_param.type = ODP_POOL_TIMEOUT;
	pool_param.tmo.num = 10;

	pool = odp_pool_create("debug_timer", &pool_param);

	if (pool == ODP_POOL_INVALID) {
		ODPH_ERR("Pool create failed\n");
		return -1;
	}

	timeout = odp_timeout_alloc(pool);
	if (timeout == ODP_TIMEOUT_INVALID) {
		ODPH_ERR("Timeout alloc failed\n");
		return -1;
	}

	if (odp_timer_capability(ODP_CLOCK_DEFAULT, &timer_capa)) {
		ODPH_ERR("Timer capa failed\n");
		return -1;
	}

	if (timer_capa.max_tmo.max_tmo < max_tmo)
		max_tmo = timer_capa.max_tmo.max_tmo;

	memset(&timer_res_capa, 0, sizeof(odp_timer_res_capability_t));
	timer_res_capa.max_tmo = max_tmo;
	if (odp_timer_res_capability(ODP_CLOCK_DEFAULT, &timer_res_capa)) {
		ODPH_ERR("Timer resolution capability failed\n");
		return -1;
	}

	if (timer_res_capa.res_ns > res)
		res = timer_res_capa.res_ns;

	odp_timer_pool_param_init(&timer_param);
	timer_param.res_ns  = res;
	timer_param.min_tmo = max_tmo / 10;
	timer_param.max_tmo = max_tmo;
	timer_param.num_timers = 10;
	timer_param.clk_src = ODP_CLOCK_DEFAULT;

	timer_pool = odp_timer_pool_create("debug_timer", &timer_param);

	if (timer_pool == ODP_TIMER_POOL_INVALID) {
		ODPH_ERR("Timer pool create failed\n");
		return -1;
	}

	if (odp_timer_pool_start_multi(&timer_pool, 1) != 1) {
		ODPH_ERR("Timer pool start failed\n");
		return -1;
	}

	odp_queue_param_init(&queue_param);
	if (timer_capa.queue_type_sched)
		queue_param.type = ODP_QUEUE_TYPE_SCHED;

	queue = odp_queue_create("debug_timer", &queue_param);
	if (queue == ODP_QUEUE_INVALID) {
		ODPH_ERR("Queue create failed.\n");
		return -1;
	}

	printf("\n");
	odp_timer_pool_print(timer_pool);

	tick = odp_timer_ns_to_tick(timer_pool, max_tmo / 2);

	timer = odp_timer_alloc(timer_pool, queue, (void *)(uintptr_t)0xdeadbeef);

	printf("\n");
	odp_timeout_print(timeout);

	event = odp_timeout_to_event(timeout);

	start_param.tick_type = ODP_TIMER_TICK_REL;
	start_param.tick = tick;
	start_param.tmo_ev = event;

	if (odp_timer_start(timer, &start_param) == ODP_TIMER_SUCCESS)
		started = 1;
	else
		ODPH_ERR("Timer start failed.\n");

	printf("\n");
	odp_timer_print(timer);

	if (started && odp_timer_cancel(timer, &event) != ODP_TIMER_SUCCESS) {
		ODPH_ERR("Timer cancel failed\n");
		return -1;
	} else {
		timeout = odp_timeout_from_event(event);

		printf("\n");
		odp_timeout_print(timeout);

		odp_timeout_free(timeout);
	}

	if (odp_timer_free(timer)) {
		ODPH_ERR("Timer free failed\n");
		return -1;
	}

	odp_timer_pool_destroy(timer_pool);

	if (odp_queue_destroy(queue)) {
		ODPH_ERR("Queue destroy failed\n");
		return -1;
	}

	if (odp_pool_destroy(pool)) {
		ODPH_ERR("Pool destroy failed\n");
		return -1;
	}

	return 0;
}

static int stash_debug(void)
{
	odp_stash_param_t param;
	odp_stash_t stash;
	uint32_t val = 0xdeadbeef;

	odp_stash_param_init(&param);
	param.num_obj  = 10;
	param.obj_size = 4;

	stash = odp_stash_create("debug_stash", &param);

	if (stash == ODP_STASH_INVALID) {
		ODPH_ERR("Stash create failed\n");
		return -1;
	}

	if (odp_stash_put_u32(stash, &val, 1) != 1) {
		ODPH_ERR("Stash put failed\n");
		return -1;
	}

	printf("\n");
	odp_stash_print(stash);

	if (odp_stash_get_u32(stash, &val, 1) != 1) {
		ODPH_ERR("Stash get failed\n");
		return -1;
	}

	if (odp_stash_destroy(stash)) {
		ODPH_ERR("Stash destroy failed\n");
		return -1;
	}

	return 0;
}

int main(int argc, char *argv[])
{
	odp_instance_t inst;
	test_global_t *global = &test_global;

	printf("ODP debug example\n\n");
	memset(global, 0, sizeof(test_global_t));

	if (argc < 2) {
		/* If not arguments, run all test cases */
		global->system  = 1;
		global->shm     = 1;
		global->pool    = 1;
		global->queue   = 1;
		global->pktio   = 1;
		global->ipsec   = 1;
		global->timer   = 1;
		global->stash   = 1;
		strcpy(global->pktio_name, "loop");
	} else {
		if (parse_options(argc, argv, global))
			exit(EXIT_FAILURE);
	}

	if (odp_init_global(&inst, NULL, 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);
	}

	/* Configure scheduler before creating any scheduled queues */
	if (odp_schedule_config(NULL)) {
		ODPH_ERR("Schedule config failed\n");
		exit(EXIT_FAILURE);
	}

	if (global->system) {
		printf("\n");
		odp_sys_info_print();

		printf("\n");
		odp_sys_config_print();
	}

	if (global->shm && shm_debug()) {
		ODPH_ERR("SHM debug failed.\n");
		exit(EXIT_FAILURE);
	}

	if (global->pool && pool_debug()) {
		ODPH_ERR("Pool debug failed.\n");
		exit(EXIT_FAILURE);
	}

	if (global->queue && queue_debug()) {
		ODPH_ERR("Queue debug failed.\n");
		exit(EXIT_FAILURE);
	}

	if (global->pktio && pktio_debug(global)) {
		ODPH_ERR("Packet debug failed.\n");
		exit(EXIT_FAILURE);
	}

	if (global->ipsec && ipsec_debug()) {
		ODPH_ERR("IPSEC debug failed.\n");
		exit(EXIT_FAILURE);
	}

	if (global->timer && timer_debug()) {
		ODPH_ERR("Timer debug failed.\n");
		exit(EXIT_FAILURE);
	}

	if (global->stash && stash_debug()) {
		ODPH_ERR("Stash debug failed.\n");
		exit(EXIT_FAILURE);
	}

	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;
}