static void release_resource (CcnetProcessor *processor) { release_thread (processor); CCNET_PROCESSOR_CLASS(seafile_recvblock_v2_proc_parent_class)->release_resource (processor); }
void release(struct task_struct * p) { int i; if (!p) return; if (p == current) { printk("task releasing itself\n"); return; } for (i=1 ; i<NR_TASKS ; i++) if (task[i] == p) { nr_tasks--; task[i] = NULL; REMOVE_LINKS(p); release_thread(p); if (STACK_MAGIC != *(unsigned long *)p->kernel_stack_page) printk(KERN_ALERT "release: %s kernel stack corruption. Aiee\n", p->comm); free_kernel_stack(p->kernel_stack_page); current->cmin_flt += p->min_flt + p->cmin_flt; current->cmaj_flt += p->maj_flt + p->cmaj_flt; current->cnswap += p->nswap + p->cnswap; kfree(p); return; } panic("trying to release non-existent task"); }
/* * Will release a thread if needed, otherwise will just increment * the semaphore's value * * @Param - Pointer to the semaphore that is being signaled */ void mysem_signal(Semaphore* sem){ DISABLE_INTERRUPTS(); sem->value++; if(sem->value <= 0){ mythread_unblock(release_thread(sem)); mysem_printQueue(sem); } ENABLE_INTERRUPTS(); }
static NIL_type flush_thread(NIL_type) { THR_type next_thread, thread; for (thread = Thread_Current; !is_NUL(thread); thread = next_thread) { next_thread = thread->thr; release_thread(thread); } Thread_Current = Main_Empty_Thread; }
static void release_resource (CcnetProcessor *processor) { SeafileGetblockV2Proc *proc = (SeafileGetblockV2Proc *)processor; release_thread (processor); descruct_bitfield (&proc->block_bitmap, &proc->active, proc->tx_task); CCNET_PROCESSOR_CLASS(seafile_getblock_v2_proc_parent_class)->release_resource (processor); }
THR_type Thread_Poke(NBR_type Thread_id, EXP_type Call_status, UNS_type Size) { THR_type thread; thread = Thread_Current->thr; release_thread(Thread_Current); Thread_Current = acquire_thread(Size, Thread_id, thread, Call_status); return Thread_Current; }
static void release_task(struct task_struct * p) { if (p != current) { #ifdef CONFIG_SMP /* * Wait to make sure the process isn't on the * runqueue (active on some other CPU still) */ for (;;) { task_lock(p); if (!task_has_cpu(p)) break; task_unlock(p); do { cpu_relax(); barrier(); } while (task_has_cpu(p)); } task_unlock(p); #endif atomic_dec(&p->user->processes); security_task_free(p); free_uid(p->user); unhash_process(p); release_thread(p); current->cmin_flt += p->min_flt + p->cmin_flt; current->cmaj_flt += p->maj_flt + p->cmaj_flt; current->cnswap += p->nswap + p->cnswap; /* * Potentially available timeslices are retrieved * here - this way the parent does not get penalized * for creating too many processes. * * (this cannot be used to artificially 'generate' * timeslices, because any timeslice recovered here * was given away by the parent in the first place.) */ current->counter += p->counter; if (current->counter >= MAX_COUNTER) current->counter = MAX_COUNTER; p->pid = 0; free_task_struct(p); } else { printk("task releasing itself\n"); } }
static void release_task(struct task_struct * p) { if (p == current) BUG(); #ifdef CONFIG_SMP wait_task_inactive(p); #endif atomic_dec(&p->user->processes); free_uid(p->user); unhash_process(p); release_thread(p); current->cmin_flt += p->min_flt + p->cmin_flt; current->cmaj_flt += p->maj_flt + p->cmaj_flt; current->cnswap += p->nswap + p->cnswap; sched_exit(p); p->pid = 0; free_task_struct(p); }
void release(struct task_struct * p) { if (p != current) { #ifdef __SMP__ /* * Wait to make sure the process isn't active on any * other CPU */ for (;;) { int has_cpu; spin_lock_irq(&runqueue_lock); has_cpu = p->has_cpu; spin_unlock_irq(&runqueue_lock); if (!has_cpu) break; do { barrier(); } while (p->has_cpu); } #endif free_uid(p); add_free_taskslot(p->tarray_ptr); write_lock_irq(&tasklist_lock); nr_tasks--; unhash_pid(p); REMOVE_LINKS(p); write_unlock_irq(&tasklist_lock); release_thread(p); current->cmin_flt += p->min_flt + p->cmin_flt; current->cmaj_flt += p->maj_flt + p->cmaj_flt; current->cnswap += p->nswap + p->cnswap; free_task_struct(p); } else { printk("task releasing itself\n"); } }
NIL_type Thread_Zap(NIL_type) { THR_type thread; thread = Thread_Current; Thread_Current = thread->thr; release_thread(thread); }