Come passare automaticamente da Suspend a Hibernate?


53

È possibile portare Ubuntu nello stato di Hibernate da Suspend, alias "Suspend Sedation"?

Quello che sto cercando è questo:
quando chiudo il coperchio, il laptop viene messo in sospensione. Quindi, dopo un tempo prestabilito (anche se la batteria si sta esaurendo) se ancora non la uso, dovrebbe mettersi in letargo per risparmiare energia.

Ad esempio, il mio laptop è impostato per andare in sospensione dopo aver chiuso il coperchio. Se poi non lo uso per tutto il giorno, la batteria si scarica, perché anche in modalità di sospensione l'hardware consuma ancora una piccola quantità di energia e alla fine la batteria si scarica. Quello che voglio è poter dire a Ubuntu che anche se è sospeso, deve ancora andare in ibernazione dopo alcune ore di inattività.

Windows può farlo. Ubuntu può essere programmato per andare in standby o ibernazione con il timer, ma non entrambi.


Nella mia ricerca ho trovato lo stesso thread di Linux Mint, ma "Suspend Sedation" non è un termine ufficiale di Microsoft per quella funzionalità e, per quanto ne so, è stato inventato dall'utente del forum di Linux Mint che lo ha menzionato.
ayan4m1,

C'è un nome migliore per quella funzione?
Sergey Stadnik,

Per quanto ne so, non esiste un nome universalmente accettato per la funzione. "Sospensione ibrida" è usata da alcuni, "sospensione sedazione" è usata da quell'utente del forum di Linux Mint, e ho già sentito che "ibernare e sospendere" faceva riferimento al processo prima. Microsoft lo definisce ufficialmente "sospensione ibrida", almeno per Windows 7.
ayan4m1,

2
@ ayan4m1 Mi rendo conto che questa è una vecchia domanda, ma penso che sia importante chiarirlo. La sospensione Hyrbid non è la stessa di "Sospendi quindi ibernazione dopo un periodo di tempo specificato". Il sonno ibrido diventa semplicemente letargo quando si perde energia, quando la batteria si esaurisce. Il comportamento descritto dall'OP non richiede l'abilitazione della sospensione ibrida.
Paul,

Risposte:


20

In Ubuntu 18.04 è molto più semplice. In systemd è disponibile una nuova modalità suspend-then-hibernate . Per iniziare a utilizzare questa funzione è necessario creare un file /etc/systemd/sleep.conf con il contenuto successivo:

[Sleep]
HibernateDelaySec=3600

Quindi puoi testarlo con il comando:

sudo systemctl suspend-then-hibernate

è possibile modificare HibernateDelaySecper ridurre il ritardo in letargo.


Se tutto funziona correttamente, è possibile modificare l'azione di chiusura del coperchio, per farlo è necessario modificare il file /etc/systemd/logind.conf

Devi trovare l'opzione HandleLidSwitch=, decommentarla e cambiarla in HandleLidSwitch=suspend-then-hibernate. Quindi è necessario riavviare il servizio systemd-logind (attenzione! La sessione utente verrà riavviata) dal comando successivo:

sudo systemctl restart systemd-logind.service

È tutto! Ora puoi usare questa bella funzione.


Questo era perfetto. Usandolo su Pop! _OS 18.10 (aka Ubuntu 18.10).
eduncan911,

Grazie brillante! Sleep.conf influenza in qualche modo anche la modalità di ibernazione o influenza solo la sospensione-poi-ibernazione?
user2428107

@ user2428107 puoi leggere le opzioni nel manuale systutorials.com/docs/linux/man/5-systemd-sleep
PRIHLOP

35

La soluzione è semplice. Innanzitutto, dopo la sospensione e il ripristino, il programma pm-suspend esegue una serie di script in /etc/pm/sleep.de /usr/lib/pm-utils/sleep.d. Quindi la mia soluzione è quella di aggiungere uno script che procede come segue:

  1. In caso di sospensione, registrare l'ora corrente e registrare un evento di riattivazione utilizzando rtcwake.
  2. Al riavvio, controllare l'ora corrente rispetto all'ora registrata dall'alto. Se è trascorso abbastanza tempo, probabilmente ci siamo svegliati a causa dell'evento timer RTC. Altrimenti ci siamo svegliati presto a causa di un evento dell'utente (come l'apertura dello schermo del laptop).
  3. Se ci siamo svegliati a causa del timer RTC, emettere immediatamente un comando "pm-hibernate" per andare in letargo.

Ecco uno script che fa questo. Denominalo 0000rtchibernatee posizionalo nella /etc/pm/sleep.ddirectory (lo 0000 è importante, in modo che lo script venga eseguito prima in sospensione e infine in ripresa).

#!/bin/bash
# Script name: /etc/pm/sleep.d/0000rtchibernate
# Purpose: Auto hibernates after a period of sleep
# Edit the "autohibernate" variable below to set the number of seconds to sleep.
curtime=$(date +%s)
autohibernate=7200
echo "$curtime $1" >>/tmp/autohibernate.log
if [ "$1" = "suspend" ]
then
    # Suspending.  Record current time, and set a wake up timer.
    echo "$curtime" >/var/run/pm-utils/locks/rtchibernate.lock
    rtcwake -m no -s $autohibernate
fi

if [ "$1" = "resume" ]
then
    # Coming out of sleep
    sustime=$(cat /var/run/pm-utils/locks/rtchibernate.lock)
    rm /var/run/pm-utils/locks/rtchibernate.lock
    # Did we wake up due to the rtc timer above?
    if [ $(($curtime - $sustime)) -ge $autohibernate ]
    then
        # Then hibernate
        rm /var/run/pm-utils/locks/pm-suspend.lock
        /usr/sbin/pm-hibernate
    else
        # Otherwise cancel the rtc timer and wake up normally.
        rtcwake -m no -s 1
    fi
fi

Spero che questo codice arrivi su questa bacheca (questo è il mio primo post qui).

Modifica il valore di timeout autohibernate=7200in alto, per quanti secondi hai a dormire prima di andare in letargo. Il valore corrente sopra è di 2 ore. Si noti che il laptop si sveglierà in quel momento per alcuni secondi, mentre sta eseguendo la funzione di ibernazione.

Quindi, se hai intenzione di mettere il tuo laptop in una custodia, non sospenderlo, ma in letargo invece. Altrimenti il ​​tuo laptop potrebbe surriscaldarsi in esp. se si trova in una custodia antiscivolo (anche se rimarrà attiva solo da pochi secondi a un minuto).

Ho usato questo metodo negli ultimi due giorni, finora ha avuto successo (e mi ha salvato da una batteria scarica questo pomeriggio). Godere.

Per le altre distribuzioni Linux che utilizzano systemde versioni più recenti di Ubuntu questo dovrebbe funzionare anche se si inserisce lo script /usr/lib/systemd/system-sleepanziché /etc/pm/sleep.d. Inoltre, sostituire il /usr/sbin/pm-hibernatecomando con systemctl hibernate.


Ha funzionato qui, ma solo dopo aver digitato il file per aggiungere X a tutti. Sono un principiante enorme e mi ci sono voluti 2 giorni per capire. Ottima sceneggiatura e spero che questo aiuti chiunque potrebbe avere problemi. Grazie.

2
Ciò renderebbe un utile pacchetto Ubuntu / Debian!
Petr Pudlák il

Mi chiedo: sarebbe ancora valido per Ubuntu 13.04? Ho bisogno esattamente di questa soluzione, ma non voglio fare casino con il laptop della moglie se si scopre che si rompe qualcosa nelle versioni più recenti.
Torben Gundtofte-Bruun,

Grazie per la sceneggiatura. Funziona bene per me su Ubuntu 14.04! Un miglioramento sarebbe se quando il laptop si sveglia per andare in letargo, potrebbe verificare se è collegato all'alimentazione CA. Se è così, vorrei che sospendesse di nuovo invece di andare in letargo. Il ripristino dall'ibernazione richiede più tempo e in realtà non ne ho davvero bisogno per andare in letargo quando è collegato ...
maddentim,

Grazie mille!!!! Questa sceneggiatura è magica che stavo sognando !!
yanpas,

12

Per spiegare come funziona (è simile a Windows) in parole semplici: la macchina non si sveglia dallo standby quando la batteria si scarica per poter salvare lo stato della macchina sulla partizione di swap, salva immediatamente tutto sulla partizione di swap in standby e quando la batteria si esaurisce, si ripristinerà caricando lo stato dalla partizione di swap (come farebbe in caso di ibernazione).

AFAIK Linux utilizzerà / dovrebbe utilizzare l'ibrido standby / ibernazione anziché lo standby "normale" se sa che funziona per il tuo hardware. È anche possibile che questo sia disabilitato attualmente a causa di troppi bug o qualcosa del genere ...;)

Se ti piace sperimentare, forse puoi vedere se puoi ottenere buoni risultati con pm-suspend-hybrid .

Se quanto segue dice che sei fortunato, in teoria la sospensione ibrida è supportata sul tuo sistema:

pm-is-supported --suspend-hybrid && echo "you're lucky"

1
L'apostrofo singolo nel comando della shell potrebbe essere fuorviante e confuso ... per favore, scappatelo.
ayan4m1,

1
Bah, ecco cosa succede quando modifichi una riga di comando incorporata in un altro testo, senza pensarci come una riga di comando ... Grazie e risolto.
JanC

Nessun problema, sì, ho capito i diversi spazi di testa per i due processi.
ayan4m1,

6

Potresti essere interessato a s2both . È fornito dal pacchetto uswsuspin Ubuntu 10.10. Si sospende su disco, ma invece di arrestare il sistema invece lo mette in S3, che è la modalità di alimentazione solitamente associata all'opzione "Sospendi" in Ubuntu. pm-suspend-hybrid è un altro strumento che pretende di fare la stessa cosa.

Per rendere questo automatizzato sul coperchio, dai un'occhiata alla seguente guida che ti permette di eseguire uno script arbitrario quando viene rilevato un evento lid:

http://ubuntuforums.org/showthread.php?t=1076486

Se ti capita di avere un ThinkPad, la manpage di tpctlfa riferimento a un argomento --pm-sedation-hibernate-from-suspend-timer, che sembra fornire la funzionalità che stai cercando. Ti consiglierei di non provare questo su hardware non ThinkPad.

Per riferimento, ho cercato nella manpage hibernate.conf ; non sembrava avere alcuna opzione pertinente, ma potrebbe valere la pena di leggerlo una seconda volta.


5

Ubuntu 16.04 - dalla sospensione / sospensione in ibernazione dopo un tempo predeterminato

Sembra che su Ubuntu 16.04 le cose siano leggermente diverse, quindi i passaggi che ho preso per farlo funzionare sono stati:

  1. Assicurarsi che l'ibernazione funzioni come previsto durante l'esecuzione

    systemctl hibernate
    
  2. Copia il suspend.targetfile originale :

    sudo cp /lib/systemd/system/suspend.target /etc/systemd/system/suspend.target
    

    Quindi modifica il file /etc/systemd/system/suspend.targete aggiungi la riga:

    Requires=delayed-hibernation.service
    

    alla [Unit]sezione di quel file.

  3. Creare il file /etc/systemd/system/delayed-hibernation.servicecon il seguente contenuto:

[Unità]
Descrizione = Trigger di ibernazione ritardata
Prima = suspend.target
Conflicts = hibernate.target hybrid-suspend.target
StopWhenUnneeded = true

[Servizio]
Tipo = oneshot
RemainAfterExit = yes
ExecStart = / usr / local / bin / delayed-hibernation.sh pre suspend
ExecStop = / usr / local / bin / delayed-hibernation.sh post suspend

[Installare]
WantedBy = sleep.target
  1. Creare il file di configurazione /etc/delayed-hibernation.confper lo script con il seguente contenuto:
# File di configurazione per lo script 'delayed-hibernation.sh'

# Specificare il tempo in secondi da trascorrere in modalità sospensione prima che il computer rimanga in letargo
TIMEOUT = 1200 # in secondi, dà 20 minuti
  1. Crea lo script che farà davvero il duro lavoro.

    Crea file /usr/local/bin/delayed-hibernation.shcon il contenuto:

#! / Bin / bash
# Nome dello script: delayed-hibernation.sh
# Scopo: l'ibernazione automatica dopo un periodo di sonno
# Modifica la variabile `TIMEOUT` nel file` $ hibernation_conf` per impostare il numero di secondi di sospensione.

hibernation_lock = '/ var / run / ritardata hibernation.lock'
= hibernation_fail '/ var / run / delayed-hibernation.fail'
hibernation_conf = '/ etc / ritardata hibernation.conf'

# Verifica del file di configurazione
Se [ ! -f $ hibernation_conf]; poi
    echo "File di configurazione mancante ('$ hibernation_conf'), interruzione."
    uscita 1
fi
hibernation_timeout = $ (grep "^ [^ #]" $ hibernation_conf | grep "TIMEOUT =" | awk -F '=' '{print $ 2}' | awk -F '#' '{print $ 1}' | tr -d '[[\ t]]')
if ["$ hibernation_timeout" = ""]; poi
    echo "Parametro 'TIMEOUT' mancante dal file di configurazione ('$ hibernation_conf'), interruzione."
    uscita 1
elif [[! "$ hibernation_timeout" = ~ ^ [0-9] + $]]; poi
    echo "Parametro 'TIMEOUT' errato ('$ hibernation_timeout') nel file di configurazione ('$ hibernation_conf'), numero atteso di secondi, interruzione."
    uscita 1
fi

# Elaborazione dei parametri forniti
if ["$ 2" = "suspend"]; poi
    curtime = $ (data +% s)
    if ["$ 1" = "pre"]; poi
        if [-f $ hibernation_fail]; poi
            echo "Rilevato ibernazione non riuscita, saltando l'impostazione timer sveglia RTC."
        altro
            echo "Sospensione rilevata. Tempo di registrazione, imposta timer RTC"
            echo "$ curtime"> $ hibernation_lock
            rtcwake -m no -s $ hibernation_timeout
        fi
    elif ["$ 1" = "post"]; poi
        if [-f $ hibernation_fail]; poi
            rm $ hibernation_fail
        fi
        if [-f $ hibernation_lock]; poi
            sustime = $ (cat $ hibernation_lock)
            rm $ hibernation_lock
            if [$ (($ curtime - $ sustime)) -ge $ hibernation_timeout]; poi
                echo "Rilevato ripristino automatico dalla sospensione. Ibernazione ..."
                ibernazione di sistema
                se [$? -ne 0]; poi
                    echo "Ibernazione automatica non riuscita. Tentativo di sospensione."
                    toccare $ hibernation_fail
                    systemctl suspend
                    se [$? -ne 0]; poi
                        echo "Ibernazione automatica e sospensione del failover non riuscita. Nient'altro da provare."
                    fi
                fi
            altro
                echo "Rilevato ripristino manuale dalla sospensione. Azzeramento del timer RTC"
                rtcwake -m disable
            fi
        altro
            echo "Il file '$ hibernation_lock' non è stato trovato, niente da fare"
        fi
    altro
        echo "Primo parametro non riconosciuto: '$ 1', previsto 'pre' o 'post'"
    fi
altro
    echo "Questo script deve essere eseguito da systemctl delayed-hibernation.service (secondo parametro previsto: 'suspend')"
fi
  1. Rendi eseguibile lo script:
chmod 755 /usr/local/bin/delayed-hibernation.sh

Mi ci è voluto un bel po 'prima di scrivere questo script basato su altre risposte in questo thread, cose che ho trovato su Internet come https://bbs.archlinux.org/viewtopic.php?pid=1554259

La mia versione dello script cerca di affrontare molti problemi come andare nuovamente in sospensione se l'ibernazione non ha avuto successo ma non si risveglia dopo il tempo predeterminato più e più volte.

  1. Il passo finale presumo sarebbe solo quello di eseguire

    sudo systemctl daemon-reload
    sudo systemctl enable delayed-hibernation.service 
    

    per assicurarsi che vengano utilizzati nuovi servizi / configurazioni.

Per controllare il registro dei servizi, è possibile utilizzare:

sudo systemctl status delayed-hibernation.service

o per un registro completo del servizio utilizzare:

sudo journalctl -u delayed-hibernation.service

Un registro normale che ottengo dal servizio in esecuzione è:

mile @ mile-ThinkPad: ~ $ sudo systemctl status delayed-hibernation.service 
● delayed-hibernation.service - Trigger di ibernazione ritardata
   Caricato: caricato (/etc/systemd/system/delayed-hibernation.service; abilitato; preset fornitore: abilitato)
   Attivo: inattivo (morto)

09 giu 20:35:42 mile-ThinkPad systemd [1]: Avvio del trigger di ibernazione ritardato ...
09 giu 20:35:42 mile-ThinkPad delayed-hibernation.sh [2933]: Rilevata sospensione. Tempo di registrazione, impostare il timer RTC
09 giu 20:35:42 mile-ThinkPad delayed-hibernation.sh [2933]: rtcwake: supponendo che RTC usi UTC ...
09 giu 20:35:42 mile-ThinkPad delayed-hibernation.sh [2933]: rtcwake: wakeup using / dev / rtc0 a gio 9 giu 18:55:43 2016
09 giu 20:55:44 mile-ThinkPad systemd [1]: Started Ritardato ibernazione ritardata.
09 giu 20:55:44 mile-ThinkPad systemd [1]: delayed-hibernation.service: unità non più necessaria. Arresto.
09 giu 20:55:44 mile-ThinkPad systemd [1]: Arresto del trigger di ibernazione ritardato ...
09 giu 20:55:44 mile-ThinkPad delayed-hibernation.sh [3093]: Rilevato ripristino automatico dalla sospensione. Hibernating ...
09 giu 20:55:44 mile-ThinkPad systemd [1]: Interruzione del trigger di ibernazione ritardata.
miglio @ miglio-ThinkPad: ~ $ 

Quindi questo sarebbe, spero che aiuti davvero qualcuno dal momento che ho passato giorni a cercare di capire la giusta combinazione di configurazioni e versioni di script per far funzionare questa utile funzionalità.


Grazie per la risposta, questo funziona ancora come un fascino su Ubuntu 18.04. Non riuscivo a far funzionare le risposte di cui sopra, l'esecuzione /bin/systemctl hibernateavrebbe sempre restituito 1 durante l'esecuzione nello script systemd, anche se funziona correttamente sulla riga di comando.
Eugenhu,

4

Nel caso in cui qualcosa vada storto, pm-hibernatepreferirei sospendere il computer piuttosto che lasciarlo funzionare. Quindi puoi usare:

   ...
/usr/sbin/pm-hibernate || /usr/sbin/pm-suspend
   ...

3

Ecco una versione aggiornata della risposta di Derek Pressnall che funziona con systemd e include il suggerimento di Eliah Kagan , basta inserirlo in /usr/lib/systemd/system-sleep/delayed_hibernation.sh e renderlo eseguibile:

#!/bin/bash

hibernation_timeout=1800  #30 minutes

if [ "$2" = "suspend" ]; then
    curtime=$(date +%s)
    if [ "$1" = "pre" ]; then
        echo -e "[($curtime) $@]\nExecuting pre-suspend hook..." >> /tmp/delayed_hibernation.log
        echo "$curtime" > /var/run/delayed_hibernation.lock
        rtcwake -m no -s $hibernation_timeout
    elif [ "$1" = "post" ]; then
        echo -e "[($curtime) $@]\nExecuting post-suspend hook..." >> /tmp/delayed_hibernation.log
        sustime=$(cat /var/run/delayed_hibernation.lock)
        if [ $(($curtime - $sustime)) -ge $hibernation_timeout ]; then
            echo -e "Automatic resume detected, hibernating.\n" >> /tmp/delayed_hibernation.log
            systemctl hibernate || systemctl suspend
        else
            echo -e "Manual resume detected, clearing RTC alarm.\n" >> /tmp/delayed_hibernation.log
            rtcwake -m no -s 1
        fi
        rm /var/run/delayed_hibernation.lock
    fi
fi

Questo ha funzionato benissimo per diversi mesi il 15.10, ma qualcosa circa 16.04 gli impedisce di andare in letargo anche se lo script è ancora in esecuzione.
Sean,

@Sean hai provato la soluzione alternativa in questo thread ?
Niccolò Maggioni,

Grazie per avermi indicato nella giusta direzione. Ho creato un servizio systemd (/etc/systemd/system/delayed-hibernation.service) che faceva riferimento allo script sopra quindi modificato /etc/systemd/system/suspend.target per richiedere il ritardo-ibernazione.service.
Sean,

2

Ecco la mia ricetta (testata su due notebook Ubuntu 16.04):

Metti questo script dove vuoi (l'ho messo alla radice, /syspend.sh) e rendilo eseguibile ( chmod +x /suspend.sh)

TIMELOG=/tmp/autohibernate.log
ALARM=$(tail -n 1 $TIMELOG)
SLEEPTIME=5000 #edit this line to change timer, e.g. 2 hours "$((2*60*60))"
if [[ $1 == "resume" ]]
then
    if [[ $(date +%s) -ge $(( $ALARM + $SLEEPTIME )) ]]
    then
        echo "hibernate triggered $(date +%H:%M:%S)">>$TIMELOG
        systemctl hibernate 2>> $TIMELOG
    else
        echo "normal wakeup $(date +%H:%M:%S)">>$TIMELOG
    fi
elif [[ $1 == "suspend" ]]
then
    echo "$(date +%s)" >> $TIMELOG
    rtcwake -m no -s $SLEEPTIME
fi

Quindi crea destinazione systemd: # touch /etc/systemd/system/suspend-to-sleep.target incolla questo contenuto:

#/etc/systemd/system/suspend-to-hibernate.service
[Unit]
Description=Delayed hibernation trigger
Before=suspend.target
Conflicts=hibernate.target hybrid-suspend.target
StopWhenUnneeded=true

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/bash /suspend.sh suspend
ExecStop=/bin/bash /suspend.sh wakeup

[Install]
WantedBy=sleep.target
RequiredBy=suspend.target

Quindi abilitalo # systemctl enable suspend-to-sleep.target .

Ho riscontrato un problema su quello dei notebook: chiudere il coperchio non ha innescato questo obiettivo. Ciò era dovuto a xfce4-power-manager. Esistono due modi per risolvere questo problema. Il primo è modificare il /etc/systemd/logind.conffile e sostituirlo HandleLidSwitch=ignorecon HandleLidSwitch=suspend. Ma sarà a livello di sistema, quindi ho appena aggiunto il link simbolico al mio script# ln -s /suspend.sh /etc/pm/sleep.d/0000rtchibernate


1

Un'altra soluzione più comune che puoi usare hybrid-sleep(come fa Mac OS). Se il tuo computer supporta l'ibernazione, puoi utilizzare questa funzione:

systemctl hybrid-sleep

Tale comando dovrebbe sospendere e inviare al disco (ibernazione) il computer. Dopo qualche tempo il computer si spegnerà (all'accensione, utilizzerà i file di ibernazione per riattivarsi).

ps: so che non è esattamente ciò che l'OP ha pubblicato, ma è abbastanza vicino


0

Non dimenticare di chmod + x quel file, rendilo eseguibile.

C'è un'altra soluzione senza rtcwake, usando wakealarm in / sys / class / rtc / rtc0. Usa il codice obsoleto nelle funzioni pm (/ usr / lib / pm-utils) dopo i commenti # poiché il kernel non supporta direttamente ..., (quindi il kernel corrente (dopo 3.6 qualcosa) supporta direttamente). Ripristina quel codice e inserisci la parte do_suspend () invece di do_suspend_hybrid ().

Codice obsoleto (sospendi quindi ibernazione quando viene chiamato suspend_hybrid):

# since the kernel does not directly support hybrid sleep, we do
# something else -- suspend and schedule an alarm to go into
# hibernate if we have slept long enough.
# Only do this if we do not need to do any special video hackery on resume
# from hibernate, though.
if [ -z "$SUSPEND_HYBRID_MODULE" -a -w "$PM_RTC/wakealarm" ] && \
    check_suspend && check_hibernate && ! is_set $HIBERNATE_RESUME_POST_VIDEO; \
    then
    SUSPEND_HYBRID_MODULE="kernel"
    do_suspend_hybrid() {
    WAKETIME=$(( $(cat "$PM_RTC/since_epoch") + PM_HIBERNATE_DELAY))
    echo >"$PM_RTC/wakealarm"
    echo $WAKETIME > "$PM_RTC/wakealarm"
    if do_suspend; then
        NOW=$(cat "$PM_RTC/since_epoch")
        if [ "$NOW" -ge "$WAKETIME" -a "$NOW" -lt $((WAKETIME + 30)) ]; then
        log "Woken by RTC alarm, hibernating."
        # if hibernate fails for any reason, go back to suspend.
        do_hibernate || do_suspend
        else
        echo > "$PM_RTC/wakealarm"
        fi
    else
        # if we cannot suspend, just try to hibernate.
        do_hibernate
    fi
    }
fi

Consigliato. Ancora più facile da usare uswsusp mentre allo stesso tempo massimizza il vantaggio di s2both, ovvero s2both quando viene sospeso. Inserisci il codice ripristinato nella parte do_suspend () del modulo uswsusp (/usr/lib/pm-utils/module.d).

Codice ripristinato (suspend_hybrid quando viene chiamato suspend):

WAKETIME=$(( $(cat "$PM_RTC/since_epoch") + PM_HIBERNATE_DELAY))
echo >"$PM_RTC/wakealarm"
echo $WAKETIME > "$PM_RTC/wakealarm"
if do_suspend_hybrid; then
    NOW=$(cat "$PM_RTC/since_epoch")
    if [ "$NOW" -ge "$WAKETIME" -a "$NOW" -lt $((WAKETIME + 30)) ];             then
    log "Woken by RTC alarm, hibernating."
    # if hibernate fails for any reason, go back to suspend_hybrid.
    do_hibernate || do_suspend_hybrid
    else
    echo > "$PM_RTC/wakealarm"
    fi
else
    # when do_suspend is being called, convert to suspend_hybrid.
    do_suspend_hybrid
fi      

Con uswsusp, possiamo vedere l'avanzamento della sospensione / ibernazione e il processo inverso visualizzati nel testo, anche se possiamo interromperlo premendo backspace. Senza uswsusp, la sospensione / ibernazione appare e scompare in modo fastidioso, specialmente quando viene attivato il wakealarm ed esegue l'ibernazione (disco s2 in uswsusp). Impostare il periodo di sospensione prima dell'ibernazione nella solita posizione sul file delle funzioni pm.

# variables to handle hibernate after suspend support
PM_HIBERNATE_DELAY=900  # 15 minutes
PM_RTC=/sys/class/rtc/rtc0

Ecco la mod uswsusp: (ricorda, questo modulo è chiamato dalle funzioni pm quindi le variabili inserite sono le stesse)

#!/bin/sh

# disable processing of 90chvt and 99video.
# s2ram and s2disk handle all this stuff internally.
uswsusp_hooks()
{
    disablehook 99video "disabled by uswsusp"
}

# Since we disabled 99video, we need to take responsibility for proper
# quirk handling.  s2ram handles all common video quirks internally,
# so all we have to do is translate the HAL standard options to s2ram options.
uswsusp_get_quirks()
{
    OPTS=""
    ACPI_SLEEP=0
    for opt in $PM_CMDLINE; do
        case "${opt##--quirk-}" in # just quirks, please
            dpms-on)       ;; # no-op
            dpms-suspend)      ;; # no-op
            radeon-off)        OPTS="$OPTS --radeontool" ;;
            reset-brightness)  ;; # no-op
            s3-bios)       ACPI_SLEEP=$(($ACPI_SLEEP + 1)) ;;
            s3-mode)       ACPI_SLEEP=$(($ACPI_SLEEP + 2)) ;;
            vbe-post)      OPTS="$OPTS --vbe_post" ;;
            vbemode-restore)   OPTS="$OPTS --vbe_mode" ;;
            vbestate-restore)  OPTS="$OPTS --vbe_save" ;;
            vga-mode-3)        ;; # no-op
            save-pci)          OPTS="$OPTS --pci_save" ;;
            none)          QUIRK_NONE="true" ;;
            *) continue ;;
        esac
    done
    [ $ACPI_SLEEP -ne 0 ] && OPTS="$OPTS --acpi_sleep $ACPI_SLEEP"
    # if we were told to ignore quirks, do so.
    # This is arguably not the best way to do things, but...
    [ "$QUIRK_NONE" = "true" ] && OPTS=""
}

# Since we disabled 99video, we also need to handle displaying
# help info for the quirks we handle.
uswsusp_help()
{
    echo  # first echo makes it look nicer.
    echo "s2ram video quirk handler options:"
    echo
    echo "  --quirk-radeon-off"
    echo "  --quirk-s3-bios"
    echo "  --quirk-s3-mode"
    echo "  --quirk-vbe-post"
    echo "  --quirk-vbemode-restore"
    echo "  --quirk-vbestate-restore"
    echo "  --quirk-save-pci"
    echo "  --quirk-none"
}

# This idiom is used for all sleep methods.  Only declare the actual
# do_ method if:
# 1: some other sleep module has not already done so, and
# 2: this sleep method can actually work on this system.
#
# For suspend, if SUSPEND_MODULE is set then something else has already
# implemented do_suspend.  We could just check to see of do_suspend was
# already declared using command_exists, but using a dedicated environment
# variable makes it easier to debug when we have to know what sleep module
# ended up claiming ownership of a given sleep method.
if [ -z "$SUSPEND_MODULE" ] && command_exists s2ram && \
    ( grep -q mem /sys/power/state || \
        ( [ -c /dev/pmu ] && check_suspend_pmu; ); ); then
    SUSPEND_MODULE="uswsusp"
    do_suspend()
    {
        WAKETIME=$(( $(cat "$PM_RTC/since_epoch") + PM_HIBERNATE_DELAY))
        echo >"$PM_RTC/wakealarm"
        echo $WAKETIME > "$PM_RTC/wakealarm"
        if do_suspend_hybrid; then
            NOW=$(cat "$PM_RTC/since_epoch")
            if [ "$NOW" -ge "$WAKETIME" -a "$NOW" -lt $((WAKETIME + 30)) ];             then
            log "Woken by RTC alarm, hibernating."
            # if hibernate fails for any reason, go back to suspend_hybrid.
            do_hibernate || do_suspend_hybrid
            else
            echo > "$PM_RTC/wakealarm"
            fi
        else
            # when do_suspend is being called, convert to suspend_hybrid.
            do_suspend_hybrid
        fi      
    }
fi

if [ -z "$HIBERNATE_MODULE" ] && \
    [ -f /sys/power/disk ] && \
    grep -q disk /sys/power/state && \
    [ -c /dev/snapshot ] &&
    command_exists s2disk; then
    HIBERNATE_MODULE="uswsusp"
    do_hibernate()
    {
        s2disk
    }
fi

if [ -z "$SUSPEND_HYBRID_MODULE" ] && 
    grep -q mem /sys/power/state && \
    command_exists s2both && \
    check_hibernate; then
    SUSPEND_HYBRID_MODULE="uswsusp"
    do_suspend_hybrid()
    {   
        uswsusp_get_quirks
        s2both --force $OPTS 
    }
    if [ "$METHOD" = "suspend_hybrid" ]; then
        add_before_hooks uswsusp_hooks
        add_module_help uswsusp_help
    fi
fi  
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.