Manera correcta de manejar hilos en kernel?

Question

He visto fragmentos de información dispersa, pero parece que no puedo obtener una respuesta final. ¿Cómo se limpia un hilo zombie en Kernel?

Solo para asegurarme, y producir una forma correcta final de manejar los hilos en kernel, me gustaría hacer esta pregunta más ampliamente. ¿Cómo se crea, finaliza y limpia un hilo en el kernel de Linux?

Lo que tengo hasta ahora es la siguiente:

thread_func: 
    exited = 0; 
    while (!must_exit) 
     do stuff 
    exited = 1; 
    do_exit(0) 

init_module: 
    must_exit = 0; 
    exited = 1; 
    kthread_run(thread_func, ...) /* creates and runs the thread */ 

cleanup_module: 
    must_exit = 1; 
    while (!exited) 
     set_current_state(TASK_INTERRUPTIBLE); 
     msleep(1); 
    /* How do I cleanup? */ 

Lo más parecido que he encontrado para la solución de limpieza es release_task, pero que no encontrar en cualquier lugar de hablar de ello. Imaginaba que dado que las funciones de subprocesos son kthread_create, kthread_run etc., debería haber un kthread_join o kthread_wait, pero no lo había. do_wait también parecía probable, pero no toma un struct task_struct *.

Además, no estoy seguro de si do_exit es una buena idea, o si es necesario tampoco. ¿Puede alguien dar el boceto mínimo de cómo debe crearse, terminarse y limpiarse una kthread?

Answer 1

Una de las formas "correctas" de hacer esto es hacer que su función de hilo compruebe si es kthread_should_stop, y simplemente regrese si necesita detenerse.

No necesita llamar al do_exit, y si tiene la intención de kthread_stop desde la función de salida del módulo, probablemente no deba hacerlo.

se puede ver esto mirando la documentación para kthread_create_on_node en kernel/kthread.c (extracto de Linux kernel 3.3.1):

/** *
kthread_create_on_node - crear un kthread.
* @threadfn: la función se ejecuta hasta signal_pending (current).
* @data: datos ptr para @threadfn.
* @node: número de nodo de memoria.
* @namefmt: nombre de estilo de printf para el subproceso.
*
* Descripción: Esta función de ayuda crea y nombra un núcleo
* thread. El hilo se detendrá: use wake_up_process() para iniciar
* it. Ver también kthread_run().
*
* Si el hilo se va a unir a una CPU en particular, proporcione su nodo
* en @node, para obtener la afinidad NUMA por la pila kthread, o bien proporcione -1.
* Cuando se lo despierte, el subproceso se ejecutará @threadfn() con @data como su argumento
*. @threadfn() puede llamar do_exit() directamente si es un hilo independiente
* por el que nadie llamará kthread_stop(), o
* retorno cuando 'kthread_should_stop()' es cierto (lo que significa
* se ha llamado a kthread_stop()). El valor de retorno debe ser cero
* o un número de error negativo; se pasará a kthread_stop().
*
* Devuelve un task_struct o ERR_PTR (-ENOMEM).
*/

Una "coincidencia" comentario está presente para kthread_stop:

Si threadfn() puede llamar do_exit() sí, la persona que llama debe garantizar task_struct no puede irse.

(Y no estoy seguro de cómo se hace eso - probablemente se aferra a la struct_task con un get_task_struct.)

Si camina el camino de una creación del hilo que obtendrá algo como:

kthread_create           // macro in kthread.h 
    -> kthread_create_on_node        // in kthead.c 
    -> adds your thread request to kthread_create_list 
    -> wakes up the kthreadd_task 

kthreadd_task está configurado en init/main.c en reset_init. Se ejecuta la función kthreadd (de kthread.c)

kthreadd             // all in kthread.c 
    -> create_kthread 
    -> kernel_thread(kthread, your_kthread_create_info, ...) 

Y la función kthread sí lo hace:

kthread 
    -> initialization stuff 
    -> schedule() // allows you to cancel the thread before it's actually started 
    -> if (!should_stop) 
    -> ret = your_thread_function() 
    -> do_exit(ret) 

... Así que si your_thread_function simplemente retorna, do_exit será llamada con su valor de retorno. No es necesario que lo hagas tú mismo.