• Linux 进程中 Stop, Park, Freeze【转】

    转自：https://blog.csdn.net/yiyeguzhou100/article/details/53134743

    http://kernel.meizu.com/linux-process-stop.html

    在调试内核的时候，经常会碰到几个相近的概念：进程 stop、进程 park、进程 freeze。这几个名词看起来都是停止进程，那么他们之间的区别和应用场景在分别是什么呢？下面就来分析一番。

    本文的代码分析基于 Linux kernel 3.18.22，最好的学习方法还是 “RTFSC”

    1. 进程 stop

    进程 stop 分成两种：用户进程 stop 和内核进程 stop。

    用户进程 stop 可以通过给进程发送 STOP 信号来实现，可以参考“Linux Signal”这一篇的描述。但是对内核进程来说不会响应信号，如果碰到需要 stop 内核进程的场景怎么处理？比如：我们在设备打开的时候创建了内核处理进程，在设备关闭的时候需要 stop 内核进程。

    Linux 实现了一套 kthread_stop() 的机制来实现内核进程 stop。

    1.1 内核进程的创建

    内核进程创建过程，是理解本篇的基础。

    可以看到 kthread_create() 并不是自己去创建内核进程，而是把创建任务推送给 kthreadd()进程执行。

    kthreadd() -> create_kthread() -> kernel_thread() 创建的新进程也不是直接使用用户的函数 threadfn()，而是创建通用函数 kthread()，kthread() 再来调用 threadfn()。

    • kernel/kthread.c:

    kthread_createkthread_create

    1.2 内核进程的 stop

    如果内核进程需要支持 kthread_stop()，需要根据以下框架来写代码。用户在主循环中调用 kthread_should_stop() 来判断当前 kthread 是否需要 stop，如果被 stop 则退出循环。

    这种代码为什么不做到通用代码 kthread() 中？这应该是和 Linux 的设计思想相关的。Linux 运行内核态的策略比较灵活，而对用户态的策略更加严格统一。

    kthread_should_stopkthread_should_stop

    kthread_should_stop() 和 kthread_stop() 的代码实现：

    • kernel/kthread.c:
    • kthread_should_stop()/kthread_stop()
    1.  
    2. bool kthread_should_stop(void)
    3. {
    4. // (1) 判断进程所在 kthread 结构中的 KTHREAD_SHOULD_STOP 是否被置位
    5. return test_bit(KTHREAD_SHOULD_STOP, &to_kthread(current)->flags);
    6. }
    7.  
    8. int kthread_stop(struct task_struct *k)
    9. {
    10. struct kthread *kthread;
    11. int ret;
    12.  
    13. trace_sched_kthread_stop(k);
    14.  
    15. get_task_struct(k);
    16. kthread = to_live_kthread(k);
    17. if (kthread) {
    18. // (2) 置位进程所在 kthread 结构中的 KTHREAD_SHOULD_STOP
    19. set_bit(KTHREAD_SHOULD_STOP, &kthread->flags);
    20. // (3) unpark & wake_up 进程来响应 stop 信号
    21. __kthread_unpark(k, kthread);
    22. wake_up_process(k);
    23. wait_for_completion(&kthread->exited);
    24. }
    25. ret = k->exit_code;
    26. put_task_struct(k);
    27.  
    28. trace_sched_kthread_stop_ret(ret);
    29. return ret;
    30. }

    2. 进程 park

    smpboot_register_percpu_thread() 用来创建 per_cpu 内核进程，所谓的 per_cpu 进程是指需要在每个 online cpu 上创建线程。比如执行 stop_machine() 中 cpu 同步操作的 migration 进程：

    1. shell@:/ $ ps | grep migration
    2. root 10 2 0 0 smpboot_th 0000000000 S migration/0
    3. root 11 2 0 0 smpboot_th 0000000000 S migration/1
    4. root 15 2 0 0 __kthread_ 0000000000 R migration/2
    5. root 19 2 0 0 __kthread_ 0000000000 R migration/3
    6. root 207 2 0 0 __kthread_ 0000000000 R migration/8
    7. root 247 2 0 0 __kthread_ 0000000000 R migration/4
    8. root 251 2 0 0 __kthread_ 0000000000 R migration/5
    9. root 265 2 0 0 __kthread_ 0000000000 R migration/6
    10. root 356 2 0 0 __kthread_ 0000000000 R migration/7
    11. root 2165 2 0 0 __kthread_ 0000000000 R migration/9
    12.  

    问题来了，既然 per_cpu 进程是和 cpu 绑定的，那么在 cpu hotplug 的时候，进程需要相应的 disable 和 enable。实现的方法可以有多种：

    • 动态的销毁和创建线程。缺点是开销比较大。
    • 设置进程的 cpu 亲和力 set_cpus_allowed_ptr()。缺点是进程绑定的 cpu 如果被 down 掉，进程会迁移到其他 cpu 继续执行。

    为了克服上述方案的缺点，适配 per_cpu 进程的 cpu hotplug 操作，设计了 kthread_park()/kthread_unpark() 机制。

    2.1 smpboot_register_percpu_thread()

    per_cpu 进程从代码上看，实际也是调用 kthread_create() 来创建的。

    • kernel/smpboot.c:
    • kernel/kthread.c:

    smpboot_register_percpu_threadsmpboot_register_percpu_thread

    我们可以看到 smpboot_register 又增加了一层封装：kthread() -> smpboot_thread_fn() -> ht->thread_fn()，这种封装的使用可以参考 cpu_stop_threads。

    • kernel/stop_machine.c:
    1. static struct smp_hotplug_thread cpu_stop_threads = {
    2. .store = &cpu_stopper_task,
    3. .thread_should_run = cpu_stop_should_run,
    4. .thread_fn = cpu_stopper_thread,
    5. .thread_comm = "migration/%u",
    6. .create = cpu_stop_create,
    7. .setup = cpu_stop_unpark,
    8. .park = cpu_stop_park,
    9. .pre_unpark = cpu_stop_unpark,
    10. .selfparking = true,
    11. };
    12.  
    13. static int __init cpu_stop_init(void)
    14. {
    15. unsigned int cpu;
    16.  
    17. for_each_possible_cpu(cpu) {
    18. struct cpu_stopper *stopper = &per_cpu(cpu_stopper, cpu);
    19.  
    20. spin_lock_init(&stopper->lock);
    21. INIT_LIST_HEAD(&stopper->works);
    22. }
    23.  
    24. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads));
    25. stop_machine_initialized = true;
    26. return 0;
    27. }

    我们可以看到 smpboot_thread_fn() 循环中实现了对 park 的支持，具体实现 kthread_should_park()、kthread_parkme()、kthread_park()、kthread_unpark() 的代码分析：

    • kernel/kthread.c:
    1. bool kthread_should_park(void)
    2. {
    3. // (1) 判断进程所在 kthread 结构中的 KTHREAD_SHOULD_PARK 是否被置位
    4. return test_bit(KTHREAD_SHOULD_PARK, &to_kthread(current)->flags);
    5. }
    6.  
    7. void kthread_parkme(void)
    8. {
    9. __kthread_parkme(to_kthread(current));
    10. }
    11. | →
    12. static void __kthread_parkme(struct kthread *self)
    13. {
    14. // (2) 如果当前进程的 KTHREAD_SHOULD_PARK 标志被置位 ,
    15. // 将当前进程进入 TASK_PARKED 的阻塞状态。
    16. // 如果 KTHREAD_SHOULD_PARK 不清除，
    17. // 就算被 wake_up 唤醒还是会循环进入 TASK_PARKED 的阻塞状态。
    18. __set_current_state(TASK_PARKED);
    19. while (test_bit(KTHREAD_SHOULD_PARK, &self->flags)) {
    20. if (!test_and_set_bit(KTHREAD_IS_PARKED, &self->flags))
    21. complete(&self->parked);
    22. schedule();
    23. __set_current_state(TASK_PARKED);
    24. }
    25. clear_bit(KTHREAD_IS_PARKED, &self->flags);
    26. __set_current_state(TASK_RUNNING);
    27. }
    28.  
    29. int kthread_park(struct task_struct *k)
    30. {
    31. struct kthread *kthread = to_live_kthread(k);
    32. int ret = -ENOSYS;
    33.  
    34. if (kthread) {
    35. // (3) 设置 KTHREAD_IS_PARKED 标志位，并且唤醒进程进入 park 状态
    36. if (!test_bit(KTHREAD_IS_PARKED, &kthread->flags)) {
    37. set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
    38. if (k != current) {
    39. wake_up_process(k);
    40. wait_for_completion(&kthread->parked);
    41. }
    42. }
    43. ret = 0;
    44. }
    45. return ret;
    46. }
    47.  
    48. void kthread_unpark(struct task_struct *k)
    49. {
    50. struct kthread *kthread = to_live_kthread(k);
    51.  
    52. if (kthread)
    53. __kthread_unpark(k, kthread);
    54. }
    55. | →
    56. static void __kthread_unpark(struct task_struct *k, struct kthread *kthread)
    57. {
    58. // (4) 清除 KTHREAD_IS_PARKED 标志位
    59. clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
    60. /*
    61. * We clear the IS_PARKED bit here as we don't wait
    62. * until the task has left the park code. So if we'd
    63. * park before that happens we'd see the IS_PARKED bit
    64. * which might be about to be cleared.
    65. */
    66. // 如果进程已经被 park，并且 wake_up 唤醒进程
    67. if (test_and_clear_bit(KTHREAD_IS_PARKED, &kthread->flags)) {
    68. // 如果是 per_cpu 进程，重新绑定进程 cpu
    69. if (test_bit(KTHREAD_IS_PER_CPU, &kthread->flags))
    70. __kthread_bind(k, kthread->cpu, TASK_PARKED);
    71. wake_up_state(k, TASK_PARKED);
    72. }
    73. }
    74.  

    2.2 cpu hotplug 支持

    我们前面说到 park 机制的主要目的是为了 per_cpu 进程支持 cpu hotplug，具体怎么响应热插拔事件呢？

    • kernel/smpboot.c:

    park_hotplugpark_hotplug

    3. 进程 freeze

    在系统进入 suspend 的时候，会尝试冻住一些进程，以避免一些进程无关操作影响系统的 suspend 状态。主要的流程如下：

    • kernel/power/suspend.c:

    suspend_freeze_processessuspend_freeze_processes

    这 suspend_freeze 里面判断当前在那个阶段，有 3 个重要的变量：

    • system_freezing_cnt - >0 表示系统全局的 freeze 开始；
    • pm_freezing - =true 表示用户进程 freeze 开始；
    • pm_nosig_freezing - =true 表示内核进程 freeze 开始；

    具体代码分析如下：

    • kernel/power/process.c:
    • kernel/freezer.c:
    • suspend_freeze_processes() -> freeze_processes() -> try_to_freeze_tasks() -> freeze_task()
    1.  
    2. int freeze_processes(void)
    3. {
    4. int error;
    5. int oom_kills_saved;
    6.  
    7. error = __usermodehelper_disable(UMH_FREEZING);
    8. if (error)
    9. return error;
    10.  
    11. // (1) 置位 PF_SUSPEND_TASK，确保当前进程不会被 freeze
    12. /* Make sure this task doesn't get frozen */
    13. current->flags |= PF_SUSPEND_TASK;
    14.  
    15. // (2) 使用全局 freeze 标志 system_freezing_cnt
    16. if (!pm_freezing)
    17. atomic_inc(&system_freezing_cnt);
    18.  
    19. pm_wakeup_clear();
    20. printk("Freezing user space processes ... ");
    21. // (3) 使用用户进程 freeze 标志 pm_freezing
    22. pm_freezing = true;
    23. oom_kills_saved = oom_kills_count();
    24. // (4) freeze user_only 进程
    25. // 判断进程是否可以被 freeze，唤醒进程 freeze 自己
    26. error = try_to_freeze_tasks(true);
    27. if (!error) {
    28. __usermodehelper_set_disable_depth(UMH_DISABLED);
    29. oom_killer_disable();
    30.  
    31. /*
    32. * There might have been an OOM kill while we were
    33. * freezing tasks and the killed task might be still
    34. * on the way out so we have to double check for race.
    35. */
    36. if (oom_kills_count() != oom_kills_saved &&
    37. !check_frozen_processes()) {
    38. __usermodehelper_set_disable_depth(UMH_ENABLED);
    39. printk("OOM in progress.");
    40. error = -EBUSY;
    41. } else {
    42. printk("done.");
    43. }
    44. }
    45. printk(" ");
    46. BUG_ON(in_atomic());
    47.  
    48. if (error)
    49. thaw_processes();
    50. return error;
    51. }
    52. | →
    53. static int try_to_freeze_tasks(bool user_only)
    54. {
    55. struct task_struct *g, *p;
    56. unsigned long end_time;
    57. unsigned int todo;
    58. bool wq_busy = false;
    59. struct timeval start, end;
    60. u64 elapsed_msecs64;
    61. unsigned int elapsed_msecs;
    62. bool wakeup = false;
    63. int sleep_usecs = USEC_PER_MSEC;
    64. #ifdef CONFIG_PM_SLEEP
    65. char suspend_abort[MAX_SUSPEND_ABORT_LEN];
    66. #endif
    68. do_gettimeofday(&start);
    69.  
    70. end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs);
    71.  
    72. // (4.1) 如果是 kernel freeze，
    73. // 停工有 WQ_FREEZABLE 标志的 workqueue
    74. // 将 wq 的 pwq->max_active 设置成 0，新的 work 不能被执行
    75. if (!user_only)
    76. freeze_workqueues_begin();
    77.  
    78. while (true) {
    79. todo = 0;
    80. read_lock(&tasklist_lock);
    81. // (4.2) 对每个进程执行 freeze_task()
    82. for_each_process_thread(g, p) {
    83. if (p == current || !freeze_task(p))
    84. continue;
    85.  
    86. if (!freezer_should_skip(p))
    87. todo++;
    88. }
    89. read_unlock(&tasklist_lock);
    90.  
    91. // (4.3) 如果是 kernel freeze，
    92. // 判断停工的 workqueue 中残留的 work 有没有执行完
    93. if (!user_only) {
    94. wq_busy = freeze_workqueues_busy();
    95. todo += wq_busy;
    96. }
    97.  
    98. if (!todo || time_after(jiffies, end_time))
    99. break;
    100.  
    101. if (pm_wakeup_pending()) {
    102. #ifdef CONFIG_PM_SLEEP
    103. pm_get_active_wakeup_sources(suspend_abort,
    104. MAX_SUSPEND_ABORT_LEN);
    105. log_suspend_abort_reason(suspend_abort);
    106. #endif
    107. wakeup = true;
    108. break;
    109. }
    110.  
    111. /*
    112. * We need to retry, but first give the freezing tasks some
    113. * time to enter the refrigerator. Start with an initial
    114. * 1 ms sleep followed by exponential backoff until 8 ms.
    115. */
    116. usleep_range(sleep_usecs / 2, sleep_usecs);
    117. if (sleep_usecs < 8 * USEC_PER_MSEC)
    118. sleep_usecs *= 2;
    119. }
    120.  
    121. do_gettimeofday(&end);
    122. elapsed_msecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
    123. do_div(elapsed_msecs64, NSEC_PER_MSEC);
    124. elapsed_msecs = elapsed_msecs64;
    125.  
    126. if (wakeup) {
    127. printk(" ");
    128. printk(KERN_ERR "Freezing of tasks aborted after %d.%03d seconds",
    129. elapsed_msecs / 1000, elapsed_msecs % 1000);
    130. } else if (todo) {
    131. printk(" ");
    132. printk(KERN_ERR "Freezing of tasks failed after %d.%03d seconds"
    133. " (%d tasks refusing to freeze, wq_busy=%d): ",
    134. elapsed_msecs / 1000, elapsed_msecs % 1000,
    135. todo - wq_busy, wq_busy);
    136.  
    137. read_lock(&tasklist_lock);
    138. for_each_process_thread(g, p) {
    139. if (p != current && !freezer_should_skip(p)
    140. && freezing(p) && !frozen(p))
    141. sched_show_task(p);
    142. }
    143. read_unlock(&tasklist_lock);
    144. } else {
    145. printk("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,
    146. elapsed_msecs % 1000);
    147. }
    148.  
    149. return todo ? -EBUSY : 0;
    150. }
    151. || →
    152. bool freeze_task(struct task_struct *p)
    153. {
    154. unsigned long flags;
    155.  
    156. /*
    157. * This check can race with freezer_do_not_count, but worst case that
    158. * will result in an extra wakeup being sent to the task. It does not
    159. * race with freezer_count(), the barriers in freezer_count() and
    160. * freezer_should_skip() ensure that either freezer_count() sees
    161. * freezing == true in try_to_freeze() and freezes, or
    162. * freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task
    163. * normally.
    164. */
    165. if (freezer_should_skip(p))
    166. return false;
    167.  
    168. spin_lock_irqsave(&freezer_lock, flags);
    169. // (4.2.1) 检查当前进程是否可以被 freeze，
    170. // 或者是否已经被 freeze
    171. if (!freezing(p) || frozen(p)) {
    172. spin_unlock_irqrestore(&freezer_lock, flags);
    173. return false;
    174. }
    175.  
    176. // (4.2.2) 如果是用户进程，伪造一个 signal 发送给进程
    177. if (!(p->flags & PF_KTHREAD))
    178. fake_signal_wake_up(p);
    179. // (4.2.3) 如果是内核进程，wake_up 内核进程
    180. else
    181. wake_up_state(p, TASK_INTERRUPTIBLE);
    182.  
    183. spin_unlock_irqrestore(&freezer_lock, flags);
    184. return true;
    185. }
    186. ||| →
    187. static inline bool freezing(struct task_struct *p)
    188. { 具体代码分析如下：
    189.  
    190. - kernel/power/process.c:
    191. - kernel/freezer.c:
    192. // 如果 system_freezing_cnt 为 0，说明全局 freeze 还没有开始
    193. if (likely(!atomic_read(&system_freezing_cnt)))
    194. return false;
    195. return freezing_slow_path(p);
    196. }
    197. |||| →
    198. bool freezing_slow_path(struct task_struct *p)
    199. {
    200. // (PF_NOFREEZE | PF_SUSPEND_TASK) 当前进程不能被 freeze
    201. if (p->flags & (PF_NOFREEZE | PF_SUSPEND_TASK))
    202. return false;
    203.  
    204. if (test_thread_flag(TIF_MEMDIE))
    205. return false;
    206.  
    207. // 如果 pm_nosig_freezing 为 true，内核进程 freeze 已经开始，
    208. // 当前进程可以被 freeze
    209. if (pm_nosig_freezing || cgroup_freezing(p))
    210. return true;
    211.  
    212. // 如果 pm_freezing 为 true，且当前进程为用户进程
    213. // 当前进程可以被 freeze
    214. if (pm_freezing && !(p->flags & PF_KTHREAD))
    215. return true;
    216.  
    217. return false;
    218. }

    3.1 用户进程 freeze

    freeze 用户态的进程利用了 signal 机制，系统 suspend 使能了 suspend 以后，调用 fake_signal_wake_up() 伪造一个信号唤醒进程，进程在 ret_to_user() -> do_notify_resume() -> do_signal() -> get_signal() -> try_to_freeze() 中 freeze 自己。

    具体代码分析如下：

    • kernel/freezer.c:
    1. static inline bool try_to_freeze(void)
    2. {
    3. if (!(current->flags & PF_NOFREEZE))
    4. debug_check_no_locks_held();
    5. return try_to_freeze_unsafe();
    6. }
    7. | →
    8. static inline bool try_to_freeze_unsafe(void)
    9. {
    10. might_sleep();
    11. // 当前进程是否可以被 freeze
    12. if (likely(!freezing(current)))
    13. return false;
    14. // 调用 __refrigerator() freeze 当前进程
    15. return __refrigerator(false);
    16. }
    17. || →
    18. bool __refrigerator(bool check_kthr_stop)
    19. {
    20. /* Hmm, should we be allowed to suspend when there are realtime
    21. processes around? */
    22. bool was_frozen = false;
    23. long save = current->state;
    24.  
    25. pr_debug("%s entered refrigerator ", current->comm);
    26.  
    27. for (;;) {
    28. // (1) 设置当前进程进入 TASK_UNINTERRUPTIBLE 阻塞状态
    29. set_current_state(TASK_UNINTERRUPTIBLE);
    30.  
    31. spin_lock_irq(&freezer_lock);
    32. // (2) 设置已经 freeze 标志 PF_FROZEN
    33. current->flags |= PF_FROZEN;
    34. // (3) 如果当前进程已经不是 freeze 状态，
    35. // 退出 freeze
    36. if (!freezing(current) ||
    37. (check_kthr_stop && kthread_should_stop()))
    38. current->flags &= ~PF_FROZEN;
    39. spin_unlock_irq(&freezer_lock);
    40.  
    41. if (!(current->flags & PF_FROZEN))
    42. break;
    43. was_frozen = true;
    44. schedule();
    45. }
    46.  
    47. pr_debug("%s left refrigerator ", current->comm);
    48.  
    49. /*
    50. * Restore saved task state before returning. The mb'd version
    51. * needs to be used; otherwise, it might silently break
    52. * synchronization which depends on ordered task state change.
    53. */
    54. set_current_state(save);
    55.  
    56. return was_frozen;
    57. }

    3.2 内核进程 freeze

    内核进程对 freeze 的响应，有两个问题：

    • wake_up_state(p, TASK_INTERRUPTIBLE) 能唤醒哪些内核进程。
    • 内核进程怎么样来响应 freeze 状态，怎么样来 freeze 自己。

    如果进程阻塞在信号量、mutex 等内核同步机制上，wake_up_state 并不能解除阻塞。因为这些机制都有 while(1) 循环来判断条件，是否成立，不成立只是简单的唤醒随即又会进入阻塞睡眠状态。

    • kernel/locking/mutex.c:
    • mutex_lock() -> __mutex_lock_common()
    1. __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
    2. struct lockdep_map *nest_lock, unsigned long ip,
    3. struct ww_acquire_ctx *ww_ctx, const bool use_ww_ctx)
    4. {
    5.  
    6. for (;;) {
    7. /*
    8. * Lets try to take the lock again - this is needed even if
    9. * we get here for the first time (shortly after failing to
    10. * acquire the lock), to make sure that we get a wakeup once
    11. * it's unlocked. Later on, if we sleep, this is the
    12. * operation that gives us the lock. We xchg it to -1, so
    13. * that when we release the lock, we properly wake up the
    14. * other waiters. We only attempt the xchg if the count is
    15. * non-negative in order to avoid unnecessary xchg operations:
    16. */
    17. // (1) 如果 mutex_lock 条件成立，才退出
    18. if (atomic_read(&lock->count) >= 0 &&
    19. (atomic_xchg(&lock->count, -1) == 1))
    20. break;
    21.  
    22. // (2) 如果如果有信号阻塞，也退出
    23. /*
    24. * got a signal? (This code gets eliminated in the
    25. * TASK_UNINTERRUPTIBLE case.)
    26. */
    27. if (unlikely(signal_pending_state(state, task))) {
    28. ret = -EINTR;
    29. goto err;
    30. }
    31.  
    32. if (use_ww_ctx && ww_ctx->acquired > 0) {
    33. ret = __mutex_lock_check_stamp(lock, ww_ctx);
    34. if (ret)
    35. goto err;
    36. }
    37.  
    38. // (3) 否则继续进入阻塞休眠状态
    39. __set_task_state(task, state);
    40.  
    41. /* didn't get the lock, go to sleep: */
    42. spin_unlock_mutex(&lock->wait_lock, flags);
    43. schedule_preempt_disabled();
    44. spin_lock_mutex(&lock->wait_lock, flags);
    45. }
    46.  
    47. }

    所以 wake_up_state() 只能唤醒这种简单阻塞的内核进程，而对于阻塞在内核同步机制上是无能无力的：

    1. void user_thread()
    2. {
    3. while(1)
    4. {
    5. set_current_state(TASK_UNINTERRUPTIBLE);
    6. schedule();
    7.  
    8. }
    9. }

    内核进程响应 freeze 操作，也必须显式的调用 try_to_freeze() 或者 kthread_freezable_should_stop() 来 freeze 自己：

    1. void user_thread()
    2. {
    3. while (!kthread_should_stop()) {
    4.  
    5. try_to_freeze();
    6.  
    7. }
    8. }

    所以从代码逻辑上看内核进程 freeze，并不会 freeze 所有内核进程，只 freeze 了 2 部分：一部分是设置了 WQ_FREEZABLE 标志的 workqueue，另一部分是内核进程主动调用 try_to_freeze() 并且在架构上设计的可以响应 freeze。



    附：

    static int
    kthread(void *vp)
    {
    struct ktstate *k;
    DECLARE_WAITQUEUE(wait, current);
    int more;
    k = vp;
    current->flags |= PF_NOFREEZE;
    set_user_nice(current, -10); //内核线程默认优先级
    complete(&k->rendez);/* tell spawner we're running */
    do {
    spin_lock_irq(k->lock);
    more = k->fn();
    if (!more) {
    add_wait_queue(k->waitq, &wait);
    __set_current_state(TASK_INTERRUPTIBLE);
    }
    spin_unlock_irq(k->lock);
    if (!more) {
    schedule();
    remove_wait_queue(k->waitq, &wait);
    } else
    cond_resched();
    } while (!kthread_should_stop());
    complete(&k->rendez);/* tell spawner we're stopping */
    return 0;
    }
  • 相关阅读:
    java练习题2
    java练习题
    java输入输出
    字符集
    eclipse快捷键
    类和对象练习-people
    类和对象-三角形
    权限修饰符-输出求和阶乘
    权限修饰符-练习
    权限修饰符-father&&son
  • 原文地址：https://www.cnblogs.com/sky-heaven/p/9340497.html
Copyright © 2020-2023  润新知