:Technologie de gel des processus Linux : rendez votre système plus stable

Avez-vous déjà rencontré divers problèmes lorsque votre système est en veille ? Par exemple, le système de fichiers est endommagé, la création d'une image d'hibernation échoue, la suspension du périphérique est anormale, etc. Ces problèmes peuvent être résolus grâce à la technologie de gel des processus Linux.

1. La technologie de gel des processus (gel des tâches) consiste à placer les processus utilisateur et certains threads du noyau dans un état de pause « contrôlable » lorsque le système hiberne ou se suspend.
2. Sans technologie de gel, le processus peut être suspendu à tout moment planifiable et ne sera pas suspendu ni migré avant cpu_down. Cela peut causer de nombreux problèmes au système :
   1. Il est possible de corrompre le système de fichiers. Entre le système créant l'image de mise en veille prolongée et le processeur en panne, s'il y a des processus qui modifient encore le contenu du système de fichiers, cela empêchera le système de fichiers d'être complètement restauré une fois le système restauré ; Cela peut entraîner l’échec de la création de l’image d’hibernation. La création d'une image d'hibernation nécessite suffisamment d'espace mémoire, mais s'il y a encore des processus demandant de la mémoire pendant cette période, la création peut échouer
   2.  ; Il est possible d'interférer avec la suspension et la reprise de l'appareil. Avant que le processeur ne soit en panne, pendant la suspension de l'appareil, si le processus accède toujours à l'appareil, en particulier aux ressources concurrentes, cela peut provoquer une exception de suspension de l'appareil
   3.  ; Cela peut amener le processus à détecter l’hibernation du système. L'état idéal de l'hibernation du système est que toutes les tâches ignorent le processus d'hibernation et reprennent automatiquement leur travail après le réveil. Cependant, certains processus, comme un certain processus, nécessitent que tous les processeurs soient en ligne pour fonctionner correctement. geler, cela fonctionnera anormalement.
   Les objets gelés sont des entités du noyau dont l'exécution peut être planifiée, notamment les processus utilisateur, les threads du noyau et work_queue. Les processus utilisateur peuvent être gelés par défaut, ce qui est implémenté en empruntant le mécanisme de traitement du signal ; les threads du noyau et work_queue ne peuvent pas être gelés par défaut. Quelques threads du noyau et work_queue spécifient l'indicateur freezeable lors de leur création. Lorsque le système entre en gel, l'opération est automatiquement suspendue. Les threads du noyau peuvent déterminer l'état de gel en appelant kthread_freezable_should_stop et appeler activement __refrigerator pour entrer dans le gel ; work_queue détermine l'attribut max_active = 0, le nouveau travail ne peut pas être mis en file d'attente et tout le travail est retardé.

Il existe trois variables globales importantes qui marquent l'état de gel du système : pm_freezing, system_freezing_cnt et pm_nosig_freezing. Si elles sont toutes à 0, cela signifie que le système n'est pas entré en gel ; system_freezing_cnt>0 signifie que le système est entré en gel. =true signifie geler les processus utilisateur, pm_nosig_freezing= true signifie geler les threads du noyau et la file d'attente de travail. Ils seront définis dans freeze_processes et freeze_kernel_threads, et effacés dans thaw_processes et thaw_kernel_threads. La fonction fake_signal_wake_up utilise intelligemment le mécanisme de traitement du signal. Elle ne définit que le bit TIF_SIGPENDING de la tâche, mais ne transmet aucun signal, puis réveille la tâche de cette manière, la tâche entrera dans le processus de traitement du signal lors de son retour ; en mode utilisateur, vérifiez l’état de gel du système et gérez-le en conséquence.

Le code de la tâche pour appeler activement try_to_freeze est le suivant :

```

```

1. static inline bool try_to_freeze_unsafe(void)
2. {
3. if (likely(!freezing(current))) //检查系统是否处于freezing状态
4. return false;
5. return __refrigerator(false); //主动进入冻结
6. }
7.  
8. static inline bool freezing(struct task_struct *p)
9. {
10. if (likely(!atomic_read(&system_freezing_cnt))) //系统总体进入freezing
11. return false;
12. return freezing_slow_path(p);
13. }
14.  
15. bool freezing_slow_path(struct task_struct *p)
16. {
17. if (p->flags & PF_NOFREEZE) //当前进程是否允许冻结
18. return false;
19.  
20. if (pm_nosig_freezing || cgroup_freezing(p)) //系统冻结kernel threads
21. return true;
22.  
23. if (pm_freezing && !(p->flags & PF_KTHREAD)) //系统冻结用户进程
24. return true;
25.  
26. return false;
27. }

La fonction principale pour entrer dans l'état gelé jusqu'à la récupération : bool __refrigerator(bool check_kthr_stop)

1. {
2. ...
3. for (;;) {
4. set_current_state(TASK_UNINTERRUPTIBLE); //设置进程为UNINTERRUPTIBLE状态
5.  
6. spin_lock_irq(&freezer_lock);
7. current->flags |= PF_FROZEN; //设置已冻结状态
8. if (!freezing(current) ||
9. (check_kthr_stop && kthread_should_stop())) //判断系统是否还处于冻结
10. current->flags &= ~PF_FROZEN; //如果系统已解冻，则取消冻结状态
11. spin_unlock_irq(&freezer_lock);
12.  
13. if (!(current->flags & PF_FROZEN)) //如果已取消冻结，跳出循环，恢复执行
14. break;
15. was_frozen = true;
16. schedule();
17. }
18. ......
19. }

En bref, la technologie de gel des processus Linux est une technologie très utile qui peut vous aider à éviter certains problèmes potentiels et à rendre votre système plus stable. Si vous souhaitez en savoir plus sur cette technologie, consultez les ressources fournies dans cet article.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!