Perbincangan mendalam tentang prinsip pelaksanaan dan teknologi berkaitan proses penggantungan/sambung semula Kernel Linux

Dalam kernel Linux, proses penggantungan/sambung semula adalah proses yang sangat penting. Ia boleh merealisasikan sistem tidur dan bangun, dan meningkatkan kecekapan tenaga dan kelajuan tindak balas sistem. Dalam artikel ini, kami akan menyelidiki prinsip pelaksanaan dan teknologi berkaitan proses penggantungan/sambung semula Kernel Linux.

Hibernasi/bangun adalah bahagian yang sangat penting dalam Linux yang dibenamkan harus memasuki keadaan tidur sebanyak mungkin untuk memanjangkan hayat bateri

Artikel rujukan: Penulis: zhangjiejing

Tarikh: 2010-04-07, http://www.thinksrc.com

Versi kernel linux saya: 3.0.31

Pengenalan ringkas kepada hibernasi

Di Linux, hibernasi terbahagi kepada tiga langkah utama:

1. Bekukan proses mod pengguna dan tugas mod kernel

2. Panggil fungsi gantung balik peranti yang didaftarkan

3 Tempahan mengikut tempahan pendaftaran

Hibernatekan peranti teras dan meletakkan CPU ke dalam proses pembekuan bermakna kernel menetapkan status semua proses dalam senarai proses untuk dihentikan dan menyimpan konteks semua proses apabila proses ini tidak dibekukan menjadi Jika ia dibekukan, ia terus melaksanakan Bagaimana untuk membuat Linux memasuki hibernasi?

# echo mem > /sys/power/state

Perintahkan sistem untuk tidur juga boleh

# kucing /sys/power/state

Untuk mengetahui mod tidur mana yang disokong oleh kernel.

Proses Penggantungan Linux

Dokumen berkaitan:

Anda boleh mendapatkan kod sumber dengan melawati laman web kernel Linux, berikut adalah laluan ke fail:

kernel/kernel/power/main.c

kernel/kernel/power/suspend.c

kernel/driver/base/power/main.c

Mari kita lihat dengan lebih dekat cara Linux tidur/bangun Mari kita lihat bagaimana ini berlaku.

Bacaan dan penulisan /sys/power/state pengguna akan memanggil state_store() dalam main.c Pengguna boleh menulis rentetan yang ditakrifkan dalam const char * const pm_state[], seperti "mem", "standby". ia biasanya dikawal oleh butang gantung dan sambung semula

Kemudian state_store() akan memanggil enter_state(), yang akan menyemak beberapa parameter keadaan dahulu dan kemudian menyegerakkan sistem fail Berikut ialah kodnya:

1. /** 
2.  \* enter_state - Do common work of entering low-power state. 
3.  \* @state:   pm_state structure for state we're entering. 
4.  \* 
5.  \* Make sure we're the only ones trying to enter a sleep state. Fail 
6.  \* if someone has beat us to it, since we don't want anything weird to 
7.  \* happen when we wake up. 
8.  \* Then, do the setup for suspend, enter the state, and cleaup (after 
9.  \* we've woken up). 
10.  */ 
11. int enter_state(suspend_state_t state) 
12. { 
13.   int error; 
14.  
15.   if (!valid_state(state)) 
16. ​    return -ENODEV; 
17.  
18.   if (!mutex_trylock(&pm_mutex)) 
19. ​    return -EBUSY; 
20.  
21.   printk(KERN_INFO "PM: Syncing filesystems ... "); 
22.   sys_sync(); 
23.   printk("done.\n"); 
24.  
25.   pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]); 
26.   error = suspend_prepare(); 
27.   if (error) 
28. ​    goto Unlock; 
29.  
30.   if (suspend_test(TEST_FREEZER)) 
31. ​    goto Finish; 
32.  
33.   pr_debug("PM: Entering %s sleep\n", pm_states[state]); 
34.   pm_restrict_gfp_mask(); 
35.   error = suspend_devices_and_enter(state); 
36.   pm_restore_gfp_mask(); 
37.  
38.  Finish: 
39.   pr_debug("PM: Finishing wakeup.\n"); 
40.   suspend_finish(); 
41.  Unlock: 
42.   mutex_unlock(&pm_mutex); 
43.   return error; 
44. } 

 

Sediakan, proses bekukan

Selepas memasukkan suspend_prepare(), ia akan memperuntukkan terminal maya untuk menggantung kepada mengeluarkan maklumat, kemudian menyiarkan Notify bahawa sistem ingin memasukkan suspend, menutup proses pembantu mod pengguna, dan kemudian memanggil suspend_freeze_processes() dalam urutan untuk membekukan semua proses. , status semasa semua proses akan disimpan di sini Mungkin terdapat beberapa proses yang menolak untuk memasuki keadaan beku yang baru beku

1. /** 
2.  \* suspend_prepare - Do prep work before entering low-power state. 
3.  \* 
4.  \* This is common code that is called for each state that we're entering. 
5.  \* Run suspend notifiers, allocate a console and stop all processes. 
6.  */ 
7. static int suspend_prepare(void) 
8. { 
9.   int error; 
10.  
11.   if (!suspend_ops || !suspend_ops-**>**enter) 
12. ​    return -EPERM; 
13.  
14.   pm_prepare_console(); 
15.  
16.   error = pm_notifier_call_chain(PM_SUSPEND_PREPARE); 
17.   if (error) 
18. ​    goto Finish; 
19.  
20.   error = usermodehelper_disable(); 
21.   if (error) 
22. ​    goto Finish; 
23.  
24.   error = suspend_freeze_processes(); 
25.   if (!error) 
26. ​    return 0; 
27.  
28.   suspend_thaw_processes(); 
29.   usermodehelper_enable(); 
30.  Finish: 
31.   pm_notifier_call_chain(PM_POST_SUSPEND); 
32.   pm_restore_console(); 
33.   return error; 
34. } 

Tidurkan periferal

Sekarang, semua proses (termasuk giliran kerja/kthread) telah dihentikan /membuka kunci dalam fungsi suspend() periferal adalah disyorkan untuk tidak menunggu kunci dalam suspend() semasa mereka bentuk Dan kerana sesetengah Log tidak boleh dikeluarkan semasa penggantungan, jadi Apabila masalah berlaku, ia adalah sangat sukar untuk nyahpepijat.

Kemudian kernel akan cuba melepaskan sedikit ingatan di sini.

Akhir sekali, suspend_devices_and_enter() akan dipanggil untuk meletakkan semua peranti untuk tidur Dalam fungsi ini, jika platform mendaftarkan suspend_pos (biasanya ditakrifkan dan didaftarkan dalam definisi peringkat papan), suspend_ops->begin() akan dipanggil di sini, dan kemudian device_suspend()->dpm_suspend() dalam driver/base/power/main.c akan dipanggil, dan mereka akan memanggil balik panggil suspend() pemandu untuk tidur semua peranti.

Apabila semua peranti tidur, suspend_ops->prepare() akan dipanggil off. , seperti yang anda boleh lihat dari komen, ia adalah untuk mengelakkan keadaan perlumbaan yang disebabkan oleh CPU lain ini, hanya satu CPU akan berjalan.

suspend_ops ialah operasi pengurusan kuasa peringkat papan, biasanya didaftarkan dalam lengkungan fail/xxx/mach-xxx/pm.c.

Seterusnya, suspend_enter() akan dipanggil dilakukan dalam fungsi ini. Jika semakan OK, maka tidurkan semua peranti sistem dan bas, dan panggil suspend_pos->enter() untuk meletakkan CPU dalam keadaan penjimatan kuasa pelaksanaan kod itu berhenti

1. /** 
2.  \* suspend_devices_and_enter - suspend devices and enter the desired system 
3.  \*         sleep state. 
4.  \* @state:    state to enter 
5.  */ 
6. int suspend_devices_and_enter(suspend_state_t state) 
7. { 
8.   int error; 
9.  
10.   if (!suspend_ops) 
11. ​    return -ENOSYS; 
12.  
13.   trace_machine_suspend(state); 
14.   if (suspend_ops-**>**begin) { 
15. ​    error = suspend_ops-**>**begin(state); 
16. ​    if (error) 
17. ​      goto Close; 
18.   } 
19.   suspend_console(); 
20.   suspend_test_start(); 
21.   error = dpm_suspend_start(PMSG_SUSPEND); 
22.   if (error) { 
23. ​    printk(KERN_ERR "PM: Some devices failed to suspend\n"); 
24. ​    goto Recover_platform; 
25.   } 
26.   suspend_test_finish("suspend devices"); 
27.   if (suspend_test(TEST_DEVICES)) 
28. ​    goto Recover_platform; 
29.  
30.   error = suspend_enter(state); 
31.  
32.  Resume_devices: 
33.   suspend_test_start(); 
34.   dpm_resume_end(PMSG_RESUME); 
35.   suspend_test_finish("resume devices"); 
36.   resume_console(); 
37.  Close: 
38.   if (suspend_ops-**>**end) 
39. ​    suspend_ops-**>**end(); 
40.   trace_machine_suspend(PWR_EVENT_EXIT); 
41.   return error; 
42.  
43.  Recover_platform: 
44.   if (suspend_ops-**>**recover) 
45. ​    suspend_ops-**>**recover(); 
46.   goto Resume_devices; 
47. } 

RESUME

如果在休眠中系统被中断或者其他事件唤醒, 接下来的代码就会开始执行, 这个 唤醒的顺序是和休眠的循序相反的,所以系统设备和总线会首先唤醒,使能系统中 断, 使能休眠时候停止掉的非启动CPU, 以及调用suspend_ops->finish(), 而且 在suspend_devices_and_enter()函数中也会继续唤醒每个设备,使能虚拟终端, 最后调用 suspend_ops->end().

在返回到enter_state()函数中的, 当 suspend_devices_and_enter() 返回以后, 外设已经唤醒了, 但是进程和任务都还是冻结状态, 这里会调用suspend_finish()来解冻这些进程和任务, 而且发出Notify来表示系统已经从suspend状态退出, 唤醒终端.

到这里, 所有的休眠和唤醒就已经完毕了, 系统继续运行了.

总之，suspend/resume过程是Linux内核中不可或缺的一部分。它可以实现系统的休眠和唤醒，提高系统的能效和响应速度。希望本文能够帮助读者更好地理解Linux Kernel suspend/resume 过程的实现原理和相关技术。

Atas ialah kandungan terperinci Perbincangan mendalam tentang prinsip pelaksanaan dan teknologi berkaitan proses penggantungan/sambung semula Kernel Linux. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!