À 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
Oui, il y en a. (Oui, il y en a)
.
First of all, the freezing of kernel threads may be tricky if they depend one on another.
Tout d'abord, geler le thread du noyau peut être délicat si vous demandez autre chose.
For example, if kernel thread A waits for a completion (in the TASK_UNINTERRUPTIBLE state) that needs to be done by freezable kernel thread B and B is frozen in the meantime, then A will be blocked until B is thawed, which may be undesirable. Par exemple, si le thread du noyau A attend la fin du thread du noyau gelable B (dans l'état TASK_UNINTERRUPTIBLE) et que B se bloque entre-temps, A sera bloqué jusqu'à ce que B soit décongelé, ce qui serait indésirable.
That’s why kernel threads are not freezable by default.
C'est pourquoi le thread du noyau ne le rend pas gelable par défaut.
.
Second, there are the following two problems related to the freezing of user space processes:
Ensuite, il y a deux raisons liées au gel des processus de l'espace utilisateur.
.
Putting processes into an uninterruptible sleep distorts the load average.
Mettre le processus en veille ininterrompue déformera la charge moyenne.
Now that we have FUSE, plus the framework for doing device drivers in userspace, it gets even more complicated because some userspace processes are now doing the sorts of things that kernel threads do (https://lists.linux-foundation.org/pipermail/linux-pm/2007-May/012309.html).
Actuellement, il existe FUSE et, en plus, un framework pour exécuter des pilotes de périphériques dans l'espace utilisateur. Ceci est encore compliqué par le fait que certains processus de l'espace utilisateur effectuent le type de traitement que le thread du noyau effectue. (https://lists.linux-foundation.org/pipermail/linux-pm/2007-May/012309.html)
The problem 1. seems to be fixable, although it hasn’t been fixed so far.
Le problème 1 semble pouvoir être résolu, mais il ne l'est pas.
The other one is more serious, but it seems that we can work around it by using hibernation (and suspend) notifiers
L'autre est un problème plus grave, mais cela peut être évité en utilisant la solution de contournement utilisée dans les notificateurs d'hibernation (et de suspension).
(in that case, though, we won’t be able to avoid the realization by the user space processes that the hibernation is taking place).
(Cependant, dans ce cas, la réalisation ne peut être évitée par le processus de l'espace utilisateur dans lequel l'hibernation a lieu).
.
There are also problems that the freezing of tasks tends to expose, although they are not directly related to it.
Il existe également un problème qui n'est pas directement lié aux blocages de tâches, mais qui est plus susceptible de devenir apparent en raison des blocages de tâches.
For example, if request_firmware() is called from a device driver’s .resume() routine, it will timeout and eventually fail, because the user land process that should respond to the request is frozen at this point.
Par exemple, si request_firmware () est appelé à partir de la routine resume () du pilote de périphérique, il expirera et finira par échouer. Parce que le processus de l'espace utilisateur qui doit répondre à cette demande est gelé à ce stade.
So, seemingly, the failure is due to the freezing of tasks.
Ainsi, à première vue, la cause de l'échec est la tâche gelée.
Suppose, however, that the firmware file is located on a filesystem accessible only through another device that hasn’t been resumed yet.
Cependant, le fichier du micrologiciel se trouve dans le système de fichiers. Le système de fichiers n'est accessible que via un autre appareil qui n'a pas terminé la reprise.
In that case, request_firmware() will fail regardless of whether or not the freezing of tasks is used.
Dans ce cas, request_firmware () échouera indépendamment du fait que le gel des tâches soit utilisé.
Consequently, the problem is not really related to the freezing of tasks, since it generally exists anyway.
En conséquence, des problèmes surviennent généralement et ne sont pas liés à des blocages de tâches.
.
A driver must have all firmwares it may need in RAM before suspend() is called.
Le pilote doit avoir tout le micrologiciel dans la RAM avant que suspend () ne soit appelé.
If keeping them is not practical, for example due to their size, they must be requested early enough using the suspend notifier API described in Documentation/driver-api/pm/notifiers.rst.
Par exemple, s'il n'est pas pratique de conserver sa taille, vous devez faire une demande précoce en utilisant l'API suspend notifier (voir Documentation / driver-api / pm / notifiers.rst).
Oui, il y en a. (Oui, il y en a)
.
First of all, grabbing the ‘system_transition_mutex’ lock to mutually exclude a piece of code from system-wide sleep such as suspend/hibernation is not encouraged.
Il n’est pas recommandé d’obtenir d’abord le verrou ‘system_transition_mutex’, puis d’exclure le code l’un de l’autre du mode veille à l’échelle du système, comme la suspension / veille prolongée.
If possible, that piece of code must instead hook onto the suspend/hibernation notifiers to achieve mutual exclusion.
Si possible, à la place, vous devez passer par des notificateurs de suspension / hibernation pour obtenir une exclusion mutuelle.
Look at the CPU-Hotplug code (kernel/cpu.c) for an example.
Voir le code CPU-Hotplug (kernel / cpu.c) pour un exemple.
.
However, if that is not feasible, and grabbing ‘system_transition_mutex’ is deemed necessary, it is strongly discouraged to directly call mutex_[un]lock(&system_transition_mutex) since that could lead to freezing failures,
Cependant, si cela n’est pas possible et que vous pensez avoir besoin d’obtenir ‘system_transition_mutex’, n’appelez pas directement mutex_ [un] lock (& system_transition_mutex). Un échec de gel peut se produire.
because if the suspend/hibernate code successfully acquired the ‘system_transition_mutex’ lock, and hence that other entity failed to acquire the lock, then that task would get blocked in TASK_UNINTERRUPTIBLE state.
Parce que si le code suspend / hibernate obtient le verrou ‘system_transition_mutex’ avec succès, aucune autre entité ne peut obtenir le verrou et la tâche sera bloquée dans l’état TASK_UNINTERRUPTIBLE.
As a consequence, the freezer would not be able to freeze that task, leading to freezing failure.
En conséquence, le congélateur ne peut pas geler la tâche, ce qui entraîne un échec de gel.
.
However, the [un]lock_system_sleep() APIs are safe to use in this scenario, since they ask the freezer to skip freezing this task, since it is anyway “frozen enough” as it is blocked on ‘system_transition_mutex’, which will be released only after the entire suspend/hibernation sequence is complete.
Cependant, pour ce scénario, l'API [un] lock_system_sleep () peut être utilisée en toute sécurité. Demandez au congélateur de sauter le gel pour cette tâche. Le system_transition_mutex est de toute façon bloqué et suffisamment gelé (frozon enogh), il sera donc libéré une fois la séquence de suspension / hibernation terminée.
So, to summarize, use [un]lock_system_sleep() instead of directly using mutex_[un]lock(&system_transition_mutex). That would prevent freezing failures.
Donc, en résumé, au lieu d'utiliser directement mutex_ [un] lock (& system_transition_mutex), utilisez [un] lock_system_sleep (). Cela évite les pannes de gel.
/sys/power/pm_freeze_timeout controls how long it will cost at most to freeze all user space processes or all freezable kernel threads, in unit of millisecond.
/ sys / power / pm_freeze_timeout contient des informations sur le coût maximum requis pour geler tous les processus de l'espace utilisateur et tous les threads du noyau gelables. L'unité est la milliseconde.
The default value is 20000, with range of unsigned integer.
La valeur par défaut est 20000 et la plage est un entier non défini.