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

在调试内核的时候，经常会碰到几个相近的概念：进程 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_create

1.2 内核进程的 stop

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

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

​​​​kthread_should_stop

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

• kernel/kthread.c:
• kthread_should_stop()
  /kthread_stop()

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

2. 进程 park

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

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

问题来了，既然 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_thread

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

• kernel/stop_machine.c:

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

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

• kernel/kthread.c:

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

2.2 cpu hotplug 支持

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

• kernel/smpboot.c:

​​​​park_hotplug

3. 进程 freeze

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

• kernel/power/suspend.c:

​​​​suspend_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()

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

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:

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

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()

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

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

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

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

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

所以从代码逻辑上看内核进程 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;

}