linux kernel - know - Módulo Kernel que itera sobre todas las tareas utilizando el primer árbol de profundidad

kernel linux

Question

Así que sé cómo crear un kernel e iterar sobre los procesos linealmente con Simply incluyendo linux/sched.h y usando el siguiente código:

struct task_struct *task;

for_each_process(task)
{
   printk("Name: %s PID: [%d]/n", task->comm, task->pid);
}

¿Cómo puedo imprimir estas tareas usando una primera búsqueda de profundidad? Quiero que mi salida sea similar a la de ps -eLf .

El siguiente parche de código se ha proporcionado como referencia:

struct task_struct *task;
struct list_head *list;
list_for_each(list, &init_task->children) {
    task = list_entry(list, struct task_struct, sibling);
    /* task points to the next child in the list */
}

y sé que task->comm devuelve el nombre y task->pid devuelve el PID para esa tarea.

¿Qué comandos se utilizan para devolver el estado y el padre pid?

Answer 1

puede obtener el estado con task->state /* -1 unrunnable, 0 runnable, >0 stopped */

obtener el padre pid con task->parent->pid

Answer 2

Para uid, tgid puede referir estructura de credito en task_struct. Para prioridad, puede consultar rt_priority (para prioridad en tiempo real) y campo prio. Para otros campos, puede referirse al directorio de proc (porque ps tomará la entrada de proc).

Answer 3

Esto es un poco viejo, pero lo encontré ya que parece ser uno de los proyectos de programación que se encuentran en el capítulo 3 de la novena edición de Conceptos de sistema operativo , por lo que otros pueden llegar a aparecer.

El código con el que comenzó es directo del libro, pero es un buen punto de partida. Solo necesita implementar el DFS. Aquí está el código que lo logrará, debería ser bastante auto explicativo:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/init.h>

/**
 * Performs a DFS on a given task''s children.
 *
 * @void
 */
void DFS(struct task_struct *task)
{   
    struct task_struct *child;
    struct list_head *list;

    printk("name: %s, pid: [%d], state: %li/n", task->comm, task->pid, task->state);
    list_for_each(list, &task->children) {
        child = list_entry(list, struct task_struct, sibling);
        DFS(child);
    }
}

/**
 * This function is called when the module is loaded. 
 *
 * @return 0  upon success
 */ 
int task_lister_init(void)
{
    printk(KERN_INFO "Loading Task Lister Module.../n");
    DFS(&init_task);

    return 0;
}

/**
 * This function is called when the module is removed.
 *
 * @void
 */
void task_lister_exit(void)
{
    printk(KERN_INFO "Removing Task Lister Module.../n");
}

// Macros for registering module entry and exit points.
module_init(task_lister_init);
module_exit(task_lister_exit);