int ruby_vm_destruct(void *ptr) { RUBY_FREE_ENTER("vm"); if (ptr) { rb_vm_t *vm = ptr; rb_thread_t *th = vm->main_thread; #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE struct rb_objspace *objspace = vm->objspace; #endif rb_gc_force_recycle(vm->self); vm->main_thread = 0; if (th) { thread_free(th); } if (vm->living_threads) { st_free_table(vm->living_threads); vm->living_threads = 0; } rb_thread_lock_unlock(&vm->global_vm_lock); rb_thread_lock_destroy(&vm->global_vm_lock); ruby_xfree(vm); ruby_current_vm = 0; #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE if (objspace) { rb_objspace_free(objspace); } #endif } RUBY_FREE_LEAVE("vm"); return 0; }
void ff_thread_free(AVCodecContext *avctx) { if (avctx->active_thread_type&FF_THREAD_FRAME) frame_thread_free(avctx, avctx->thread_count); else thread_free(avctx); }
int ruby_vm_destruct(rb_vm_t *vm) { RUBY_FREE_ENTER("vm"); if (vm) { rb_thread_t *th = vm->main_thread; #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE struct rb_objspace *objspace = vm->objspace; #endif rb_gc_force_recycle(vm->self); vm->main_thread = 0; if (th) { thread_free(th); } if (vm->living_threads) { st_free_table(vm->living_threads); vm->living_threads = 0; } #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE if (objspace) { rb_objspace_free(objspace); } #endif ruby_vm_run_at_exit_hooks(vm); rb_vm_gvl_destroy(vm); ruby_xfree(vm); ruby_current_vm = 0; } RUBY_FREE_LEAVE("vm"); return 0; }
/** * Internally used "receive status" thread function that will call the specified * callback function when status update messages (or error messages) are * received. * * @param arg Pointer to an allocated struct instproxy_status_data that holds * the required data about the connected client and the callback function. * * @return Always NULL. */ static void* instproxy_receive_status_loop_thread(void* arg) { struct instproxy_status_data *data = (struct instproxy_status_data*)arg; /* run until the command is complete or an error occurs */ (void)instproxy_receive_status_loop(data->client, data->command, data->cbfunc, data->user_data); /* cleanup */ instproxy_lock(data->client); debug_info("done, cleaning up."); if (data->command) { plist_free(data->command); } if (data->client->receive_status_thread) { thread_free(data->client->receive_status_thread); data->client->receive_status_thread = (thread_t)NULL; } instproxy_unlock(data->client); free(data); return NULL; }
void thread_list_free(struct thread_list* self) { int t; for (t = 0; t < self->count; t++) { thread_free(&(self->threads[t])); } free(self); }
void hci_inject_close(void) { socket_free(listen_socket); list_free(clients); thread_free(thread); listen_socket = NULL; thread = NULL; clients = NULL; }
static void fiber_schedule_main_free(void) { if (__main_fiber) { thread_free(__main_fiber); if (__thread_fiber == __main_fiber) __thread_fiber = NULL; __main_fiber = NULL; } }
void printer_free(NumPrinter* p){ mutex_lock(printer_num); if(p->thread != NULL){ thread_terminate(p->thread); thread_free(p->thread); } mutex_unlock(printer_num); free(p); }
static void fiber_io_main_free(void) { if (__main_fiber) { thread_free(__main_fiber); if (__thread_fiber == __main_fiber) { __thread_fiber = NULL; } __main_fiber = NULL; } }
/******************************************************************************* ** ** Function epilog_wait_timeout ** ** Description Timeout thread of epilog watchdog timer ** ** Returns None ** *******************************************************************************/ static void epilog_wait_timeout(UNUSED_ATTR union sigval arg) { ALOGI("...epilog_wait_timeout..."); thread_free(hc_cb.worker_thread); pthread_mutex_lock(&hc_cb.worker_thread_lock); hc_cb.worker_thread = NULL; pthread_mutex_unlock(&hc_cb.worker_thread_lock); }
LIBIMOBILEDEVICE_API np_error_t np_client_free(np_client_t client) { plist_t dict; property_list_service_client_t parent; if (!client) return NP_E_INVALID_ARG; dict = plist_new_dict(); plist_dict_set_item(dict,"Command", plist_new_string("Shutdown")); property_list_service_send_xml_plist(client->parent, dict); plist_free(dict); parent = client->parent; /* notifies the client->notifier thread that it should terminate */ client->parent = NULL; if (client->notifier) { debug_info("joining np callback"); thread_join(client->notifier); thread_free(client->notifier); client->notifier = (thread_t)NULL; } else { dict = NULL; property_list_service_receive_plist(parent, &dict); if (dict) { #ifndef STRIP_DEBUG_CODE char *cmd_value = NULL; plist_t cmd_value_node = plist_dict_get_item(dict, "Command"); if (plist_get_node_type(cmd_value_node) == PLIST_STRING) { plist_get_string_val(cmd_value_node, &cmd_value); } if (cmd_value && !strcmp(cmd_value, "ProxyDeath")) { // this is the expected answer } else { debug_info("Did not get ProxyDeath but:"); debug_plist(dict); } if (cmd_value) { free(cmd_value); } #endif plist_free(dict); } } property_list_service_client_free(parent); mutex_destroy(&client->mutex); free(client); return NP_E_SUCCESS; }
void thread_delete(struct thread *t) { static struct thread *zombie = NULL; assert(t); assert(t->state & TS_EXITED); task_thread_unregister(t->task, t); thread_local_free(t); if (zombie) { thread_free(zombie); } if (t != thread_self()) { assert(!t->schedee.active); assert(!t->schedee.ready); thread_free(t); zombie = NULL; } else { zombie = t; } }
void destroy_xshm_image (Display *dpy, XImage *image, XShmSegmentInfo *shm_info) { #ifdef HAVE_XSHM_EXTENSION if (shm_info->shmid == -1) { #endif /* HAVE_XSHM_EXTENSION */ /* Don't let XDestroyImage free image->data. */ thread_free (image->data); image->data = NULL; XDestroyImage (image); return; #ifdef HAVE_XSHM_EXTENSION } Status status; CATCH_X_ERROR(dpy); status = XShmDetach (dpy, shm_info); UNCATCH_X_ERROR(dpy); if (shm_got_x_error) status = False; if (!status) fprintf (stderr, "%s: XShmDetach failed!\n", progname); #ifdef DEBUG else fprintf (stderr, "%s: XShmDetach(dpy, shm_info) ==> True\n", progname); #endif XDestroyImage (image); XSync(dpy, False); status = shmdt (shm_info->shmaddr); if (status != 0) { char buf[1024]; sprintf (buf, "%s: shmdt(0x%lx) failed", progname, (unsigned long) shm_info->shmaddr); perror(buf); } #ifdef DEBUG else fprintf (stderr, "%s: shmdt(shm_info->shmaddr) ==> 0\n", progname); #endif XSync(dpy, False); #endif /* HAVE_XSHM_EXTENSION */ }
void btif_sock_cleanup(void) { if (thread_handle == -1) return; thread_stop(thread); thread_join(thread); btsock_thread_exit(thread_handle); btsock_rfc_cleanup(); btsock_sco_cleanup(); btsock_l2cap_cleanup(); thread_free(thread); thread_handle = -1; thread = NULL; }
bt_status_t btif_sock_init(void) { assert(thread_handle == -1); assert(thread == NULL); btsock_thread_init(); thread_handle = btsock_thread_create(btsock_signaled, NULL); if (thread_handle == -1) { LOG_ERROR("%s unable to create btsock_thread.", __func__); goto error; } bt_status_t status = btsock_rfc_init(thread_handle); if (status != BT_STATUS_SUCCESS) { LOG_ERROR("%s error initializing RFCOMM sockets: %d", __func__, status); goto error; } status = btsock_l2cap_init(thread_handle); if (status != BT_STATUS_SUCCESS) { LOG_ERROR("%s error initializing L2CAP sockets: %d", __func__, status); goto error; } thread = thread_new("btif_sock"); if (!thread) { LOG_ERROR("%s error creating new thread.", __func__); btsock_rfc_cleanup(); goto error; } status = btsock_sco_init(thread); if (status != BT_STATUS_SUCCESS) { LOG_ERROR("%s error initializing SCO sockets: %d", __func__, status); btsock_rfc_cleanup(); goto error; } return BT_STATUS_SUCCESS; error:; thread_free(thread); thread = NULL; if (thread_handle != -1) btsock_thread_exit(thread_handle); thread_handle = -1; return BT_STATUS_FAIL; }
// Closes the interface. // This routine is not thread safe. static void cleanup(void) { if (has_cleaned_up) { ALOGW("%s Already cleaned up for this session\n", __func__); return; } BTHCDBG("cleanup"); if (hc_cb.worker_thread) { if (fwcfg_acked) { epilog_wait_timer(); // Stop reading thread userial_close_reader(); thread_post(hc_cb.worker_thread, event_epilog, NULL); } thread_free(hc_cb.worker_thread); pthread_mutex_lock(&hc_cb.worker_thread_lock); hc_cb.worker_thread = NULL; pthread_mutex_unlock(&hc_cb.worker_thread_lock); if (hc_cb.epilog_timer_created) { timer_delete(hc_cb.epilog_timer_id); hc_cb.epilog_timer_created = false; } } BTHCDBG("%s Finalizing cleanup\n", __func__); lpm_cleanup(); userial_close(); p_hci_if->cleanup(); utils_cleanup(); set_power(BT_VND_PWR_OFF); vendor_close(); pthread_mutex_destroy(&hc_cb.worker_thread_lock); fwcfg_acked = false; bt_hc_cbacks = NULL; has_cleaned_up = true; }
/* * UMA should ensure that this function is never called. * Freeing a proc structure would violate type stability. */ static void proc_fini(void *mem, int size) { #ifdef notnow struct proc *p; p = (struct proc *)mem; EVENTHANDLER_INVOKE(process_fini, p); pstats_free(p->p_stats); thread_free(FIRST_THREAD_IN_PROC(p)); mtx_destroy(&p->p_mtx); if (p->p_ksi != NULL) ksiginfo_free(p->p_ksi); #else panic("proc reclaimed"); #endif }
static future_t *shut_down() { LOG_INFO(LOG_TAG, "%s", __func__); hci_inject->close(); if (thread) { if (firmware_is_configured) { non_repeating_timer_restart(epilog_timer); thread_post(thread, event_epilog, NULL); } else { thread_stop(thread); } thread_join(thread); } fixed_queue_free(command_queue, buffer_allocator->free); fixed_queue_free(packet_queue, buffer_allocator->free); list_free(commands_pending_response); pthread_mutex_destroy(&commands_pending_response_lock); packet_fragmenter->cleanup(); non_repeating_timer_free(epilog_timer); non_repeating_timer_free(command_response_timer); non_repeating_timer_free(startup_timer); epilog_timer = NULL; command_response_timer = NULL; low_power_manager->cleanup(); hal->close(); // Turn off the chip int power_state = BT_VND_PWR_OFF; vendor->send_command(VENDOR_CHIP_POWER_CONTROL, &power_state); vendor->close(); thread_free(thread); thread = NULL; firmware_is_configured = false; return NULL; }
LIBIMOBILEDEVICE_API instproxy_error_t instproxy_client_free(instproxy_client_t client) { if (!client) return INSTPROXY_E_INVALID_ARG; property_list_service_client_free(client->parent); client->parent = NULL; if (client->receive_status_thread) { debug_info("joining receive_status_thread"); thread_join(client->receive_status_thread); thread_free(client->receive_status_thread); client->receive_status_thread = (thread_t)NULL; } mutex_destroy(&client->mutex); free(client); return INSTPROXY_E_SUCCESS; }
void alarm_cleanup(void) { // If lazy_initialize never ran there is nothing to do if (!alarms) return; callback_thread_active = false; semaphore_post(alarm_expired); thread_free(callback_thread); callback_thread = NULL; semaphore_free(alarm_expired); alarm_expired = NULL; timer_delete(&timer); list_free(alarms); alarms = NULL; pthread_mutex_destroy(&monitor); }
char PICLANG_save(char saved_status) { if(curr_process.page_size == 0) return PICLANG_NO_SUCH_PROGRAM; curr_process.status = saved_status; SRAM_write(picos_processes[picos_curr_process].addr,&curr_process,PCB_SIZE); if(saved_status == PICLANG_SUSPENDED) thread_suspend(picos_curr_process); else { PAGE_free(picos_curr_process); thread_free(picos_curr_process); } PICLANG_init(); return 0; }
void* thread_realloc(void* addr, size_t size) { if (addr == NULL) { return thread_alloc(size); } alloc_block_header* blk = (alloc_block_header*)addr - 1; size_t new_size = ((size + BLOCK_ALIGNMENT-1) & ~(BLOCK_ALIGNMENT-1)) + sizeof(alloc_block_header); if (blk->size >= new_size) { return addr; } if (blk->size > MAX_BLOCK_SIZE) { blk = (alloc_block_header*)realloc(blk, new_size); blk->size = new_size; return (alloc_block_header*)blk + 1; } else { void* new_addr = thread_alloc(size); memcpy(new_addr, addr, blk->size - sizeof(alloc_block_header)); thread_free(addr); return new_addr; } }
void eager_reader_free(eager_reader_t *reader) { if (!reader) return; eager_reader_unregister(reader); // Only unregister from the input if we actually did register if (reader->inbound_read_object) reactor_unregister(reader->inbound_read_object); if (reader->bytes_available_fd != INVALID_FD) close(reader->bytes_available_fd); // Free the current buffer, because it's not in the queue // and won't be freed below if (reader->current_buffer) reader->allocator->free(reader->current_buffer); fixed_queue_free(reader->buffers, reader->allocator->free); thread_free(reader->inbound_read_thread); osi_free(reader); }
int main() { THREAD *t = thread_new(); thread_setFunction(t, sub, NULL); thread_run(t); int i; for (i = 0; i < 10; ++i) { if (thread_isRunning(t)) { printf ("Thread 1 is still running\n"); sleep(1); } } thread_wait(t); printf("Thread 1 has the status %d\n", thread_getStatus(t)); printf("Thread 1 has the exit-code %d\n", thread_getExit(t)); thread_free(t); return EXIT_SUCCESS; }
void thread_delete(struct thread *thread) { struct pd *pd; #if defined(CONFIG_SESSION) struct session_p_node *sd; #endif pd = thread->owner; (void)L4_ThreadControl(thread->id, L4_nilspace, L4_nilthread, L4_nilthread, L4_nilthread, 0, NULL); thread_free(thread->id); if ( #if defined(CONFIG_EAS) thread->eas == NULL && #endif thread->utcb != (void *)-1UL) { /* free local thread no. */ bfl_free(pd->local_threadno, ((uintptr_t)thread->utcb - L4_Address(pd->space.utcb_area)) >> L4_GetUtcbBits()); }
static void thread_exit(void *dcontext) { fuzz_pass_context_t *fp = (fuzz_pass_context_t *) drmgr_get_tls_field(dcontext, tls_idx_fuzzer); /* crash is indicated by aborted fuzz targets, even if the app did a hard exit() */ if (fp->live_targets != NULL) { if (callbacks->crash_thread_event != NULL) { /* There may be targets already captured by a fault event. If not, and if fuzz * targets were evidently aborted, then make them available in an iterator. */ if (fp->thread_state->targets == NULL && fp->live_targets != NULL) fp->thread_state->targets = create_target_iterator(fp); callbacks->crash_thread_event(fp, fp->thread_state); } } free_thread_state(fp); clear_pass_targets(fp); thread_free(dcontext, fp, sizeof(fuzz_pass_context_t), HEAPSTAT_MISC); }
int test_scheduler() { shared_counter = 0; struct thread_t* threads[5]; scheduler_begin(2); threads[0] = thread_fork(increment, (void*)"1"); threads[1] = thread_fork(increment, (void*)"2"); threads[2] = thread_fork(increment, (void*)"3"); threads[3] = thread_fork(increment, (void*)"4"); threads[4] = thread_fork(increment, (void*)"5"); scheduler_end(); //free threads' memories int i; for (i=0;i<5;i++) { thread_free(threads[i]); } //check if the result is correct if (shared_counter != 100*5) { return -1; } return 0; }
LIBIMOBILEDEVICE_API np_error_t np_set_notify_callback( np_client_t client, np_notify_cb_t notify_cb, void *user_data ) { if (!client) return NP_E_INVALID_ARG; np_error_t res = NP_E_UNKNOWN_ERROR; np_lock(client); if (client->notifier) { debug_info("callback already set, removing"); property_list_service_client_t parent = client->parent; client->parent = NULL; thread_join(client->notifier); thread_free(client->notifier); client->notifier = (thread_t)NULL; client->parent = parent; } if (notify_cb) { struct np_thread *npt = (struct np_thread*)malloc(sizeof(struct np_thread)); if (npt) { npt->client = client; npt->cbfunc = notify_cb; npt->user_data = user_data; if (thread_new(&client->notifier, np_notifier, npt) == 0) { res = NP_E_SUCCESS; } } } else { debug_info("no callback set"); } np_unlock(client); return res; }
void setter_remove(setter_t setter){ thread_free(setter->th); free(setter); }
static int create_thread(struct thread *td, mcontext_t *ctx, void (*start_func)(void *), void *arg, char *stack_base, size_t stack_size, char *tls_base, long *child_tid, long *parent_tid, int flags, struct rtprio *rtp) { stack_t stack; struct thread *newtd; struct proc *p; int error; p = td->td_proc; /* Have race condition but it is cheap. */ if (p->p_numthreads >= max_threads_per_proc) { ++max_threads_hits; return (EPROCLIM); } if (rtp != NULL) { switch(rtp->type) { case RTP_PRIO_REALTIME: case RTP_PRIO_FIFO: /* Only root can set scheduler policy */ if (priv_check(td, PRIV_SCHED_SETPOLICY) != 0) return (EPERM); if (rtp->prio > RTP_PRIO_MAX) return (EINVAL); break; case RTP_PRIO_NORMAL: rtp->prio = 0; break; default: return (EINVAL); } } #ifdef RACCT PROC_LOCK(td->td_proc); error = racct_add(p, RACCT_NTHR, 1); PROC_UNLOCK(td->td_proc); if (error != 0) return (EPROCLIM); #endif /* Initialize our td */ newtd = thread_alloc(0); if (newtd == NULL) { error = ENOMEM; goto fail; } cpu_set_upcall(newtd, td); /* * Try the copyout as soon as we allocate the td so we don't * have to tear things down in a failure case below. * Here we copy out tid to two places, one for child and one * for parent, because pthread can create a detached thread, * if parent wants to safely access child tid, it has to provide * its storage, because child thread may exit quickly and * memory is freed before parent thread can access it. */ if ((child_tid != NULL && suword_lwpid(child_tid, newtd->td_tid)) || (parent_tid != NULL && suword_lwpid(parent_tid, newtd->td_tid))) { thread_free(newtd); error = EFAULT; goto fail; } bzero(&newtd->td_startzero, __rangeof(struct thread, td_startzero, td_endzero)); bcopy(&td->td_startcopy, &newtd->td_startcopy, __rangeof(struct thread, td_startcopy, td_endcopy)); newtd->td_proc = td->td_proc; newtd->td_ucred = crhold(td->td_ucred); if (ctx != NULL) { /* old way to set user context */ error = set_mcontext(newtd, ctx); if (error != 0) { thread_free(newtd); crfree(td->td_ucred); goto fail; } } else { /* Set up our machine context. */ stack.ss_sp = stack_base; stack.ss_size = stack_size; /* Set upcall address to user thread entry function. */ cpu_set_upcall_kse(newtd, start_func, arg, &stack); /* Setup user TLS address and TLS pointer register. */ error = cpu_set_user_tls(newtd, tls_base); if (error != 0) { thread_free(newtd); crfree(td->td_ucred); goto fail; } } PROC_LOCK(td->td_proc); td->td_proc->p_flag |= P_HADTHREADS; thread_link(newtd, p); bcopy(p->p_comm, newtd->td_name, sizeof(newtd->td_name)); thread_lock(td); /* let the scheduler know about these things. */ sched_fork_thread(td, newtd); thread_unlock(td); if (P_SHOULDSTOP(p)) newtd->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK; PROC_UNLOCK(p); tidhash_add(newtd); thread_lock(newtd); if (rtp != NULL) { if (!(td->td_pri_class == PRI_TIMESHARE && rtp->type == RTP_PRIO_NORMAL)) { rtp_to_pri(rtp, newtd); sched_prio(newtd, newtd->td_user_pri); } /* ignore timesharing class */ } TD_SET_CAN_RUN(newtd); sched_add(newtd, SRQ_BORING); thread_unlock(newtd); return (0); fail: #ifdef RACCT PROC_LOCK(p); racct_sub(p, RACCT_NTHR, 1); PROC_UNLOCK(p); #endif return (error); }