Comment Linux détermine-t-il le prochain PID ?

Question

Comment Linux détermine-t-il le prochain PID qu'il utilisera pour un processus ? Le but de cette question est de mieux comprendre le noyau Linux. N'ayez pas peur de poster le code source du noyau. Si les PIDs sont alloués séquentiellement, comment Linux remplit-il les vides ? Que se passe-t-il quand il arrive à la fin ?

Par exemple, si je lance un script PHP depuis Apache qui fait un <?php print(getmypid());?> le même PID sera imprimé pendant quelques minutes en appuyant sur rafraîchir. Cette période de temps est fonction du nombre de requêtes qu'apache reçoit. Même s'il n'y a qu'un seul client, le PID finira par changer.

Lorsque le PID change, ce sera un chiffre proche, mais proche comment ? Le numéro ne semble pas être entièrement séquentiel. Si je fais un ps aux | grep apache Je reçois un bon nombre de processus :

Comment Linux choisit-il ce prochain numéro ? Les quelques PID précédents sont toujours en cours, ainsi que le PID le plus récent qui a été imprimé. Comment Apache choisit-il de réutiliser ces PID ?

Answer 1

Le noyau alloue des PIDs dans la plage de (RESERVED_PIDS, PID_MAX_DEFAULT). Il le fait séquentiellement dans chaque espace de noms (les tâches de différents espaces de noms peuvent avoir les mêmes ID). Dans le cas où la plage est épuisée, l'attribution des pids se poursuit.

Quelques codes pertinents :

Dans alloc_pid(...)

for (i = ns->level; i >= 0; i--) {
    nr = alloc_pidmap(tmp);
    if (nr < 0)
        goto out_free;
    pid->numbers[i].nr = nr;
    pid->numbers[i].ns = tmp;
    tmp = tmp->parent;
}

alloc_pidmap()

static int alloc_pidmap(struct pid_namespace *pid_ns)
{
        int i, offset, max_scan, pid, last = pid_ns->last_pid;
        struct pidmap *map;

        pid = last + 1;
        if (pid >= pid_max)
                pid = RESERVED_PIDS;
        /* and later on... */
        pid_ns->last_pid = pid;
        return pid;
}

Notez que les PIDs dans le contexte du noyau sont plus que de simples int les identifiants ; la structure correspondante se trouve dans /include/linux/pid.h . Outre l'identifiant, il contient une liste de tâches avec cet identifiant, un compteur de référence et un nœud de liste hachée pour un accès rapide.

La raison pour laquelle les PID n'apparaissent pas séquentiels dans l'espace utilisateur est que l'ordonnancement du noyau peut bifurquer un processus entre votre processus et celui de l'utilisateur. fork() appels. C'est très courant, en fait.

Answer 2

Je préfère supposer que le comportement que vous observez provient d'une autre source :

Les bons serveurs web ont généralement plusieurs instances de processus pour équilibrer la charge des demandes. Ces processus sont gérés dans un pool et affectés à une certaine demande à chaque fois qu'une requête arrive. Pour optimiser les performances, Apache affecte probablement le même processus à un ensemble de requêtes séquentielles provenant du même client. Après un certain nombre de demandes, le processus est arrêté et un nouveau processus est créé.

Je ne crois pas que linux attribue le même PID à plus d'un processus en séquence.

Comme vous dites que le nouveau PID sera proche du dernier, je suppose que Linux attribue simplement à chaque processus le dernier PID + 1. Mais il y a des processus qui apparaissent et sont terminés tout le temps en arrière-plan par des applications et des programmes système, donc vous ne pouvez pas prédire le numéro exact du processus apache qui sera lancé ensuite.

En outre, vous devez pas utiliser toute hypothèse sur l'affectation PID comme base pour quelque chose que vous implémentez. (Voir aussi le commentaire de sanmai).

Answer 3

PIDs sont séquentiels . Vous pouvez le constater en démarrant vous-même plusieurs processus sur une machine inactive.

Answer 4

Les PID peuvent être attribués de manière aléatoire. Il y a de plusieurs façons pour y parvenir.