Android休眠與喚醒
阿新 • • 發佈：2018-12-29
對於休眠(suspend)的簡單介紹
在Linux中,休眠主要分三個主要的步驟:
凍結使用者態程序和核心態任務
呼叫註冊的裝置的suspend的回撥函式
順序是按照註冊順序
休眠核心裝置和使CPU進入休眠態凍結程序是核心把程序列表中所有的程序的狀態都設定為停止,並且儲存下所有程序的上下文. 當這些程序被解凍的時候,他們是不知道自己被凍結過的,只是簡單的繼續執行.如何讓Linux進入休眠呢?使用者可以通過讀寫sys檔案/sys /power/state 是實現控制系統進入休眠. 比如
# echo standby > /sys/power/state命令系統進入休眠. 也可以使用
# cat /sys/power/state來得到核心支援哪幾種休眠方式.
Linux Suspend 的流程
相關的檔案:
你可以通過訪問 Linux核心網站 來得到原始碼,下面是檔案的路徑:
linux_soruce/kernel/power/main.c
linux_source/kernel/arch/xxx/mach-xxx/pm.c
linux_source/driver/base/power/main.c
接下來讓我們詳細的看一下Linux是怎麼休眠/喚醒的. Let 's going to see how these happens.
使用者對於/sys/power/state 的讀寫會呼叫到 main.c中的state_store(), 使用者可以寫入 const char * const pm_state[] 中定義的字串, 比如"mem", "standby".
然後state_store()會呼叫enter_state(), 它首先會檢查一些狀態引數,然後同步檔案系統. 下面是程式碼:
static int enter_state(suspend_state_t state){
int error;
if (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
printk(KERN_INFO "PM: Syncing filesystems ... ");
sys_sync();
printk("done.");
pr_debug("PM: Preparing system for %s sleep ", pm_states[state]);
error = suspend_prepare();
if (error)
goto Unlock;
if (suspend_test(TEST_FREEZER))
goto Finish;
pr_debug("PM: Entering %s sleep", pm_states[state]);
error = suspend_devices_and_enter(state);
Finish: pr_debug("PM: Finishing wakeup.");
suspend_finish();
Unlock: mutex_unlock(&pm_mutex);
return error;}
準備, 凍結程序
當進入到suspend_prepare()中以後, 它會給suspend分配一個虛擬終端來輸出信 息, 然後廣播一個系統要進入suspend的Notify, 關閉掉使用者態的helper程序, 然後一次呼叫suspend_freeze_processes()凍結所有的程序, 這裡會儲存所有程序 當前的狀態, 也許有一些程序會拒絕進入凍結狀態, 當有這樣的程序存在的時候, 會導致凍結失敗,此函式就會放棄凍結程序,並且解凍剛才凍結的所有程序.
static int suspend_prepare(void){
int error;
unsigned int free_pages;
if (!suspend_ops || !suspend_ops->enter)
return -EPERM;
pm_prepare_console();
error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
if (error)
goto Finish;
error = usermodehelper_disable();
if (error)
goto Finish;
if (suspend_freeze_processes()) {
error = -EAGAIN;
goto Thaw;
}
free_pages = global_page_state(NR_FREE_PAGES);
if (free_pages < FREE_PAGE_NUMBER) {
pr_debug("PM: free some memory");
shrink_all_memory(FREE_PAGE_NUMBER - free_pages);
if (nr_free_pages() < FREE_PAGE_NUMBER) {
error = -ENOMEM;
printk(KERN_ERR "PM: No enough memory");
}
}
if (!error)
return 0;
Thaw:
suspend_thaw_processes();
usermodehelper_enable();
Finish:
pm_notifier_call_chain(PM_POST_SUSPEND);
pm_restore_console();
return error;
}
讓外設進入休眠
現在, 所有的程序(也包括workqueue/kthread) 都已經停止了, 核心態人物有 可能在停止的時候握有一些訊號量, 所以如果這時候在外設裡面去解鎖這個訊號 量有可能會發生死鎖, 所以在外設的suspend()函式裡面作lock/unlock鎖要非常小心,這裡建議設計的時候就不要在suspend()裡面等待鎖. 而且因為suspend的時候,有一些Log是無法輸出的,所以一旦出現問題,非常難除錯.
然後kernel在這裡會嘗試釋放一些記憶體.
最後會呼叫suspend_devices_and_enter()來把所有的外設休眠, 在這個函式中, 如果平臺註冊了suspend_pos(通常是在板級定義中定義和註冊), 這裡就會呼叫 suspend_ops->begin(), 然後driver/base/power/main.c 中的 device_suspend()->dpm_suspend() 會被呼叫,他們會依次呼叫驅動的suspend() 回撥來休眠掉所有的裝置.
當所有的裝置休眠以後, suspend_ops->prepare()會被呼叫, 這個函式通常會作一些準備工作來讓板機進入休眠. 接下來Linux,在多核的CPU中的非啟動CPU會被關掉, 通過註釋看到是避免這些其他的CPU造成race condion,接下來的以後只有一個CPU在運行了.
suspend_ops 是板級的電源管理操作, 通常註冊在檔案 arch/xxx/mach-xxx/pm.c 中.
接下來, suspend_enter()會被呼叫, 這個函式會關閉arch irq, 呼叫 device_power_down(), 它會呼叫suspend_late()函式, 這個函式是系統真正進入 休眠最後呼叫的函式, 通常會在這個函式中作最後的檢查. 如果檢查沒問題, 接 下來休眠所有的系統裝置和匯流排, 並且呼叫 suspend_pos->enter() 來使CPU進入 省電狀態. 這時候,就已經休眠了.程式碼的執行也就停在這裡了.
int suspend_devices_and_enter(suspend_state_t state){
int error, ftrace_save;
if (!suspend_ops)
return -ENOSYS;
if (suspend_ops->begin) {
error = suspend_ops->begin(state);
if (error)
goto Close;
}
suspend_console();
ftrace_save = __ftrace_enabled_save();
suspend_test_start();
error = device_suspend(PMSG_SUSPEND);
if (error) {
printk(KERN_ERR "PM: Some devices failed to suspend");
goto Recover_platform;
}
suspend_test_finish("suspend devices");
if (suspend_test(TEST_DEVICES))
goto Recover_platform;
if (suspend_ops->prepare) {
error = suspend_ops->prepare();
if (error)
goto Resume_devices;
}
if (suspend_test(TEST_PLATFORM))
goto Finish;
error = disable_nonboot_cpus();
if (!error && !suspend_test(TEST_CPUS))
suspend_enter(state);
enable_nonboot_cpus();
Finish:
if (suspend_ops->finish)
suspend_ops->finish();
Resume_devices:
suspend_test_start();
device_resume(PMSG_RESUME);
suspend_test_finish("resume devices");
__ftrace_enabled_restore(ftrace_save);
resume_console();
Close:
if (suspend_ops->end)
suspend_ops->end();
return error;
Recover_platform:
if (suspend_ops->recover)
suspend_ops->recover();
goto Resume_devices;
}
Resume
如果在休眠中系統被中斷或者其他事件喚醒, 接下來的程式碼就會開始執行, 這個喚醒的順序是和休眠的循序相反的,所以系統裝置和匯流排會首先喚醒,使能系統中 斷, 使能休眠時候停止掉的非啟動CPU, 以及呼叫suspend_ops->finish(), 而且在suspend_devices_and_enter()函式中也會繼續喚醒每個裝置,使能虛擬終端, 最後呼叫 suspend_ops->end().
在返回到enter_state()函式中的, 當 suspend_devices_and_enter() 返回以後, 外設已經喚醒了, 但是程序和任務都還是凍結狀態, 這裡會呼叫suspend_finish()來解凍這些程序和任務, 而且發出Notify來表示系統已經從suspend狀態退出, 喚醒終端.
到這裡, 所有的休眠和喚醒就已經完畢了, 系統繼續運行了.
Android 休眠(suspend)
在一個打過android補丁的核心中, state_store()函式會走另外一條路,會進入到request_suspend_state()中, 這個檔案在earlysuspend.c中. 這些功能都 是android系統加的, 後面會對earlysuspend和late resume 進行介紹.
涉及到的檔案:
linux_source/kernel/power/main.c
linux_source/kernel/power/earlysuspend.c
linux_source/kernel/power/wakelock.c
特性介紹
Early Suspend
Early suspend 是android 引進的一種機制, 這種機制在上游備受爭議,這裡 不做評論. 這個機制作用在關閉顯示的時候, 在這個時候, 一些和顯示有關的 裝置, 比如LCD背光, 比如重力感應器, 觸控式螢幕, 這些裝置都會關掉, 但是系統可能還是在執行狀態(這時候還有wake lock)進行任務的處理, 例如在掃描 SD卡上的檔案等. 在嵌入式裝置中, 背光是一個很大的電源消耗,所以 android會加入這樣一種機制.
Late Resume
Late Resume 是和suspend 配套的一種機制, 是在核心喚醒完畢開始執行的. 主要就是喚醒在Early Suspend的時候休眠的裝置.
Wake Lock
Wake Lock 在Android的電源管理系統中扮演一個核心的角色. Wake Lock是一種鎖的機制, 只要有人拿著這個鎖, 系統就無法進入休眠, 可以被使用者態程式和核心獲得. 這個鎖可以是有超時的或者是沒有超時的, 超時的鎖會在時間過去以後自動解鎖. 如果沒有鎖了或者超時了, 核心就會啟動休眠的那套機制來進入休眠.
Android Suspend
當用戶寫入mem 或者 standby到 /sys/power/state中的時候, state_store()會被呼叫, 然後Android會在這裡呼叫 request_suspend_state() 而標準的Linux會在這裡進入enter_state()這個函式. 如果請求的是休眠, 那麼early_suspend這個workqueue就會被呼叫,並且進入early_suspend狀態.
void request_suspend_state(suspend_state_t new_state)
{
unsigned long irqflags;
int old_sleep;
spin_lock_irqsave(&state_lock, irqflags);
old_sleep = state & SUSPEND_REQUESTED;
if (debug_mask & DEBUG_USER_STATE) {
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
pr_info("request_suspend_state: %s (%d->%d) at %lld "
"(%d-d-d d:d:d. lu UTC)",
new_state != PM_SUSPEND_ON ? "sleep" : "wakeup",
requested_suspend_state, new_state,
ktime_to_ns(ktime_get()),
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
if (!old_sleep && new_state != PM_SUSPEND_ON) {
state |= SUSPEND_REQUESTED;
queue_work(suspend_work_queue, &early_suspend_work);
} else if (old_sleep && new_state == PM_SUSPEND_ON) {
state &= ~SUSPEND_REQUESTED;
wake_lock(&main_wake_lock);
queue_work(suspend_work_queue, &late_resume_work);
}
requested_suspend_state = new_state;
spin_unlock_irqrestore(&state_lock, irqflags);
}
Early Suspend
在early_suspend()函式中, 首先會檢查現在請求的狀態還是否是suspend, 來防止suspend的請求會在這個時候取消掉(因為這個時候使用者程序還在執行),如 果需要退出, 就簡單的退出了. 如果沒有, 這個函式就會把early suspend中 註冊的一系列的回撥都呼叫一次, 然後同步檔案系統, 然後放棄掉 main_wake_lock, 這個wake lock是一個沒有超時的鎖,如果這個鎖不釋放, 那 麼系統就無法進入休眠.
static void early_suspend(struct work_struct *work)
{
struct early_suspend *pos;
unsigned long irqflags;
int abort = 0;
mutex_lock(&early_suspend_lock);
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED)
state |= SUSPENDED;
else
abort = 1;
spin_unlock_irqrestore(&state_lock, irqflags);
if (abort) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: abort, state %d", state);
mutex_unlock(&early_suspend_lock);
goto abort;
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: call handlers");
list_for_each_entry(pos, &early_suspend_handlers, link) {
if (pos->suspend != NULL)
pos->suspend(pos);
}
mutex_unlock(&early_suspend_lock);
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: sync");
sys_sync();
abort:
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED_AND_SUSPENDED)
wake_unlock(&main_wake_lock);
spin_unlock_irqrestore(&state_lock, irqflags);
}
Late Resume
當所有的喚醒已經結束以後, 使用者程序都已經開始運行了, 喚醒通常會是以下的幾種原因:
來電
如果是來電, 那麼Modem會通過傳送命令給rild來讓rild通知WindowManager有來電響應,這樣就會遠端呼叫PowerManagerService來寫"on" 到 /sys/power/state 來執行late resume的裝置, 比如點亮螢幕等.
使用者按鍵使用者按鍵事件會送到WindowManager中, WindowManager會處理這些 按鍵事件,按鍵分為幾種情況, 如果案件不是喚醒鍵(能夠喚醒系統的按鍵) 那麼WindowManager會主動放棄wakeLock來使系統進入再次休眠, 如果按鍵是喚醒鍵,那麼WindowManger就會呼叫PowerManagerService中的介面來執行 Late Resume.
Late Resume 會依次喚醒前面呼叫了Early Suspend的裝置.
static void late_resume(struct work_struct *work)
{
struct early_suspend *pos;
unsigned long irqflags;
int abort = 0;
mutex_lock(&early_suspend_lock);
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPENDED)
state &= ~SUSPENDED;
else
abort = 1;
spin_unlock_irqrestore(&state_lock, irqflags);
if (abort) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: abort, state %d", state);
goto abort;
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: call handlers");
list_for_each_entry_reverse(pos, &early_suspend_handlers, link);
if (pos->resume != NULL)
pos->resume(pos);
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: done");
abort:
mutex_unlock(&early_suspend_lock);
}
Wake Lock
我們接下來看一看wake lock的機制是怎麼執行和起作用的, 主要關注 wakelock.c檔案就可以了.
wake lock 有加鎖和解鎖兩種狀態, 加鎖的方式有兩種, 一種是永久的鎖住, 這樣的鎖除非顯示的放開, 是不會解鎖的, 所以這種鎖的使用是非常小心的. 第二種是超時鎖, 這種鎖會鎖定系統喚醒一段時間, 如果這個時間過去了, 這個鎖會自動解除.
鎖有兩種型別:
WAKE_LOCK_SUSPEND 這種鎖會防止系統進入睡眠
WAKE_LOCK_IDLE 這種鎖不會影響系統的休眠, 作用我不是很清楚.
在wake lock中, 會有3個地方讓系統直接開始suspend(), 分別是:
在wake_unlock()中, 如果發現解鎖以後沒有任何其他的wake lock了, 就開始休眠
在定時器都到時間以後, 定時器的回撥函式會檢視是否有其他的wake lock, 如果沒有, 就在這裡讓系統進入睡眠.
在wake_lock() 中, 對一個wake lock加鎖以後, 會再次檢查一下有沒有鎖, 我想這裡的檢查是沒有必要的, 更好的方法是使加鎖的這個操作原子化, 而 不是繁冗的檢查. 而且這樣的檢查也有可能漏掉.
Suspend
當wake_lock 執行 suspend()以後, 在wakelock.c的suspend()函式會被呼叫,這個函式首先sync檔案系統,然後呼叫pm_suspend(request_suspend_state),接下來pm_suspend()就會呼叫enter_state()來進入Linux的休眠流程..
static void suspend(struct work_struct *work)
{
int ret;
int entry_event_num;
if (has_wake_lock(WAKE_LOCK_SUSPEND)) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: abort suspend");
return;
}
entry_event_num = current_event_num;
sys_sync();
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: enter suspend");
ret = pm_suspend(requested_suspend_state);
if (current_event_num == entry_event_num) {
wake_lock_timeout(&unknown_wakeup, HZ / 2);
}
}
Android於標準Linux休眠的區別
pm_suspend() 雖然會呼叫enter_state()來進入標準的Linux休眠流程,但是還 是有一些區別:
當進入凍結程序的時候, android首先會檢查有沒有wake lock,如果沒有, 才會停止這些程序, 因為在開始suspend和凍結程序期間有可能有人申請了 wake lock,如果是這樣, 凍結程序會被中斷.
在Linux中,休眠主要分三個主要的步驟:
凍結使用者態程序和核心態任務
呼叫註冊的裝置的suspend的回撥函式
順序是按照註冊順序
休眠核心裝置和使CPU進入休眠態凍結程序是核心把程序列表中所有的程序的狀態都設定為停止,並且儲存下所有程序的上下文. 當這些程序被解凍的時候,他們是不知道自己被凍結過的,只是簡單的繼續執行.如何讓Linux進入休眠呢?使用者可以通過讀寫sys檔案/sys /power/state 是實現控制系統進入休眠. 比如
# echo standby > /sys/power/state命令系統進入休眠. 也可以使用
# cat /sys/power/state來得到核心支援哪幾種休眠方式.
Linux Suspend 的流程
相關的檔案:
你可以通過訪問 Linux核心網站 來得到原始碼,下面是檔案的路徑:
linux_soruce/kernel/power/main.c
linux_source/kernel/arch/xxx/mach-xxx/pm.c
linux_source/driver/base/power/main.c
接下來讓我們詳細的看一下Linux是怎麼休眠/喚醒的. Let 's going to see how these happens.
使用者對於/sys/power/state 的讀寫會呼叫到 main.c中的state_store(), 使用者可以寫入 const char * const pm_state[] 中定義的字串, 比如"mem", "standby".
然後state_store()會呼叫enter_state(), 它首先會檢查一些狀態引數,然後同步檔案系統. 下面是程式碼:
static int enter_state(suspend_state_t state){
int error;
if (!valid_state(state))
return -ENODEV;
if (!mutex_trylock(&pm_mutex))
return -EBUSY;
printk(KERN_INFO "PM: Syncing filesystems ... ");
sys_sync();
printk("done.");
pr_debug("PM: Preparing system for %s sleep ", pm_states[state]);
error = suspend_prepare();
if (error)
goto Unlock;
if (suspend_test(TEST_FREEZER))
goto Finish;
pr_debug("PM: Entering %s sleep", pm_states[state]);
error = suspend_devices_and_enter(state);
Finish: pr_debug("PM: Finishing wakeup.");
suspend_finish();
Unlock: mutex_unlock(&pm_mutex);
return error;}
準備, 凍結程序
當進入到suspend_prepare()中以後, 它會給suspend分配一個虛擬終端來輸出信 息, 然後廣播一個系統要進入suspend的Notify, 關閉掉使用者態的helper程序, 然後一次呼叫suspend_freeze_processes()凍結所有的程序, 這裡會儲存所有程序 當前的狀態, 也許有一些程序會拒絕進入凍結狀態, 當有這樣的程序存在的時候, 會導致凍結失敗,此函式就會放棄凍結程序,並且解凍剛才凍結的所有程序.
static int suspend_prepare(void){
int error;
unsigned int free_pages;
if (!suspend_ops || !suspend_ops->enter)
return -EPERM;
pm_prepare_console();
error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
if (error)
goto Finish;
error = usermodehelper_disable();
if (error)
goto Finish;
if (suspend_freeze_processes()) {
error = -EAGAIN;
goto Thaw;
}
free_pages = global_page_state(NR_FREE_PAGES);
if (free_pages < FREE_PAGE_NUMBER) {
pr_debug("PM: free some memory");
shrink_all_memory(FREE_PAGE_NUMBER - free_pages);
if (nr_free_pages() < FREE_PAGE_NUMBER) {
error = -ENOMEM;
printk(KERN_ERR "PM: No enough memory");
}
}
if (!error)
return 0;
Thaw:
suspend_thaw_processes();
usermodehelper_enable();
Finish:
pm_notifier_call_chain(PM_POST_SUSPEND);
pm_restore_console();
return error;
}
讓外設進入休眠
現在, 所有的程序(也包括workqueue/kthread) 都已經停止了, 核心態人物有 可能在停止的時候握有一些訊號量, 所以如果這時候在外設裡面去解鎖這個訊號 量有可能會發生死鎖, 所以在外設的suspend()函式裡面作lock/unlock鎖要非常小心,這裡建議設計的時候就不要在suspend()裡面等待鎖. 而且因為suspend的時候,有一些Log是無法輸出的,所以一旦出現問題,非常難除錯.
然後kernel在這裡會嘗試釋放一些記憶體.
最後會呼叫suspend_devices_and_enter()來把所有的外設休眠, 在這個函式中, 如果平臺註冊了suspend_pos(通常是在板級定義中定義和註冊), 這裡就會呼叫 suspend_ops->begin(), 然後driver/base/power/main.c 中的 device_suspend()->dpm_suspend() 會被呼叫,他們會依次呼叫驅動的suspend() 回撥來休眠掉所有的裝置.
當所有的裝置休眠以後, suspend_ops->prepare()會被呼叫, 這個函式通常會作一些準備工作來讓板機進入休眠. 接下來Linux,在多核的CPU中的非啟動CPU會被關掉, 通過註釋看到是避免這些其他的CPU造成race condion,接下來的以後只有一個CPU在運行了.
suspend_ops 是板級的電源管理操作, 通常註冊在檔案 arch/xxx/mach-xxx/pm.c 中.
接下來, suspend_enter()會被呼叫, 這個函式會關閉arch irq, 呼叫 device_power_down(), 它會呼叫suspend_late()函式, 這個函式是系統真正進入 休眠最後呼叫的函式, 通常會在這個函式中作最後的檢查. 如果檢查沒問題, 接 下來休眠所有的系統裝置和匯流排, 並且呼叫 suspend_pos->enter() 來使CPU進入 省電狀態. 這時候,就已經休眠了.程式碼的執行也就停在這裡了.
int suspend_devices_and_enter(suspend_state_t state){
int error, ftrace_save;
if (!suspend_ops)
return -ENOSYS;
if (suspend_ops->begin) {
error = suspend_ops->begin(state);
if (error)
goto Close;
}
suspend_console();
ftrace_save = __ftrace_enabled_save();
suspend_test_start();
error = device_suspend(PMSG_SUSPEND);
if (error) {
printk(KERN_ERR "PM: Some devices failed to suspend");
goto Recover_platform;
}
suspend_test_finish("suspend devices");
if (suspend_test(TEST_DEVICES))
goto Recover_platform;
if (suspend_ops->prepare) {
error = suspend_ops->prepare();
if (error)
goto Resume_devices;
}
if (suspend_test(TEST_PLATFORM))
goto Finish;
error = disable_nonboot_cpus();
if (!error && !suspend_test(TEST_CPUS))
suspend_enter(state);
enable_nonboot_cpus();
Finish:
if (suspend_ops->finish)
suspend_ops->finish();
Resume_devices:
suspend_test_start();
device_resume(PMSG_RESUME);
suspend_test_finish("resume devices");
__ftrace_enabled_restore(ftrace_save);
resume_console();
Close:
if (suspend_ops->end)
suspend_ops->end();
return error;
Recover_platform:
if (suspend_ops->recover)
suspend_ops->recover();
goto Resume_devices;
}
Resume
如果在休眠中系統被中斷或者其他事件喚醒, 接下來的程式碼就會開始執行, 這個喚醒的順序是和休眠的循序相反的,所以系統裝置和匯流排會首先喚醒,使能系統中 斷, 使能休眠時候停止掉的非啟動CPU, 以及呼叫suspend_ops->finish(), 而且在suspend_devices_and_enter()函式中也會繼續喚醒每個裝置,使能虛擬終端, 最後呼叫 suspend_ops->end().
在返回到enter_state()函式中的, 當 suspend_devices_and_enter() 返回以後, 外設已經喚醒了, 但是程序和任務都還是凍結狀態, 這裡會呼叫suspend_finish()來解凍這些程序和任務, 而且發出Notify來表示系統已經從suspend狀態退出, 喚醒終端.
到這裡, 所有的休眠和喚醒就已經完畢了, 系統繼續運行了.
Android 休眠(suspend)
在一個打過android補丁的核心中, state_store()函式會走另外一條路,會進入到request_suspend_state()中, 這個檔案在earlysuspend.c中. 這些功能都 是android系統加的, 後面會對earlysuspend和late resume 進行介紹.
涉及到的檔案:
linux_source/kernel/power/main.c
linux_source/kernel/power/earlysuspend.c
linux_source/kernel/power/wakelock.c
特性介紹
Early Suspend
Early suspend 是android 引進的一種機制, 這種機制在上游備受爭議,這裡 不做評論. 這個機制作用在關閉顯示的時候, 在這個時候, 一些和顯示有關的 裝置, 比如LCD背光, 比如重力感應器, 觸控式螢幕, 這些裝置都會關掉, 但是系統可能還是在執行狀態(這時候還有wake lock)進行任務的處理, 例如在掃描 SD卡上的檔案等. 在嵌入式裝置中, 背光是一個很大的電源消耗,所以 android會加入這樣一種機制.
Late Resume
Late Resume 是和suspend 配套的一種機制, 是在核心喚醒完畢開始執行的. 主要就是喚醒在Early Suspend的時候休眠的裝置.
Wake Lock
Wake Lock 在Android的電源管理系統中扮演一個核心的角色. Wake Lock是一種鎖的機制, 只要有人拿著這個鎖, 系統就無法進入休眠, 可以被使用者態程式和核心獲得. 這個鎖可以是有超時的或者是沒有超時的, 超時的鎖會在時間過去以後自動解鎖. 如果沒有鎖了或者超時了, 核心就會啟動休眠的那套機制來進入休眠.
Android Suspend
當用戶寫入mem 或者 standby到 /sys/power/state中的時候, state_store()會被呼叫, 然後Android會在這裡呼叫 request_suspend_state() 而標準的Linux會在這裡進入enter_state()這個函式. 如果請求的是休眠, 那麼early_suspend這個workqueue就會被呼叫,並且進入early_suspend狀態.
void request_suspend_state(suspend_state_t new_state)
{
unsigned long irqflags;
int old_sleep;
spin_lock_irqsave(&state_lock, irqflags);
old_sleep = state & SUSPEND_REQUESTED;
if (debug_mask & DEBUG_USER_STATE) {
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
pr_info("request_suspend_state: %s (%d->%d) at %lld "
"(%d-d-d d:d:d. lu UTC)",
new_state != PM_SUSPEND_ON ? "sleep" : "wakeup",
requested_suspend_state, new_state,
ktime_to_ns(ktime_get()),
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
if (!old_sleep && new_state != PM_SUSPEND_ON) {
state |= SUSPEND_REQUESTED;
queue_work(suspend_work_queue, &early_suspend_work);
} else if (old_sleep && new_state == PM_SUSPEND_ON) {
state &= ~SUSPEND_REQUESTED;
wake_lock(&main_wake_lock);
queue_work(suspend_work_queue, &late_resume_work);
}
requested_suspend_state = new_state;
spin_unlock_irqrestore(&state_lock, irqflags);
}
Early Suspend
在early_suspend()函式中, 首先會檢查現在請求的狀態還是否是suspend, 來防止suspend的請求會在這個時候取消掉(因為這個時候使用者程序還在執行),如 果需要退出, 就簡單的退出了. 如果沒有, 這個函式就會把early suspend中 註冊的一系列的回撥都呼叫一次, 然後同步檔案系統, 然後放棄掉 main_wake_lock, 這個wake lock是一個沒有超時的鎖,如果這個鎖不釋放, 那 麼系統就無法進入休眠.
static void early_suspend(struct work_struct *work)
{
struct early_suspend *pos;
unsigned long irqflags;
int abort = 0;
mutex_lock(&early_suspend_lock);
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED)
state |= SUSPENDED;
else
abort = 1;
spin_unlock_irqrestore(&state_lock, irqflags);
if (abort) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: abort, state %d", state);
mutex_unlock(&early_suspend_lock);
goto abort;
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: call handlers");
list_for_each_entry(pos, &early_suspend_handlers, link) {
if (pos->suspend != NULL)
pos->suspend(pos);
}
mutex_unlock(&early_suspend_lock);
if (debug_mask & DEBUG_SUSPEND)
pr_info("early_suspend: sync");
sys_sync();
abort:
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPEND_REQUESTED_AND_SUSPENDED)
wake_unlock(&main_wake_lock);
spin_unlock_irqrestore(&state_lock, irqflags);
}
Late Resume
當所有的喚醒已經結束以後, 使用者程序都已經開始運行了, 喚醒通常會是以下的幾種原因:
來電
如果是來電, 那麼Modem會通過傳送命令給rild來讓rild通知WindowManager有來電響應,這樣就會遠端呼叫PowerManagerService來寫"on" 到 /sys/power/state 來執行late resume的裝置, 比如點亮螢幕等.
使用者按鍵使用者按鍵事件會送到WindowManager中, WindowManager會處理這些 按鍵事件,按鍵分為幾種情況, 如果案件不是喚醒鍵(能夠喚醒系統的按鍵) 那麼WindowManager會主動放棄wakeLock來使系統進入再次休眠, 如果按鍵是喚醒鍵,那麼WindowManger就會呼叫PowerManagerService中的介面來執行 Late Resume.
Late Resume 會依次喚醒前面呼叫了Early Suspend的裝置.
static void late_resume(struct work_struct *work)
{
struct early_suspend *pos;
unsigned long irqflags;
int abort = 0;
mutex_lock(&early_suspend_lock);
spin_lock_irqsave(&state_lock, irqflags);
if (state == SUSPENDED)
state &= ~SUSPENDED;
else
abort = 1;
spin_unlock_irqrestore(&state_lock, irqflags);
if (abort) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: abort, state %d", state);
goto abort;
}
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: call handlers");
list_for_each_entry_reverse(pos, &early_suspend_handlers, link);
if (pos->resume != NULL)
pos->resume(pos);
if (debug_mask & DEBUG_SUSPEND)
pr_info("late_resume: done");
abort:
mutex_unlock(&early_suspend_lock);
}
Wake Lock
我們接下來看一看wake lock的機制是怎麼執行和起作用的, 主要關注 wakelock.c檔案就可以了.
wake lock 有加鎖和解鎖兩種狀態, 加鎖的方式有兩種, 一種是永久的鎖住, 這樣的鎖除非顯示的放開, 是不會解鎖的, 所以這種鎖的使用是非常小心的. 第二種是超時鎖, 這種鎖會鎖定系統喚醒一段時間, 如果這個時間過去了, 這個鎖會自動解除.
鎖有兩種型別:
WAKE_LOCK_SUSPEND 這種鎖會防止系統進入睡眠
WAKE_LOCK_IDLE 這種鎖不會影響系統的休眠, 作用我不是很清楚.
在wake lock中, 會有3個地方讓系統直接開始suspend(), 分別是:
在wake_unlock()中, 如果發現解鎖以後沒有任何其他的wake lock了, 就開始休眠
在定時器都到時間以後, 定時器的回撥函式會檢視是否有其他的wake lock, 如果沒有, 就在這裡讓系統進入睡眠.
在wake_lock() 中, 對一個wake lock加鎖以後, 會再次檢查一下有沒有鎖, 我想這裡的檢查是沒有必要的, 更好的方法是使加鎖的這個操作原子化, 而 不是繁冗的檢查. 而且這樣的檢查也有可能漏掉.
Suspend
當wake_lock 執行 suspend()以後, 在wakelock.c的suspend()函式會被呼叫,這個函式首先sync檔案系統,然後呼叫pm_suspend(request_suspend_state),接下來pm_suspend()就會呼叫enter_state()來進入Linux的休眠流程..
static void suspend(struct work_struct *work)
{
int ret;
int entry_event_num;
if (has_wake_lock(WAKE_LOCK_SUSPEND)) {
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: abort suspend");
return;
}
entry_event_num = current_event_num;
sys_sync();
if (debug_mask & DEBUG_SUSPEND)
pr_info("suspend: enter suspend");
ret = pm_suspend(requested_suspend_state);
if (current_event_num == entry_event_num) {
wake_lock_timeout(&unknown_wakeup, HZ / 2);
}
}
Android於標準Linux休眠的區別
pm_suspend() 雖然會呼叫enter_state()來進入標準的Linux休眠流程,但是還 是有一些區別:
當進入凍結程序的時候, android首先會檢查有沒有wake lock,如果沒有, 才會停止這些程序, 因為在開始suspend和凍結程序期間有可能有人申請了 wake lock,如果是這樣, 凍結程序會被中斷.
在suspend_late()中, 會最後檢查一次有沒有wake lock, 這有可能是某種快速申請wake lock,並且快速釋放這個鎖的程序導致的,如果有這種情況, 這裡會返回錯誤, 整個suspend就會全部放棄.如果pm_suspend()成功了,LOG的輸出可以通過在kernel cmd裡面增加 "no_console_suspend" 來看到suspend和resume過程中的log輸出。
轉載於 http://xxw8393.blog.163.com/blog/static/372568342010112281513635/