À l'origine, il fait partie du code source du noyau Linux, il sera donc traité comme GPLv2 (reconnaissance qu'il devrait l'être).
https://www.kernel.org/doc/html/latest/index.html
Licensing documentation
The following describes the license of the Linux kernel source code (GPLv2), how to properly mark the license of individual files in the source tree, as well as links to the full license text.
https://www.kernel.org/doc/html/latest/process/license-rules.html#kernel-licensing
https://www.kernel.org/doc/html/latest/power/freezing-of-tasks.html
Docs » Power Management » Freezing of tasks
Freezing of tasks 2007 Rafael J. Wysocki ＜rjw＠sisk.pl＞, GPL
The freezing of tasks is a mechanism by which user space processes and some kernel threads are controlled during hibernation or system-wide suspend (on some architectures).
Le gel des tâches est le contrôle des processus de l'espace utilisateur et de certains threads du noyau pendant l'hibernation ou le syspend à l'échelle du système (dans certaines architectures).
There are three per-task flags used for that, PF_NOFREEZE, PF_FROZEN and PF_FREEZER_SKIP (the last one is auxiliary).
Trois types d'indicateurs de tâche de tâche sont utilisés. PF_NOFREEZE, PF_FROZEN, PF_FREEZER_SKIP (le dernier est auxiliaire).
The tasks that have PF_NOFREEZE unset (all user space processes and some kernel threads) are regarded as ‘freezable’ and treated in a special way before the system enters a suspend state as well as before a hibernation image is created
Les tâches (tous les processus de l'espace utilisateur et certains threads du noyau) pour lesquelles PF_NOFREEZE n'est pas défini sont considérées comme "gelables". Ils sont traités d'une manière spéciale avant que le système ne passe à l'état syspend avant de générer l'image d'hibernation.
(in what follows we only consider hibernation, but the description also applies to suspend).
(Dans ce qui suit, seule la mise en veille prolongée est prise en compte, mais la description peut également être appliquée pour suspendre.)
.
Namely, as the first step of the hibernation procedure the function freeze_processes() (defined in kernel/power/process.c) is called.
Autrement dit, la fonction freeze_processes () est appelée comme première étape de la procédure d'hibernation (comme décrit dans kernel / power / process.c).
A system-wide variable system_freezing_cnt (as opposed to a per-task flag) is used to indicate whether the system is to undergo a freezing operation.
La variable système system_freezing_cnt (plutôt que l'indicateur par tâche) est utilisée pour indiquer si le système subit une opération de gel.
And freeze_processes() sets this variable.
freeze_processes () définit cette variable.
After this, it executes try_to_freeze_tasks() that sends a fake signal to all user space processes, and wakes up all the kernel threads.
Après cela, try_to_freeze_tasks () est exécuté pour envoyer un pseudo signal à tous les processus de l'espace utilisateur et à tous les threads du noyau.
All freezable tasks must react to that by calling try_to_freeze(), which results in a call to __refrigerator() (defined in kernel/freezer.c), which sets the task’s PF_FROZEN flag, changes its state to TASK_UNINTERRUPTIBLE and makes it loop until PF_FROZEN is cleared for it.
Toutes les tâches gelables doivent réagir en appelant try_to_freeze (). Cela définit l'indicateur PF_FROZEN de la tâche, change l'état de la tâche en TASK_UNTERRRUPTIBLE et effectue une boucle jusqu'à ce que PF_FROZEN soit effacé.
Then, we say that the task is ‘frozen’ and therefore the set of functions handling this mechanism is referred to as ‘the freezer’
Et comme la tâche est "gelée", l'ensemble des fonctions qui gèrent ce mécanisme est appelé "le congélateur".
(these functions are defined in kernel/power/process.c, kernel/freezer.c & include/linux/freezer.h).
(Ces fonctions sont décrites dans kernel / power / process.c, kernel / freezer.c et include / linux / freezer.h)
User space processes are generally frozen before kernel threads
Les processus spatiaux utilisateur sont fondamentalement figés avant le thread du noyau. ..
.
__refrigerator() must not be called directly.
Vous ne pouvez pas appeler __refrigerator () directement.
Instead, use the try_to_freeze() function (defined in include/linux/freezer.h), that checks if the task is to be frozen and makes the task enter __refrigerator().
À la place, utilisez la fonction try_yo_freeze () (définie dans include / linux / freezer.h), qui vérifie si la tâche doit être supervisée et si la tâche passe à __refrigerator (). Faire.
.
For user space processes try_to_freeze() is called automatically from the signal-handling code, but the freezable kernel threads need to call it explicitly in suitable places or use the wait_event_freezable() or wait_event_freezable_timeout() macros (defined in include/linux/freezer.h) that combine interruptible sleep with checking if the task is to be frozen and calling try_to_freeze().
Dans les processus de l'espace utilisateur, try_yo_freeze () est automatiquement appelée à partir du code de gestion du signal. Cependant, le thread du noyau congelable doit être explicitement appelé sur place ou utiliser la macro wait_event_freezable () ou wait_event_freezable_timeout () (définie dans include / linux / freezer.h). Il s'agit d'une macro de sommeil interruptible qui détermine si une tâche doit se figer et s'il faut appeler try_to_freeze ().
The main loop of a freezable kernel thread may look like the following one:
Le looop principal du thread du noyau congelable a la forme suivante.
set_freezable();
do {
hub_events();
wait_event_freezable(khubd_wait,
!list_empty(&hub_event_list) ||
kthread_should_stop());
} while (!kthread_should_stop() || !list_empty(&hub_event_list));
(from drivers/usb/core/hub.c::hub_thread()).
If a freezable kernel thread fails to call try_to_freeze() after the freezer has initiated a freezing operation, the freezing of tasks will fail and the entire hibernation operation will be cancelled.
Le thread freezablekernel échouera si vous appelez try_to_freeze () après que le congélateur ait initialisé le processus de gel. Le gel de la tâche échoue et la transition vers le traitement d'hibernation est annulée.
For this reason, freezable kernel threads must call try_to_freeze() somewhere or use one of the wait_event_freezable() and wait_event_freezable_timeout() macros.
Pour cette raison, le thread du noyau congelable doit soit appeler try_to_freeze () sur l'un d'entre eux, soit utiliser l'une des macros wait_event_freezable () et wait_event_freezable_timeout ().
.
After the system memory state has been restored from a hibernation image and devices have been reinitialized, the function thaw_processes() is called in order to clear the PF_FROZEN flag for each frozen task. Then, the tasks that have been frozen leave __refrigerator() and continue running.
Lorsque l'état de la mémoire système est restauré à partir de l'image d'hibernation et que le périphérique peut être réinitialisé, thaw_processes () est appelée. Cela efface l'indicateur PF_FROZEN pour chaque tâche gelée. Par conséquent, la tâche est séparée de __refrigerator () et peut continuer à être traitée. ..
Rationale behind the functions dealing with freezing and thawing of tasks
La relation entre le gel et la décongélation des tâches est la suivante.
freeze_processes():
freezes only userspace tasks
Figer uniquement les tâches de l'espace utilisateur.
freeze_kernel_threads():
freezes all tasks (including kernel threads) because we can’t freeze kernel threads without freezing userspace tasks
Figer toutes les tâches, y compris le thread du noyau. En effet, les tâches de l'espace utilisateur ne peuvent pas être figées et les threads du noyau ne peuvent pas être figés.
thaw_kernel_threads():
thaws only kernel threads; this is particularly useful if we need to do anything special in between thawing of kernel threads and thawing of userspace tasks, or if we want to postpone the thawing of userspace tasks
Restaurez le thread du noyau. Ceci est utile si vous voulez faire quelque chose de spécial entre la décompression d'un thread du noyau et la décompression d'une tâche de l'espace utilisateur, ou si vous souhaitez différer la décompression d'une tâche de l'espace utilisateur.
thaw_processes():
thaws all tasks (including kernel threads) because we can’t thaw userspace tasks without thawing kernel threads
Répondez à toutes les tâches, y compris le thread du noyau. En effet, les tâches de l'espace utilisateur ne peuvent pas être décompressées sans décompresser le thread du noyau.
Kernel threads are not freezable by default.
Le thread du noyau n'est pas figeable par défaut.
However, a kernel thread may clear PF_NOFREEZE for itself by calling set_freezable() (the resetting of PF_NOFREEZE directly is not allowed).
Cependant, le thread du noyau peut effacer son propre PF_NOFREEZE en appelant set_freezable (). (La réinitialisation directe de PF_NOFREEZE n'est pas autorisée).
From this point it is regarded as freezable and must call try_to_freeze() in a suitable place.
À partir de ce moment, il est considéré comme gelable et vous devez appeler try_to_freeze () à l'endroit approprié.
.
Generally speaking, there is a couple of reasons to use the freezing of tasks:
De manière générale, il existe plusieurs raisons pour lesquelles vous devriez utiliser le gel des tâches.
.
The principal reason is to prevent filesystems from being damaged after hibernation.
La raison principale est d'éviter d'endommager le système de fichiers après l'hibernation.
At the moment we have no simple means of checkpointing filesystems, so if there are any modifications made to filesystem data and/or metadata on disks, we cannot bring them back to the state from before the modifications.
Pour le moment, il n'existe aucun moyen simple de définir un point de contrôle du système de fichiers. Par conséquent, si vous apportez des modifications aux données ou aux métadonnées sur le disque, vous ne pouvez pas les restaurer à leur état d'origine.
At the same time each hibernation image contains some filesystem-related information that must be consistent with the state of the on-disk data and metadata after the system memory state has been restored from the image
À ce stade, chaque image d'hibernation contient des informations relatives au système de fichiers qui doivent correspondre à l'état des données et des métadonnées sur le disque une fois l'état de la mémoire système restauré à partir de l'image.
(otherwise the filesystems will be damaged in a nasty way, usually making them almost impossible to repair).
(Sinon, le système de fichiers est endommagé de manière lourde et est généralement presque impossible à récupérer).
We therefore freeze tasks that might cause the on-disk filesystems’ data and metadata to be modified after the hibernation image has been created and before the system is finally powered off.
Par conséquent, une image d'hibernation est créée pour figer les tâches potentiellement modifiables dans les données et métadonnées du système de fichiers sur le disque avant que le système ne soit finalement mis hors tension.
The majority of these are user space processes, but if any of the kernel threads may cause something like this to happen, they have to be freezable.
Beaucoup d'entre eux sont des processus de l'espace utilisateur, mais ils peuvent également être figés si vous avez un thread du noyau qui fait quelque chose qui provoque cela.
.
Next, to create the hibernation image we need to free a sufficient amount of memory (approximately 50% of available RAM) and we need to do that before devices are deactivated, because we generally need them for swapping out.
Deuxièmement, vous devez libérer suffisamment de mémoire pour créer une image d'hibernation (environ 50% de la RAM disponible). Cela doit être fait avant de désactiver l'appareil. Parce qu'il est nécessaire d'échanger.
Then, after the memory for the image has been freed, we don’t want tasks to allocate additional memory and we prevent them from doing that by freezing them earlier.
Par conséquent, une fois la mémoire de l'image libérée, elle est empêchée en se figeant plus tôt afin que la tâche ne demande pas plus de mémoire.
[Of course, this also means that device drivers should not allocate substantial amounts of memory from their .suspend() callbacks before hibernation, but this is a separate issue.]
[Bien sûr, cela signifie que vous ne devriez pas allouer beaucoup de mémoire à chaque rappel suspend () avant que le pilote de périphérique ne passe en veille prolongée. Ceci est une autre affaire] .
The third reason is to prevent user space processes and some kernel threads from interfering with the suspending and resuming of devices.
La troisième raison est de s'assurer que les processus de l'espace utilisateur et certains threads du noyau n'interfèrent pas avec la suspension et la reprise des périphériques.
A user space process running on a second CPU while we are suspending devices may, for example, be troublesome and without the freezing of tasks we would need some safeguards against race conditions that might occur in such a case.
Par exemple, un processus de l'espace utilisateur exécuté sur un deuxième processeur peut être gênant lors de la tentative de suspension d'un périphérique. Sans geler la tâche, vous avez besoin d'une protection contre les conditions conflictuelles qui provoquent de tels cas.
.
Although Linus Torvalds doesn’t like the freezing of tasks, he said this in one of the discussions on LKML (http://lkml.org/lkml/2007/4/27/608):
Linus Torvalds déteste les tâches gelées. J'ai mentionné cela dans l'une des discussions sur LKML (http://lkml.org/lkml/2007/4/27/608)
.
«RJW:> Pourquoi geler les tâches ou pourquoi geler les threads du noyau?» (Pourquoi geler toutes les tâches ou pourquoi geler les threads du noyau?)
Linus: À bien des égards, «pas du tout» (souvent «tous») I do realize the IO request queue issues, and that we cannot actually do s2ram with some devices in the middle of a DMA.
Je comprends le problème de la demande d'E / S. En outre, vous ne pouvez pas s2ram avec un périphérique au milieu de DMA.
So we want to be able to avoid that, there’s no question about that.
Il n'y a donc aucun doute à ce sujet pour éviter cela.
And I suspect that stopping user threads and then waiting for a sync is practically one of the easier ways to do so.
Et arrêter le thread utilisateur puis attendre la synchronisation est en fait l'un des moyens les plus simples.
So in practice, the ‘at all’ may become a ‘why freeze kernel threads?’ and freezing user threads I don’t find really objectionable.”
Donc, en réalité, "du tout" devient "pourquoi geler le fil du noyau" et gèle le fil de l'utilisateur, ce que je ne trouve pas vraiment déplaisant.
.
Still, there are kernel threads that may want to be freezable.
Pourtant, j'ai un thread de noyau que je veux être gelable.
For example, if a kernel thread that belongs to a device driver accesses the device directly, it in principle needs to know when the device is suspended, so that it doesn’t try to access it at that time.
Par exemple, si le thread du noyau appartient au pilote de périphérique et accède directement au périphérique, vous devez savoir s'il est temps que le périphérique entre en mode suspension et vous ne devez pas accéder au périphérique à ce stade.
However, if the kernel thread is freezable, it will be frozen before the driver’s .suspend() callback is executed and it will be thawed after the driver’s .resume() callback has run, so it won’t be accessing the device while it’s suspended.
Cependant, si le thread du noyau est gelable, il sera gelé avant que le rappel suspend () du pilote ne soit exécuté. Il sera ensuite répondu avant que le rappel du pilote resume () ne soit exécuté. L'accès à l'appareil mourra pendant la suspension.
Another reason for freezing tasks is to prevent user space processes from realizing that hibernation (or suspend) operation takes place.
Une autre raison de geler une tâche est de rendre le processus de l'espace utilisateur ignorant que le traitement d'hibernation (ou de suspension) est en cours.
Ideally, user space processes should not notice that such a system-wide operation has occurred and should continue running without any problems after the restore (or resume from suspend).
Idéalement, les processus de l'espace utilisateur devraient pouvoir continuer à fonctionner sans problème après une restauration (ou une reprise après une suspension) sans savoir qu'une telle opération à l'échelle du système est en cours.
Unfortunately, in the most general case this is quite difficult to achieve without the freezing of tasks.
Malheureusement, dans les cas les plus courants, il est très difficile d'y parvenir sans geler la tâche. ..
Consider, for example, a process that depends on all CPUs being online while it’s running.
Par exemple, considérons un processus qui dépend de tous les processeurs qui s'exécutent en ligne.
Since we need to disable nonboot CPUs during the hibernation, if this process is not frozen, it may notice that the number of CPUs has changed and may start to work incorrectly because of that.
Si vous souhaitez arrêter un processeur qui ne démarre pas pendant l'hibernation, vous ne pouvez pas geler ce processus. Il remarquera que le nombre de processeurs a changé et ne fonctionnera pas correctement.