/** * * Close the serial port associated with @a serialfd. * * Before the closing of the file descriptor, a command is sent to the UART * so that it will stop the watchdog timer. This is not necessary when * powering off the machine, but *is* important when the system * administrator has, for some reason, stopped the daemon for some kind of * maintenance. * * FIXME: The memory used by the linked list of events is freed. This should * probably be better to keep split in another function. Also, the file * descriptor used for syslog is closed (optional, but nice). Perhaps the * function should just be renamed, instead of being split in many smaller * functions? */ static void close_serial(void) { if (serialfd != 0) { /* Stop the watchdog timer */ write_to_uart(0x4B); /* 'K' */ close(serialfd); } /* Destroy the macro timer objects */ destroy_timer(off_timer); destroy_timer(on_timer); closelog(); }
int plugin_fini(int type) { switch (type) { case PROC_MAIN: break; case PROC_CONN: break; case PROC_WORK: { switch (get_work_idx()) { case PROC_PROXY: break; case PROC_COLLECT: // 采集进程 fini_collect(); break; case PROC_COMMAND: fini_log_archive(); break; case PROC_MYSQL: fini_mysql_instance(); break; default: break; } destroy_timer(); } } return 0; }
void end_in_game_state( game* _pGame ) { destroy_top_bar( ((in_game_state*)_pGame->p_current_state)->p_top_bar ); unload_image( ((in_game_state*)_pGame->p_current_state)->p_esc_menu_img ); unload_button( ((in_game_state*)_pGame->p_current_state)->p_continue ); unload_button( ((in_game_state*)_pGame->p_current_state)->p_main_menu ); unload_button( ((in_game_state*)_pGame->p_current_state)->p_exit ); destroy_map( ((in_game_state*)_pGame->p_current_state)->p_map ); for ( int i = 0; i < ((in_game_state*)_pGame->p_current_state)->NPC_count; i++ ) destroy_NPC( ((in_game_state*)_pGame->p_current_state)->pp_NPCs[i] ); free( ((in_game_state*)_pGame->p_current_state)->pp_NPCs ); destroy_player( ((in_game_state*)_pGame->p_current_state)->p_player ); destroy_timer( ((in_game_state*)_pGame->p_current_state)->game_ended_timer ); free( _pGame->p_current_state ); _pGame->p_current_state = NULL; }
int fini_service(int isparent) { if (!isparent) { destroy_timer(); } return 0; }
int main(void) { char arg[50]; char tstr[200]; int ret; struct timespec time; time.tv_sec = 0, time.tv_nsec= 100000000; init_timer(MAX_TIMER_NUM); id[0] = add_timer(1, timer1_cb, NULL, 0); printf("Register timer id[0]=%d\n", id[0]); id[1] = add_timer(2, timer2_cb, arg, 50); printf("Register timer id[1]=%d\n", id[1]); while (1) { if (call_cnt > 10) { break; } nanosleep(&time, NULL); } ret = destroy_timer(); printf("main: %s destroy_timer, ret=%d\n", fmt_time(tstr), ret); return 0; }
// Timer map cleanup static int timer_delete_cb(void *data, const char *key, void *value) { timer_hist *t = value; destroy_timer(&t->tm); if (t->counts) free(t->counts); free(t); return 0; }
static void timer_callback(lcb_socket_t sock, short which, void *arg) { lcb_timer_t timer = arg; lcb_t instance = timer->instance; lcb_assert(TMR_IS_ARMED(timer)); lcb_assert(!TMR_IS_DESTROYED(timer)); timer->state |= LCB_TIMER_S_ENTERED; lcb_timer_disarm(timer); timer->callback(timer, instance, timer->cookie); if (TMR_IS_DESTROYED(timer) == 0 && TMR_IS_PERIODIC(timer) != 0) { lcb_timer_rearm(timer, timer->usec_); return; } if (! TMR_IS_STANDALONE(timer)) { lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_TIMER, timer); lcb_maybe_breakout(instance); } if (TMR_IS_DESTROYED(timer)) { destroy_timer(timer); } else { timer->state &= ~LCB_TIMER_S_ENTERED; } (void)sock; (void)which; }
void cleanup_clock() { pango_font_description_free(time1_font_desc); time1_font_desc = NULL; pango_font_description_free(time2_font_desc); time2_font_desc = NULL; free(time1_format); time1_format = NULL; free(time2_format); time2_format = NULL; free(time_tooltip_format); time_tooltip_format = NULL; free(time1_timezone); time1_timezone = NULL; free(time2_timezone); time2_timezone = NULL; free(time_tooltip_timezone); time_tooltip_timezone = NULL; free(clock_lclick_command); clock_lclick_command = NULL; free(clock_mclick_command); clock_mclick_command = NULL; free(clock_rclick_command); clock_rclick_command = NULL; free(clock_uwheel_command); clock_uwheel_command = NULL; free(clock_dwheel_command); clock_dwheel_command = NULL; destroy_timer(&clock_timer); }
/// Destructor flushes buffered data. virtual ~basic_socket_streambuf() { if (pptr() != pbase()) overflow(traits_type::eof()); destroy_timer(); }
void tm_timer_cleanup() { while (timers_head) { tm_timer* t = timers_head; timers_head = t->next; destroy_timer(t); } tm_event_unref(&tm_timer_event); }
void destroy_NPC( NPC* _pNPC ) { if ( _pNPC ) { for ( int i = 0; i < GC_NPC_frames; i++ ) unload_image( _pNPC->NPC_up_frames[i] ); destroy_timer( _pNPC->walk_timer ); destroy_timer( _pNPC->AI_timer ); destroy_timer( _pNPC->frame_timer ); free( _pNPC->NPC_up_frames ); free( _pNPC ); _pNPC = NULL; } }
/** * @brief AsyncServer框架要求实现的接口之一。 * */ extern "C" int fini_service(int isparent) { if (!isparent) { Online::fini(); destroy_timer(); } return 0; }
void alarm( void* arg ) { int* count = (int*)arg; os_timer_log("time is coming,value = %d", (*count)++ ); if( *count == 10 ) destroy_timer(); }
extern "C" int fini_service(int isparent) { if (isparent) { } else { destroy_timer(); clear_online(); } return 0; }
/** * Clean up on exit. This should be called before exiting. * \param show_status set to one to display the mem status */ void cleanup(int show_status) { LM_INFO("cleanup\n"); /*clean-up*/ /* hack: force-unlock the shared memory lock in case some process crashed and let it locked; this will allow an almost gracious shutdown */ if (mem_lock) #ifdef HP_MALLOC { int i; for (i = 0; i < HP_HASH_SIZE; i++) shm_unlock(i); } #else shm_unlock(); #endif handle_ql_shutdown(); destroy_modules(); #ifdef USE_TCP destroy_tcp(); #endif #ifdef USE_TLS destroy_tls(); #endif destroy_timer(); destroy_stats_collector(); destroy_script_cb(); pv_free_extra_list(); destroy_argv_list(); destroy_black_lists(); #ifdef PKG_MALLOC if (show_status){ LM_GEN1(memdump, "Memory status (pkg):\n"); pkg_status(); } #endif #ifdef SHM_MEM cleanup_debug(); if (pt) shm_free(pt); pt=0; if (show_status){ LM_GEN1(memdump, "Memory status (shm):\n"); shm_status(); } /* zero all shmem alloc vars that we still use */ shm_mem_destroy(); #endif if (pid_file) unlink(pid_file); if (pgid_file) unlink(pgid_file); }
/** * @brief AsyncServer框架要求实现的接口之一。 * */ extern "C" int fini_service(int isparent) { if (!isparent) { destroy_timer(); // finalize service login.fini(); } return 0; }
/** * @brief fini_service 异步框架要求实现的接口之一 * * @param isparent * * @return */ int fini_service(int isparent) { DEBUG_LOG("isparent:%d", isparent); if(!isparent) { g_online.uninit(); g_shop.uninit(); g_ed_fight.uninit(); destroy_timer(); } return 0; }
void iu_tq_destroy(iu_tq_t *tq) { iu_timer_node_t *node, *next_node; for (node = tq->iutq_head; node != NULL; node = next_node) { next_node = node->iutn_next; destroy_timer(tq, node); } free(tq); }
/** * @brief AsyncServer框架要求实现的接口之一。 * */ extern "C" int fini_service(int isparent) { if (!isparent) { destroy_timer(); std::map<uint32_t, CChatCheck*>::iterator it; for (it = game_chat_check.begin(); it != game_chat_check.end(); it ++) { delete it->second; } game_chat_check.clear(); } return 0; }
/** * Clean up on exit. This should be called before exiting. * \param show_status set to one to display the mem status */ void cleanup(int show_status) { LM_INFO("cleanup\n"); /*clean-up*/ if (mem_lock) shm_unlock(); /* hack: force-unlock the shared memory lock in case some process crashed and let it locked; this will allow an almost gracious shutdown */ handle_ql_shutdown(); destroy_modules(); #ifdef USE_TCP destroy_tcp(); #endif #ifdef USE_TLS destroy_tls(); #endif destroy_timer(); destroy_stats_collector(); destroy_script_cb(); pv_free_extra_list(); destroy_argv_list(); destroy_black_lists(); #ifdef CHANGEABLE_DEBUG_LEVEL if (debug!=&debug_init) { reset_proc_debug_level(); debug_init = *debug; shm_free(debug); debug = &debug_init; } #endif #ifdef PKG_MALLOC if (show_status){ LM_GEN1(memdump, "Memory status (pkg):\n"); pkg_status(); } #endif #ifdef SHM_MEM if (pt) shm_free(pt); pt=0; if (show_status){ LM_GEN1(memdump, "Memory status (shm):\n"); shm_status(); } /* zero all shmem alloc vars that we still use */ shm_mem_destroy(); #endif if (pid_file) unlink(pid_file); if (pgid_file) unlink(pgid_file); }
int handle_fini () { int i; for (i = 0; i < epi.maxfd; i++) { if (epi.fds[i].type == REMOTE_TYPE_FD && epi.fds[i].cb.sendlen > 0) return 0; } destroy_timer (); fini_sprites (); unload_dlls (); return 1; }
int plugin_fini(int type) { switch (type) { case PROC_MAIN: break; case PROC_CONN: break; case PROC_WORK: fini_nodes(); destroy_timer(); break; default: break; } return 0; }
LIBCOUCHBASE_API lcb_error_t lcb_timer_destroy(lcb_t instance, lcb_timer_t timer) { int standalone = timer->options & LCB_TIMER_STANDALONE; if (!standalone) { lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_TIMER, timer); } lcb_timer_disarm(timer); if (timer->state & LCB_TIMER_S_ENTERED) { timer->state |= LCB_TIMER_S_DESTROYED; lcb_assert(TMR_IS_DESTROYED(timer)); } else { destroy_timer(timer); } return LCB_SUCCESS; }
/// Cancel and free a timeout by id void tm_cleartimeout(unsigned id) { tm_timer** p = &timers_head; while (*p) { tm_timer* t = *p; if (t->id == id) { if (t->next) { t->next->time += t->time; } *p = t->next; destroy_timer(t); break; } p = &t->next; } if (p == &timers_head) { configure_timer_interrupt(); } }
int iu_cancel_timer(iu_tq_t *tq, iu_timer_id_t timer_id, void **arg) { iu_timer_node_t *node; if (timer_id == -1) return (0); for (node = tq->iutq_head; node != NULL; node = node->iutn_next) { if (node->iutn_timer_id == timer_id) { if (arg != NULL) *arg = node->iutn_arg; remove_timer(tq, node); destroy_timer(tq, node); return (1); } } return (0); }
int fini_service(int isparent) { if (!isparent) { KDEBUG_LOG(0, "FINI SERVICE"); destroy_timer(); fini_sprites(); fini_home_maps(); unload_maps(); fini_mail(); fini_all_items(); fini_beast_grp(); fini_rand_infos(); fini_npcs(1); fini_all_skills(); fini_all_clothes(); fini_sys_info(); fini_all_tasks(); fini_shops(); } return 0; }
/* call it before exiting; if show_status==1, mem status is displayed */ void cleanup(show_status) { /*clean-up*/ if (mem_lock) shm_unlock(); /* hack: force-unlock the shared memory lock in case some process crashed and let it locked; this will allow an almost gracious shutdown */ destroy_modules(); #ifdef USE_TCP destroy_tcp(); #endif #ifdef USE_TLS destroy_tls(); #endif destroy_timer(); close_unixsock_server(); destroy_fifo(); destroy_script_cb(); #ifdef PKG_MALLOC if (show_status){ LOG(memlog, "Memory status (pkg):\n"); pkg_status(); } #endif #ifdef SHM_MEM if (pt) shm_free(pt); pt=0; if (show_status){ LOG(memlog, "Memory status (shm):\n"); shm_status(); } /* zero all shmem alloc vars that we still use */ shm_mem_destroy(); #endif if (pid_file) unlink(pid_file); if (pgid_file) unlink(pgid_file); }
/// Callback enqueued by the timer ISR. It is safe for this to be called more /// often than necessary void timer_cb(tm_event* event) { (void) event; unsigned prev_time = last_time; last_time = tm_uptime_micro(); unsigned elapsed = last_time - prev_time; while (timers_head) { tm_timer* t = timers_head; if (t->time > elapsed) { t->time -= elapsed; break; } elapsed -= t->time; timers_head = t->next; lua_rawgeti(tm_lua_state, LUA_REGISTRYINDEX, t->lua_cb); if (t->repeat != 0) { // It's back in the queue, so clearInterval within the callback can cancel it enqueue_timer(t->repeat, t); } else { // Clean up before calling lua, as it can setjmp. The callback is safely rooted on the lua stack above. destroy_timer(t); t = NULL; } lua_getfield(tm_lua_state, LUA_GLOBALSINDEX, "global"); tm_checked_call(tm_lua_state, 1); } // If lua setjmps, these will be cleaned up when the timer state is reset configure_timer_interrupt(); }
void destroy_game(Game* G) { destroy_timer(G->timer); destroy_graphics(G->graphics); free(G); }
/* ret 0 on success, <0 on error*/ int init_timer() { int r; int ret; ret=-1; /* init the locks */ timer_lock=lock_alloc(); if (timer_lock==0){ ret=E_OUT_OF_MEM; goto error; } if (lock_init(timer_lock)==0){ lock_dealloc(timer_lock); timer_lock=0; ret=-1; goto error; } /* init the shared structs */ ticks=shm_malloc(sizeof(ticks_t)); timer_lst=shm_malloc(sizeof(struct timer_lists)); if (ticks==0){ SHM_MEM_CRITICAL; ret=E_OUT_OF_MEM; goto error; } if (timer_lst==0){ SHM_MEM_CRITICAL; ret=E_OUT_OF_MEM; goto error; } running_timer=shm_malloc(sizeof(struct timer_ln*)); if (running_timer==0){ SHM_MEM_CRITICAL; ret=E_OUT_OF_MEM; goto error; } /* initial values */ memset(timer_lst, 0, sizeof(struct timer_lists)); *ticks=random(); /* random value for start, for debugging */ prev_ticks=last_ticks=last_adj_check=*ticks; *running_timer=0; if (gettimeofday(&start_time, 0)<0){ LM_ERR("gettimeofday failed: %s [%d]\n", strerror(errno), errno); ret=-1; goto error; } last_time=start_time; LM_DBG("starting with *ticks=%u\n", (unsigned) *ticks); /* init timer structures */ for (r=0; r<H0_ENTRIES; r++) _timer_init_list(&timer_lst->h0[r]); for (r=0; r<H1_ENTRIES; r++) _timer_init_list(&timer_lst->h1[r]); for (r=0; r<H2_ENTRIES; r++) _timer_init_list(&timer_lst->h2[r]); _timer_init_list(&timer_lst->expired); #ifdef USE_SLOW_TIMER /* init the locks */ slow_timer_lock=lock_alloc(); if (slow_timer_lock==0){ ret=E_OUT_OF_MEM; goto error; } if (lock_init(slow_timer_lock)==0){ lock_dealloc(slow_timer_lock); slow_timer_lock=0; ret=-1; goto error; } t_idx=shm_malloc(sizeof(*t_idx)); s_idx=shm_malloc(sizeof(*s_idx)); slow_timer_lists=shm_malloc(sizeof(struct timer_head)*SLOW_LISTS_NO); running_timer2=shm_malloc(sizeof(struct timer_ln*)); if ((t_idx==0)||(s_idx==0) || (slow_timer_lists==0) ||(running_timer2==0)){ SHM_MEM_ERROR; ret=E_OUT_OF_MEM; goto error; } *t_idx=*s_idx=0; *running_timer2=0; for (r=0; r<SLOW_LISTS_NO; r++) _timer_init_list(&slow_timer_lists[r]); #endif LM_DBG("timer_list between %p and %p\n", &timer_lst->h0[0], &timer_lst->h2[H2_ENTRIES]); return 0; error: destroy_timer(); return ret; }