Effiziente Möglichkeit, task_struct nach PID zu finden

Gibt es eine effiziente Möglichkeit, die zu finden task_struct für eine angegebene PID, ohne Iteration durch die task_struct aufführen?

Was ist falsch daran, eines der folgenden zu verwenden?

extern struct task_struct *find_task_by_vpid(pid_t nr);
extern struct task_struct *find_task_by_pid_ns(pid_t nr,
            struct pid_namespace *ns);

Wenn Sie die finden möchten task_struct aus einem Modul, find_task_by_vpid(pid_t nr) usw. funktionieren nicht, da diese Funktionen nicht exportiert werden.

In einem Modul können Sie stattdessen die folgende Funktion verwenden:

pid_task(find_vpid(pid), PIDTYPE_PID);

Es gibt einen besseren Weg, um die Instanz von task_struct aus einem Modul abzurufen. Versuchen Sie immer, Wrapper-Funktionen/Hilfsroutinen zu verwenden, da sie so konzipiert sind, dass der Kernel sich selbst darum kümmern kann, wenn der Treiberprogrammierer etwas übersehen hat. Für zB – Fehlerbehandlung, Zustandsprüfungen etc.

/* Use below API and you will get a pointer of (struct task_struct *) */

taskp = get_pid_task(pid, PIDTYPE_PID);

und um die PID vom Typ pid_t zu erhalten. Sie müssen die folgende API verwenden –

find_get_pid(pid_no);

Sie brauchen nicht “rcu_read_lock()” und “rcu_read_unlock()” beim Aufrufen dieser APIs, weil “get_pid_task()” ruft intern rcu_read_lock(), rcu_read_unlock() vor dem Aufruf auf “pid_task()” und handhabt Parallelität richtig. Deshalb habe ich oben gesagt, verwenden Sie immer diese Art von Wrapper.

Ausschnitt der Funktion get_pid_task() und find_get_pid() unten:-

struct task_struct *get_pid_task(struct pid *pid, enum pid_type type)
{
    struct task_struct *result;
    rcu_read_lock();
    result = pid_task(pid, type);
    if (result)
        get_task_struct(result);
    rcu_read_unlock();
    return result;
}
EXPORT_SYMBOL_GPL(get_pid_task);

struct pid *find_get_pid(pid_t nr)
{
    struct pid *pid;

    rcu_read_lock();
    pid = get_pid(find_vpid(nr));
    rcu_read_unlock();

    return pid;
}
EXPORT_SYMBOL_GPL(find_get_pid);

In einem Kernel-Modul können Sie die Wrapper-Funktion auch auf folgende Weise verwenden –

taskp = get_pid_task(find_get_pid(PID),PIDTYPE_PID);

PS: Weitere Informationen zu APIs finden Sie unter kernel/pid.c

Niemand hat erwähnt, dass die pid_task() Funktion und die Zeiger (die Sie daraus erhalten) verwendet werden im kritischen Abschnitt der RCU (weil es eine RCU-geschützte Datenstruktur verwendet). Andernfalls Es kann geben Use-after-free BUG.
Es gibt viele Anwendungsfälle pid_task() in Linux-Kernel-Quellen (zB in posix_timer_event()).
Zum Beispiel:

rcu_read_lock();
/* search through the global namespace */
task = pid_task(find_pid_ns(pid_num, &init_pid_ns), PIDTYPE_PID);
if (task)
    printk(KERN_INFO "1. pid: %d, state: %#lx\n",
           pid_num, task->state); /* valid task dereference */
rcu_read_unlock(); /* after it returns - task pointer becomes invalid! */

if (task)
    printk(KERN_INFO "2. pid: %d, state: %#lx\n",
           pid_num, task->state); /* may be successful,
                                   * but is buggy (task dereference is INVALID!) */

Erfahren Sie mehr über die RCU-API unter Kernel.org

PS auch Sie können einfach die speziellen API-Funktionen wie verwenden find_task_by_pid_ns() und find_task_by_vpid() unter dem rcu_read_lock().

Der erste dient zum Durchsuchen des jeweiligen Namensraums:

task = find_task_by_pid_ns(pid_num, &init_pid_ns); /* e.g. init namespace */

Der zweite dient zum Durchsuchen des Namensraums von current Aufgabe.