| #!/bin/sh |
| |
| # Copyright (c) 2010 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # This script is responsible for suspending and resuming the system. It is run |
| # as root by powerd_setuid_helper, which is run by powerd. |
| |
| . /usr/share/misc/shflags |
| |
| DEFINE_integer wakeup_count -1 \ |
| "wakeup event count from start of suspend. -1 to disable" w |
| DEFINE_boolean suspend_to_idle false \ |
| "indicates that the system should suspend to idle (freeze)" i |
| |
| # Exit codes returned by this script and reported via the |
| # Power.SuspendResult histogram: |
| |
| # The system successfully suspended and resumed. |
| readonly RESULT_SUCCESS=0 |
| |
| # A suspend failure occurred in the kernel after writing to /sys/power/state |
| # (i.e. the write to /sys/power/state failed with a non-EBUSY reason). |
| readonly RESULT_FAILURE=1 |
| |
| # The suspend attempt was canceled as the result of a wakeup event occurring |
| # between powerd's read from /sys/power/wakeup_count and this script's write to |
| # it (i.e. the write to wakeup_count failed). |
| readonly RESULT_CANCELED_EARLY=2 |
| |
| # The suspend attempt was canceled as the result of a wakeup event occurring |
| # between the write to /sys/power/wakeup_count and the write to |
| # /sys/power/state (i.e. the write to /sys/power/state failed with EBUSY). |
| readonly RESULT_CANCELED_LATE=3 |
| |
| # Histogram-only max value. |
| readonly RESULT_MAX=4 |
| |
| # Directory where this script and send_metrics_on_resume (running as root) |
| # write temporary state files. |
| readonly ROOT_RUN_DIR=/run/power_manager/root |
| |
| # For testing: write RTC resume timestamp to this file if it exists |
| readonly TIMESTAMP_FILE="${ROOT_RUN_DIR}"/hwclock-on-resume |
| |
| # File used to record the power status (AC vs. battery) before suspending. Read |
| # by send_metrics_on_resume (but only when run after resuming; this doesn't |
| # need to persist across reboots). |
| readonly POWER_STATUS_ON_SUSPEND_FILE="${ROOT_RUN_DIR}"/power-status-on-suspend |
| |
| # File containing resume-related timing information. Written by |
| # send_metrics_on_resume and read by autotests; doesn't need to persist |
| # across reboots. |
| readonly LAST_RESUME_TIMINGS_FILE="${ROOT_RUN_DIR}"/last_resume_timings |
| |
| # Directory where this script (running as root) writes files that must |
| # persist across reboots. |
| readonly ROOT_SPOOL_DIR=/var/spool/power_manager/root |
| |
| # File containing the time at which we started suspending. Read by |
| # send_metrics_on_resume. |
| readonly SUSPEND_TO_RAM_TIME_FILE="${ROOT_SPOOL_DIR}"/suspend-to-ram-time |
| |
| # File containing suspend-related information to log on failure. |
| readonly SUSPEND_STATS_FILE=/sys/kernel/debug/suspend_stats |
| |
| # Compact if order 3 page count is less than this. |
| readonly COMPACT_ORDER3_THRESHOLD=500 |
| |
| # For testing: do not compact before suspending if this file exists. |
| readonly NO_COMPACT_FILE="${ROOT_RUN_DIR}"/no-compact |
| |
| log_msg() { |
| logger -t "powerd_suspend" --id="$$" -- "$@" |
| } |
| |
| log_msg_from_file() { |
| logger -t "powerd_suspend" --id="$$" -f "$1" |
| } |
| |
| log_wakeup_count() { |
| log_msg "wakeup_count is $(cat /sys/power/wakeup_count)" |
| } |
| |
| log_suspend_stats() { |
| log_msg "--- begin ${SUSPEND_STATS_FILE} ---" |
| local tempfile="$(mktemp --tmpdir powerd_suspend_stats.XXXXXXXXXX)" |
| # Omit blank lines and replace tabs with spaces so syslog won't escape them |
| # to "#011". |
| grep -e '\S' "${SUSPEND_STATS_FILE}" | tr '\t' ' ' >"${tempfile}" |
| log_msg_from_file "${tempfile}" |
| log_msg "--- end ${SUSPEND_STATS_FILE} ---" |
| rm "${tempfile}" |
| } |
| |
| is_kip() { |
| crossystem hwid | grep -q '^KIP ' |
| } |
| |
| # Checks if the system has a Huawei Technologies Mobile Broadband Module. |
| has_huawei_modem() { |
| lsusb -d 12d1:15bb |
| } |
| |
| # Powers "on" or "off" the built-in modem via EC. |
| ec_power_modem() { |
| local op="$1" |
| |
| case "${op}" in |
| on) |
| ectool wireless 0x4 0x4 |
| ;; |
| off) |
| ectool wireless 0x0 0x4 |
| ;; |
| *) |
| log_msg "Invalid operation 'ec_power_modem ${op}'" |
| return 1 |
| ;; |
| esac |
| |
| if [ $? -eq 0 ]; then |
| log_msg "Power ${op} built-in modem" |
| return 0 |
| else |
| log_msg "Failed to power ${op} built-in modem" |
| return 1 |
| fi |
| } |
| |
| to_hex() { |
| echo "obase=16; $(($1))" | bc |
| } |
| |
| |
| # Exit Sniff mode for all ACL connections. |
| # |
| # This workaround is to make sure BlueZ stack and the controller are aligned |
| # on connections state after resume, since the 'sniff mode change' event could |
| # have been masked out while the system was is suspend mode |
| bt_exit_sniff() { |
| local file |
| for file in /sys/class/bluetooth/hci[0-9]; do |
| local hcidev="$(basename "${file}")" |
| # The command of "hcitool con" shows something like |
| # Connections: |
| # > ACL 04:52:C7:83:95:10 handle 256 state 1 lm MASTER AUTH ENCRYPT |
| # > ACL 04:52:C7:C3:65:B5 handle 512 state 1 lm MASTER AUTH ENCRYPT |
| |
| handles="$(echo "$(hcitool con)" | awk '/ACL/ {print $5}')" |
| for handle in $handles; do |
| lo_byte="$(to_hex $((handle % 256)))" |
| hi_byte="$(to_hex $((handle / 256)))" |
| log_msg "Exiting Sniff mode for connection handle ${lo_byte} ${hi_byte}" |
| timeout -k 2 2 hcitool -i "${hcidev}" cmd 02 04 "${lo_byte}" \ |
| "${hi_byte}" |
| done |
| done |
| } |
| |
| # Writes the wakeup count that was passed to this script to |
| # /sys/power/wakeup_count. Returns success if the write fails, indicating |
| # that one or more wakeup events occurred in the meantime. |
| saw_wakeup_event() { |
| if [ "${FLAGS_wakeup_count}" -eq -1 ] || |
| echo "${FLAGS_wakeup_count}" > /sys/power/wakeup_count; then |
| return 1 |
| else |
| log_msg "Aborting suspend, wake event received" |
| log_wakeup_count |
| return 0 |
| fi |
| } |
| |
| |
| # Sends suspend result (one of the above RESULT_* values) to UMA. |
| send_uma_result() { |
| metrics_client -e Power.SuspendResult "$1" "${RESULT_MAX}" & |
| } |
| |
| # Gets the allocatable order 3 page count. Using order 3 threshold because |
| # there are many order 3 allocation by network modules when running low memory |
| # suspending stress test. /proc/pagetypeinfo provides available high order |
| # pages count, example: |
| # Free pages count per migrate type at order 0 1 2 3 4 ... 10 |
| # ... |
| # Node 0, zone DMA32, type Unmovable 1 9 29 5 2 ... 0 |
| # Node 0, zone DMA32, type Reclaimable 160 204 17 8 0 ... 0 |
| # Node 0, zone DMA32, type Movable 0 1163 1530 1236 298 ... 0 |
| # Node 0, zone DMA32, type Reserve 0 0 0 0 0 ... 2 |
| # Movable order 3 field 1236: there are 1236 order 3 pages ((2 ^ 3) * 4KB |
| # consecutive memory). |
| order3_available() { |
| awk '(NF == 17) && |
| ($6 == "Unmovable" || $6 == "Movable" || $6 == "Reclaimable") { |
| size = 1 |
| for (i = 10; i <= 17; i++) { |
| sum += $i * size |
| size *= 2 |
| } |
| } |
| END { print sum }' /proc/pagetypeinfo |
| } |
| |
| # When system is suspending, memory compaction and swap are disabled. If |
| # memory is fragmented at this time, high order allocation would fail. |
| # When memory fragmentation is detected (too few allocatable order 3 pages), |
| # compact memory before suspending. For 4.4 or earlier kernel without |
| # kcompactd. |
| # TODO(crbug.com/827053): Check if compaction before suspending is necessary |
| # on newer kernel. |
| try_compact_memory() { |
| local order3="$(order3_available)" |
| log_msg "Available order 3 pages: ${order3}" |
| if uname -r | grep -q "^3\.\|^4\.4\." && [ ! -f ${NO_COMPACT_FILE} ] && \ |
| [ "${order3}" -le "${COMPACT_ORDER3_THRESHOLD}" ]; then |
| log_msg "Compacting memory before suspend" |
| echo 1 > /proc/sys/vm/compact_memory |
| log_msg "Available order 3 pages after compaction: $(order3_available)" |
| fi |
| } |
| |
| # Encourage people to use powerd_dbus_suspend instead of running this |
| # script directly so that e.g. suspend delays will happen. |
| if [ -z "${POWERD_SETUID_HELPER}" ]; then |
| echo "This script is called by powerd. Please run powerd_dbus_suspend" 1>&2 |
| echo "to manually exercise the full suspend path." 1>&2 |
| exit 1 |
| fi |
| |
| # Note: Don't change or remove this line without also updating |
| # send_metrics_on_resume. |
| log_msg "Going to suspend-to-RAM state: args=$@" |
| |
| # Parse command line. |
| FLAGS "$@" || exit 1 |
| eval set -- "${FLAGS_ARGV}" |
| |
| # The metrics library requires a max value of 2 rather than 1 |
| # (http://crbug.com/338015). |
| metrics_client -e Power.SuspendAttempt 0 2 & |
| |
| # Log the time before going to suspend (no-op if no RTC). |
| cp /sys/class/rtc/rtc0/since_epoch "${SUSPEND_TO_RAM_TIME_FILE}" \ |
| 2> /dev/null || true |
| |
| # Remove last_resume_timings to ensure the file is fresh on resume. |
| rm -f "${LAST_RESUME_TIMINGS_FILE}" |
| |
| # Store the current power status. |
| power_supply_info 2> /dev/null \ |
| | grep -Eq '^[[:space:]]+online:[[:space:]]+no$' |
| if [ $? -eq 0 ]; then |
| echo OnBattery > "${POWER_STATUS_ON_SUSPEND_FILE}" |
| else |
| echo OnAC > "${POWER_STATUS_ON_SUSPEND_FILE}" |
| fi |
| |
| # Is this a Kip system with Huawei modem? |
| kip_with_huawei_modem=0 |
| if is_kip && has_huawei_modem; then |
| log_msg "Kip with Huawei modem" |
| kip_with_huawei_modem=1 |
| fi |
| |
| result="${RESULT_FAILURE}" |
| |
| if saw_wakeup_event; then |
| # Note: The client/cros/power_suspend.py module in autotest depends on |
| # this message. |
| log_msg "Cancel suspend at kernel" |
| |
| # This file is usually removed by send_metrics_on_resume, but that script |
| # isn't run if the suspend attempt is unsuccessful. |
| rm -f "${SUSPEND_TO_RAM_TIME_FILE}" |
| |
| result="${RESULT_CANCELED_EARLY}" |
| else |
| # Before suspending, power down this problematic modem. |
| if [ "${kip_with_huawei_modem}" -eq 1 ]; then |
| ec_power_modem off |
| fi |
| |
| # Compact memory if it is fragmented. |
| try_compact_memory |
| |
| log_msg "Finalizing suspend" |
| # Make sure that hwclock is cached for when we wake up, this way we don't |
| # wait for io and get a more accurate time for wakeup |
| # -V prints a little version information and exits, loading .so but not |
| # making actual RTC accesses. Do *NOT* change this to a normal execution... |
| # it will trigger an RTC interrupt that may count as a wakeup reason, abort |
| # your suspend and cause you hours of pain and confusion! |
| if [ -f "${TIMESTAMP_FILE}" ]; then |
| /sbin/hwclock -V > /dev/null |
| fi |
| |
| # Echo freeze to /sys/power/state on platforms that support suspend to idle. |
| action='mem' |
| if [ "${FLAGS_suspend_to_idle}" -eq 0 ]; then |
| action='freeze' |
| fi |
| |
| # Suspend to RAM. This is piped through cat since we want to determine |
| # the causes of failures -- dash's "echo" command appears to not print |
| # anything in response to write errors. |
| error=$( (printf '%s' "${action}" | cat > /sys/power/state) 2>&1) |
| if [ $? -eq 0 ]; then |
| # On resume: |
| result="${RESULT_SUCCESS}" |
| |
| if [ -f "${TIMESTAMP_FILE}" ]; then |
| # Record the hwclock time at resume for the power_Resume test. |
| if /sbin/hwclock -r --utc > "${TIMESTAMP_FILE}" 2>&1; then |
| log_msg "Recorded hwclock time for test" |
| else |
| log_msg "/sbin/hwclock failed: $(cat "${TIMESTAMP_FILE}")" |
| log_msg "debug: $(/sbin/hwclock -r --debug --utc 2>&1)" |
| fi |
| fi |
| |
| if [ -e /sys/firmware/log ]; then |
| # Grep /sys/firmware/log for WAK. |
| # shellcheck disable=SC2002 |
| # cat is required because tac is unable to correctly processes |
| # /sys/firmware/log. tac reads in 8k chunks, but the kernel only returns |
| # 4k chunks. |
| wakeup_source="$(cat /sys/firmware/log | tac | \ |
| grep -m1 -A1 -B1 "PM1_STS: WAK" | tac)" |
| if [ -z "${wakeup_source}" ]; then |
| wakeup_source='unknown' |
| fi |
| log_msg "wake source: ${wakeup_source}" |
| fi |
| |
| # Send UMA metrics. |
| send_metrics_on_resume & |
| else |
| # The write will fail with EBUSY if additional wakeup events have |
| # occurred since the earlier write to /sys/power/wakeup_count. Since this |
| # can happen if e.g. a device fails to suspend, we check the wakeup count |
| # again to make sure it has actually gone up. |
| current_wakeup_count="$(cat /sys/power/wakeup_count)" |
| if echo "${error}" | grep -q 'Device or resource busy' && \ |
| [ "${FLAGS_wakeup_count}" -ne -1 ] && \ |
| [ "${FLAGS_wakeup_count}" -ne "${current_wakeup_count}" ]; then |
| log_msg "Warning: Device or resource busy on write to /sys/power/state" |
| log_suspend_stats |
| log_wakeup_count |
| result="${RESULT_CANCELED_LATE}" |
| else |
| # Note: The client/cros/power_suspend.py module in autotest depends on |
| # this message. |
| log_msg "Error writing to /sys/power/state: ${error}" |
| log_suspend_stats |
| result="${RESULT_FAILURE}" |
| fi |
| fi |
| |
| # Power back on the Huawei modem if it was powered off before suspend. |
| if [ "${kip_with_huawei_modem}" -eq 1 ]; then |
| ec_power_modem on |
| fi |
| |
| bt_exit_sniff |
| fi |
| |
| send_uma_result "${result}" |
| |
| # Refresh mosys eventlog to help feedback reports pick up the latest snapshot. |
| /usr/share/userfeedback/scripts/eventlog & |
| |
| log_msg "Resume finished" |
| |
| return "${result}" |