static inline bool s_initialize(test_thread_t tt, lagopus_mutex_t start_lock, lagopus_bbq_t bbq, ssize_t n, const char *name) { bool ret = false; if (tt != NULL) { lagopus_result_t r; if ((r = lagopus_thread_create((lagopus_thread_t *)&tt, s_test_thread_main, s_test_thread_finalize, s_test_thread_destroy, name, NULL)) != LAGOPUS_RESULT_OK) { lagopus_perror(r); goto done; } tt->m_start_lock = start_lock; tt->m_q = bbq; tt->m_n_puts = n; ret = true; } done: return ret; }
static inline bool s_check_create_common(lagopus_thread_t *thd_ptr, lagopus_result_t require_ret, lagopus_thread_main_proc_t mproc, const char *name) { bool result = false; lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES; ret = lagopus_thread_create(thd_ptr, mproc, finalize_proc, freeup_proc, name, NULL); if (ret == LAGOPUS_RESULT_OK) { ret = lagopus_thread_free_when_destroy(thd_ptr); if (ret == require_ret) { result = s_check_get_thread_id(thd_ptr, LAGOPUS_RESULT_NOT_STARTED); } else { lagopus_perror(ret); TEST_FAIL_MESSAGE("create failed"); result = false; } } else { if (ret == require_ret) { result = true; } else { lagopus_perror(ret); TEST_FAIL_MESSAGE("create failed"); result = false; } } return result; }
static inline bool s_initialize(test_thread_t tt, size_t n) { bool ret = false; if (tt != NULL) { tt->m_data = (int *)malloc(n * sizeof(int)); if (tt->m_data != NULL) { lagopus_result_t r; if ((r = lagopus_mutex_create(&(tt->m_lock))) != LAGOPUS_RESULT_OK) { lagopus_perror(r); goto initfailure; } if ((r = lagopus_thread_create((lagopus_thread_t *)&tt, s_test_thread_main, s_test_thread_finalize, s_test_thread_destroy, "test", NULL)) != LAGOPUS_RESULT_OK) { lagopus_perror(r); goto initfailure; } tt->m_n_data = n; tt->m_is_operational = false; tt->m_stop_requested = false; ret = true; } initfailure: if (ret != true) { free((void *)tt->m_data); } } return ret; }
void test_thread_create_params(void) { lagopus_thread_t m_thread = NULL; TEST_ASSERT_EQUAL_MESSAGE( LAGOPUS_RESULT_INVALID_ARGS, lagopus_thread_create(NULL, main_proc, finalize_proc, freeup_proc, "m_thread", NULL), "thread is null"); lagopus_thread_destroy(&m_thread); m_thread = NULL; TEST_ASSERT_EQUAL_MESSAGE( LAGOPUS_RESULT_INVALID_ARGS, lagopus_thread_create(&m_thread, NULL, finalize_proc, freeup_proc, "m_thread", NULL), "main_proc is null"); lagopus_thread_destroy(&m_thread); m_thread = NULL; TEST_ASSERT_EQUAL_MESSAGE( LAGOPUS_RESULT_OK, lagopus_thread_create(&m_thread, main_proc, NULL, freeup_proc, "m_thread", NULL), "finalize_proc is null"); lagopus_thread_destroy(&m_thread); m_thread = NULL; TEST_ASSERT_EQUAL_MESSAGE( LAGOPUS_RESULT_OK, lagopus_thread_create(&m_thread, main_proc, finalize_proc, NULL, "m_thread", NULL), "freeup_proc is null"); lagopus_thread_destroy(&m_thread); m_thread = NULL; TEST_ASSERT_EQUAL_MESSAGE( LAGOPUS_RESULT_OK, lagopus_thread_create(&m_thread, main_proc, finalize_proc, freeup_proc, NULL, NULL), "thread_name is null"); lagopus_thread_destroy(&m_thread); }
lagopus_result_t dataplane_initialize(int argc, const char *const argv[], __UNUSED void *extarg, lagopus_thread_t **thdptr) { #ifdef HAVE_DPDK static struct dataplane_arg dparg; #endif /* HAVE_DPDK */ static struct dataplane_arg sockarg; static struct dataplane_arg timerarg; lagopus_result_t nb_ports; nb_ports = lagopus_dataplane_init(argc, argv); if (nb_ports < 0) { lagopus_msg_fatal("lagopus_dataplane_init failed\n"); return nb_ports; } dp_api_init(); #ifdef HAVE_DPDK if (rawsocket_only_mode != true) { dparg.threadptr = &dpdk_thread; dparg.lock = &dpdk_lock; lagopus_thread_create(&dpdk_thread, dpdk_thread_loop, dp_finalproc, dp_freeproc, "dataplane", &dparg); if (lagopus_mutex_create(&dpdk_lock) != LAGOPUS_RESULT_OK) { lagopus_exit_fatal("lagopus_mutex_create"); } } #endif /* HAVE_DPDK */ lagopus_meter_init(); lagopus_register_action_hook = lagopus_set_action_function; lagopus_register_instruction_hook = lagopus_set_instruction_function; flowinfo_init(); timerarg.threadptr = &timer_thread; timerarg.lock = &timer_lock; timerarg.running = NULL; timerthread_initialize(&timerarg); sockarg.threadptr = &sock_thread; sockarg.lock = &sock_lock; sockarg.running = NULL; sockthread_initialize(&sockarg); *thdptr = &sock_thread; return LAGOPUS_RESULT_OK; }
static lagopus_result_t dummy_module_initialize(int argc, const char *const argv[], void *extarg, lagopus_thread_t **thdptr) { lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES; (void)extarg; lagopus_msg_debug(5, "called.\n"); if (thdptr != NULL) { *thdptr = NULL; } s_lock(); { if (s_is_initialized == false) { int i; lagopus_msg_debug(5, "argc: %d\n", argc); for (i = 0; i < argc; i++) { lagopus_msg_debug(5, "%5d: '%s'\n", i, argv[i]); } ret = lagopus_thread_create(&s_thd, s_dummy_thd_main, s_dummy_thd_finalize, s_dummy_thd_destroy, "dummy", NULL); if (ret == LAGOPUS_RESULT_OK) { s_is_initialized = true; if (thdptr != NULL) { *thdptr = &s_thd; } } } else { ret = LAGOPUS_RESULT_OK; } } s_unlock(); return ret; }
int main(int argc, char const *const argv[]) { lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES; int cpu = 0; lagopus_thread_t thd = NULL; if (argc > 1) { int tmp; if (lagopus_str_parse_int32(argv[1], &tmp) == LAGOPUS_RESULT_OK && tmp > 0) { cpu = tmp; } } if ((ret = lagopus_thread_create(&thd, s_main_proc, NULL, NULL, (const char *) "thread", (void *) NULL)) == LAGOPUS_RESULT_OK) { if ((ret = lagopus_thread_set_cpu_affinity(&thd, -1)) == LAGOPUS_RESULT_OK && (ret = lagopus_thread_set_cpu_affinity(&thd, cpu)) == LAGOPUS_RESULT_OK) { if ((ret = lagopus_thread_start(&thd, false)) == LAGOPUS_RESULT_OK) { ret = lagopus_thread_wait(&thd, -1LL); } } } if (ret != LAGOPUS_RESULT_OK) { lagopus_perror(ret); return 1; } else { return 0; } }
static void initialize_internal(void) { lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES; void *logger_client_arg = NULL; char *master_agentx_socket = NULL; char *ping_interval_string = NULL; uint16_t ping_interval = 0; state = SNMPMGR_NONE; /* `is_thread` is able to be changed only once here */ is_thread = is_thread_dummy; if (is_thread == false && thdptr_dummy != NULL) { *thdptr_dummy = NULL; } else if (thdptr_dummy != NULL) { *thdptr_dummy = &snmpmgr; } else { /* never reached! */ return; } if (lagopus_mutex_create(&snmp_lock) != LAGOPUS_RESULT_OK) { return; } if (lagopus_mutex_create(&snmp_state_lock) != LAGOPUS_RESULT_OK) { return; } snmp_set_do_debugging(false); /* setup Net-SNMP logger to use the lagopus logging function */ if (snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_LOGGING, snmp_log_callback_wrapper, logger_client_arg) != SNMPERR_SUCCESS) { return; } snmp_enable_calllog(); /* setup the SNMP module to be Agentx subagent */ netsnmp_enable_subagent(); #ifdef THE_CONFSYS_ERA master_agentx_socket = config_get("snmp master-agentx-socket WORD"); if (master_agentx_socket == NULL) { config_set_default("snmp master-agentx-socket WORD", (char *)DEFAULT_SNMPMGR_AGENTX_SOCKET); master_agentx_socket = config_get("snmp master-agentx-socket WORD"); } #else /* * FIXME: * Fetch it from the datastore. */ master_agentx_socket = (char *)DEFAULT_SNMPMGR_AGENTX_SOCKET; #endif /* THE_CONFSYS_ERA */ lagopus_msg_debug(25, "master agentx socket is %s\n", master_agentx_socket); if (netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_X_SOCKET, master_agentx_socket) != SNMPERR_SUCCESS) { initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR; return; } /* don't read/write configuration files */ if (netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DONT_PERSIST_STATE, true) != SNMPERR_SUCCESS) { initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR; return; } if (netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DISABLE_PERSISTENT_LOAD, true) != SNMPERR_SUCCESS) { initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR; return; } /* the interval [sec] to send ping to AgentX master agent */ #ifdef THE_CONFSYS_ERA ping_interval_string = config_get("snmp ping-interval-second 1-255"); if (ping_interval_string != NULL && (ret = check_ping_interval(ping_interval_string, &ping_interval)) != LAGOPUS_RESULT_OK) { config_set_default("snmp ping-interval-second 1-255", (char *) __STR__(DEFAULT_SNMPMGR_AGENTX_PING_INTERVAL_SEC)); ping_interval_string = config_get("snmp ping-interval-second 1-255"); ping_interval = DEFAULT_SNMPMGR_AGENTX_PING_INTERVAL_SEC; /* default value */ } #else /* * FIXME: * Fetch it from the datastore. */ ping_interval = DEFAULT_SNMPMGR_AGENTX_PING_INTERVAL_SEC; #endif /* THE_CONFSYS_ERA */ if (netsnmp_ds_set_int(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_AGENTX_PING_INTERVAL, (int)ping_interval) != SNMPERR_SUCCESS) { initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR; return; } if (init_agent(SNMP_TYPE) != SNMPERR_SUCCESS) { initialize_ret = LAGOPUS_RESULT_SNMP_API_ERROR; return; } if ((ret = lagopus_hashmap_create(&iftable_entry_hash, LAGOPUS_HASHMAP_TYPE_STRING, delete_entry)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); exit(1); } init_ifTable(); init_ifNumber(); init_dot1dBaseBridgeAddress(); init_dot1dBaseNumPorts(); init_dot1dBasePortTable(); init_dot1dBaseType(); if (is_thread == false) { initialize_ret = LAGOPUS_RESULT_OK; } else { keep_running = true; initialize_ret = lagopus_thread_create(&snmpmgr, snmpmgr_thread_loop, snmpmgr_thread_finally_called, NULL, "snmpmgr", NULL); } lagopus_msg_info("SNMP manager initialized.\n"); }
int main(int argc, char const *const argv[]) { lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES; int i; int n = 10000; lagopus_thread_t thread = NULL; pthread_t tid = LAGOPUS_INVALID_THREAD; lagopus_log_set_debug_level(10); if (argc > 1) { int tmp; if (lagopus_str_parse_int32(argv[1], &tmp) == LAGOPUS_RESULT_OK && tmp > 0) { n = tmp; } } /* create, start, wait, destroy */ for (i = 0; i < n; i++) { thread = NULL; if ((ret = lagopus_thread_create( (lagopus_thread_t *)&thread, (lagopus_thread_main_proc_t)s_main_proc, (lagopus_thread_finalize_proc_t)s_finalize_proc, (lagopus_thread_freeup_proc_t)s_freeup_proc, (const char *) "thread", (void *) NULL)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_exit_fatal("Can't create a thread.\n"); } else { fprintf(stderr, "create a thread [%d]\n", i); if ((ret = lagopus_thread_get_pthread_id(&thread, &tid)) != LAGOPUS_RESULT_NOT_STARTED) { lagopus_perror(ret); goto done; } } if ((ret = lagopus_thread_start(&thread, false)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_exit_fatal("Can't start the thread.\n"); } else { ret = lagopus_thread_get_pthread_id(&thread, &tid); if (ret == LAGOPUS_RESULT_OK || ret == LAGOPUS_RESULT_ALREADY_HALTED) { fprintf(stderr, " start thread: %lu\n", tid); } else { lagopus_perror(ret); goto done; } } s_check_cancelled(&thread, false); if ((ret = lagopus_thread_wait(&thread, 1000LL * 1000LL * 1000LL)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_msg_error("Can't wait the thread.\n"); } else { if ((ret = lagopus_thread_get_pthread_id(&thread, &tid)) == LAGOPUS_RESULT_OK) { lagopus_msg_error( "Thread has been completed, but I can get thread ID, %lu\n", tid); } else if (ret != LAGOPUS_RESULT_ALREADY_HALTED) { lagopus_perror(ret); goto done; } } s_check_cancelled(&thread, false); lagopus_thread_destroy(&thread); fprintf(stderr, "destroy the thread [%d]\n", i); fprintf(stderr, "\n"); } /* create, start, cancel, destroy */ for (i = 0; i < n; i++) { thread = NULL; if ((ret = lagopus_thread_create( (lagopus_thread_t *)&thread, (lagopus_thread_main_proc_t)s_main_proc_with_sleep, (lagopus_thread_finalize_proc_t)s_finalize_proc, (lagopus_thread_freeup_proc_t)s_freeup_proc, (const char *) "thread", (void *) NULL)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_exit_fatal("Can't create a thread.\n"); } else { fprintf(stderr, "create a thread [%d]\n", i); if ((ret = lagopus_thread_get_pthread_id(&thread, &tid)) != LAGOPUS_RESULT_NOT_STARTED) { lagopus_perror(ret); goto done; } } if ((ret = lagopus_thread_start(&thread, false)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_exit_fatal("Can't start the thread.\n"); } else { ret = lagopus_thread_get_pthread_id(&thread, &tid); if (ret == LAGOPUS_RESULT_OK || ret == LAGOPUS_RESULT_ALREADY_HALTED) { fprintf(stderr, " start thread: %lu\n", tid); } else { lagopus_perror(ret); goto done; } } s_check_cancelled(&thread, false); if ((ret = lagopus_thread_cancel(&thread)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_msg_error("Can't cancel the thread.\n"); } else { if ((ret = lagopus_thread_get_pthread_id(&thread, &tid)) == LAGOPUS_RESULT_OK) { lagopus_msg_error( "Thread has been canceled, but I can get thread ID, %lu\n", tid); } else if (ret != LAGOPUS_RESULT_NOT_STARTED && ret != LAGOPUS_RESULT_ALREADY_HALTED) { lagopus_perror(ret); goto done; } } s_check_cancelled(&thread, true); lagopus_thread_destroy(&thread); fprintf(stderr, "destroy the thread [%d]\n", i); fprintf(stderr, "\n"); } /* create, start, destroy */ for (i = 0; i < n; i++) { thread = NULL; if ((ret = lagopus_thread_create( (lagopus_thread_t *)&thread, (lagopus_thread_main_proc_t)s_main_proc_with_sleep, (lagopus_thread_finalize_proc_t)s_finalize_proc, (lagopus_thread_freeup_proc_t)s_freeup_proc, (const char *) "thread", (void *) NULL)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_exit_fatal("Can't create a thread.\n"); } else { fprintf(stderr, "create a thread [%d]\n", i); if ((ret = lagopus_thread_get_pthread_id(&thread, &tid)) != LAGOPUS_RESULT_NOT_STARTED) { lagopus_perror(ret); goto done; } } if ((ret = lagopus_thread_start(&thread, false)) != LAGOPUS_RESULT_OK) { lagopus_perror(ret); lagopus_exit_fatal("Can't start the thread.\n"); } else { ret = lagopus_thread_get_pthread_id(&thread, &tid); if (ret == LAGOPUS_RESULT_OK || ret == LAGOPUS_RESULT_ALREADY_HALTED) { fprintf(stderr, " start thread: %lu\n", tid); } else { lagopus_perror(ret); goto done; } } lagopus_thread_destroy(&thread); fprintf(stderr, "destroy the thread [%d]\n", i); fprintf(stderr, "\n"); } done: return (ret == LAGOPUS_RESULT_OK) ? 0 : 1; }
static lagopus_result_t sockthread_initialize(void *arg) { lagopus_thread_create(&sock_thread, rawsock_thread_loop, dp_finalproc, dp_freeproc, "dataplane rawswock", arg); return LAGOPUS_RESULT_OK; }
static lagopus_result_t timerthread_initialize(void *arg) { lagopus_thread_create(&timer_thread, dp_timer_loop, dp_finalproc, dp_freeproc, "dataplane timer", arg); return LAGOPUS_RESULT_OK; }