Comment Linux détermine-t-il le PID suivant?
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 pid sont attribués de manière séquentielle, comment Linux comble-t-il les lacunes? Que se passe-t-il quand ça touche la fin?
par exemple, si je lance un script PHP à partir D'Apache qui fait un <?php print(getmypid());?> , le même PID sera imprimé pendant quelques minutes pendant que je clique sur refresh. Cette période de temps est une fonction du nombre de demandes de apache. Même s'il n'y a qu'un seul client, le PID finira par changer.
quand le PID change,ce sera un nombre proche, mais à quel point? Le numéro ne semble pas être entièrement séquentiel. Si je fais un ps aux | grep apache j'obtiens un bon nombre de processus:
comment Linux choisit-il ce numéro suivant? Quelques PID sont toujours en cours d'exécution, ainsi que le PID le plus récent qui a été imprimé. Comment apache choisit-il de réutiliser ces pid?
4 réponses
le noyau attribue les pid dans la gamme de (RESERVED_PIDS, PID_MAX_DEFAULT). Il le fait de manière séquentielle dans chaque namespace (les tâches dans différents namespaces peuvent avoir les mêmes IDs). Dans le cas où la portée est épuisée, l'assignation de pid s'enroule.
Certains pertinentes du code:
à l'Intérieur de 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 pid dans le contexte du noyau sont plus que des identificateurs int ; la structure pertinente se trouve dans /include/linux/pid.h . En plus de l'id, il contient une liste de tâches avec cet id, un compteur de référence et un noeud 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 parce que la programmation du noyau peut bifurquer un processus entre les appels fork() de votre processus. Il est très commun, en fait.
je préférerais supposer que le comportement que vous regardez provient d'une autre source :
bons serveurs web ont généralement plusieurs instances de processus pour équilibrer la charge des demandes. Ces processus sont gérés dans une piscine et d'une demande chaque fois qu'une demande est en. Pour optimiser les performances, Apache assigne probablement le même processus à un ensemble de requêtes séquentielles du même client. Après une certaine quantité de demandes qui processus est terminé et un nouveau est créé.
Je ne crois pas que plus d'un processus en séquence se voient attribuer le même PID par linux.
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 surgissent et qui se terminent tout le temps en arrière-plan par des applications et des programmes système, donc vous ne pouvez pas prédire le nombre exact d'apache le processus commence ensuite.
en dehors de cela, vous devriez et non utiliser n'importe quelle hypothèse au sujet de l'assignation PID comme base pour quelque chose que vous mettez en œuvre. (Voir Aussi Le Commentaire de sanmai.)
Pid séquentielles sur la plupart des systèmes. Vous pouvez le voir en démarrant plusieurs processus par vous-même sur la machine inactive.
p.ex. utiliser l'historique flèche haut pour lancer à plusieurs reprises une commande qui imprime son propre PID:
$ ls -l /proc/self
lrwxrwxrwx 1 root root 0 Mar 15 19:32 /proc/self -> 21491
$ ls -l /proc/self
lrwxrwxrwx 1 root root 0 Mar 15 19:32 /proc/self -> 21492
$ ls -l /proc/self
lrwxrwxrwx 1 root root 0 Mar 15 19:32 /proc/self -> 21493
$ ls -l /proc/self
lrwxrwxrwx 1 root root 0 Mar 15 19:32 /proc/self -> 21494
ne dépend pas de cela: pour des raisons de sécurité, certaines personnes exécutent des noyaux qui passent du temps CPU supplémentaire pour choisir au hasard de nouveaux PIDs.
peuvent être attribués au hasard. Il y a un certain nombre de façons pour accomplir cela.