Linux and UNIX Man Pages

Linux & Unix Commands - Search Man Pages

select_enqueue(9r) [osf1 man page]

select_enqueue(9r)														select_enqueue(9r)

NAME
select_enqueue - General: Adds the current kernel thread SYNOPSIS
void select_enqueue( sel_queue_t *selq ); ARGUMENTS
Specifies a pointer to a sel_queue structure. DESCRIPTION
The select_enqueue routine adds the current kernel thread to the list of kernel threads waiting for a select event on the specified device. This routine is called when a kernel module's select routine has been called and the requested event cannot be immediately satisfied. For example, the requested event cannot be immediately satisfied when xxselect is called for the following reasons: To select on input and there are no characters available When called for output and the kernel module's output buffers are currently full By calling select_enqueue, the kernel module's select routine ensures that the kernel thread issuing the select call will be blocked until the requested event can be satisfied or until the select call terminates. CAUTIONS
You must call the queue_init routine to initialize the sel_queue structure pointer prior to calling select_enqueue. Failure to do so causes the kernel to panic. RETURN VALUES
None FILES
SEE ALSO
Routines: queue_init(9r), select_dequeue(9r), select_dequeue_all(9r), select_wakeup(9r) Data Structures: sel_queue(9s) System Calls: select(2) select_enqueue(9r)

Check Out this Related Man Page

thread_terminate(9r)													      thread_terminate(9r)

NAME
thread_terminate - General: Prepares to stop or stops execution of the specified kernel thread SYNOPSIS
kern_return_t thread_terminate( thread_t thread_to_terminate ); ARGUMENTS
Specifies a pointer to the thread structure associated with the kernel thread that you want to terminate. This pointer was returned in a previous call to the kernel_isrthread or kernel_thread_w_arg routine. DESCRIPTION
The thread_terminate routine prepares to stop or permanently stops execution of the specified kernel thread. You created and started this kernel thread in a previous call to the kernel_isrthread or kernel_thread_w_arg routine. These routines return a pointer to the thread structure associated with the newly created and started kernel thread. Kernel modules use this pointer as a handle to identify the specific kernel thread that thread_terminate stops executing. Typically, a kernel thread terminates itself. However, one kernel thread can terminate another kernel thread. A kernel thread that termi- nates itself must call thread_halt_self immediately after the call to thread_terminate. The reason for this is that thread_terminate only prepares the self-terminating kernel thread to stop execution. The thread_halt_self routine completes the work needed to stop execution (by performing the appropriate cleanup work) of the self-terminating kernel thread. Specifically, the thread_terminate routine works as follows: For terminating other kernel threads The thread_terminate routine stops execution of the specified kernel thread, frees any resources associated with that kernel thread, and thus makes the kernel thread unavailable. To make the kernel thread available again, you need to create it by calling ker- nel_isrthread or kernel_thread_w_arg. A kernel thread terminates itself The thread_terminate routine prepares to stop execution of the kernel thread that needs to terminate itself. The thread_halt_self routine completes the work needed to stop execution of the self-terminating kernel thread by performing the appropriate cleanup work. After you call these routines, the self-terminating kernel thread becomes unavailable until you create it again by calling kernel_isrthread or kernel_thread_w_arg. NOTES
You do not need to terminate every kernel thread that you create. You should not terminate a kernel thread that is waiting for some event. The basic rule is that you should terminate only those kernel threads that you do not need anymore. For example, if a dynamically config- ured kernel module uses kernel threads, you should terminate them in the CFG_OP_UNCONFIGURE entry point of the loadable module's configure routine. The kernel threads are no longer needed after the module is unconfigured. Note that the thread_terminate routine (for kernel threads that terminate other kernel threads) not only permanently stops execution of the specified kernel thread, but it also frees any resources associated with that kernel thread; thus, this kernel thread can no longer be used. RETURN VALUES
Upon successfully terminating the specified kernel thread, thread_terminate returns the constant KERN_SUCCESS. If the thread structure pointer passed to the thread_to_terminate argument does not identify a valid kernel thread, thread_terminate returns the constant KERN_INVALID_ARGUMENT. On any other error, thread_terminate returns the constant KERN_FAILURE. SEE ALSO
Data Structures: thread(9s) Routines: kernel_isrthread(9r), kernel_thread_w_arg(9r), thread_halt_self(9r) thread_terminate(9r)
Man Page