Linux LPI 101.3: Alternar runlevels/boot targets, desligar e reiniciar o sistema

Hoje iremos falar sobre processos que servem para controlar certas funções do sistema. Esses processos são chamados de daemons ou de serviços.

Muitas vezes precisaremos interromper, iniciar(start) ou reiniciar(restart) alguns serviços; poderemos também fazer serviços iniciarem automaticamente após o start do sistema operacional. Para isso, podemos usar scripts ou programas específicos.

Dentre esses programas para controlar os serviços, temos:

SysVinit( ou System V ou apenas SysV): usado ainda em sistemas unix-like. No linux foi brutalmente substituído pelo systemd.
systemd: é o mais famoso e usado atualmente.
Upstart: esse é antigo, foi uma tentativa da Canonical no Ubuntu e não teve sucesso.

Esses programas acima são chamados de gerenciadores de serviços. O gerenciador de serviço é o primeiro programa a ser iniciado pelo kernel, portanto seu PID (número de identificação do processo) é sempre 1.

Veja o post anterior: Linux LPI 101.2: Detalhes sobre Início ou boot do sistema

Poderá gostar também de: Linux LPI 101.1: Identificar e editar configurações de hardware

Abaixo está uma tabela com resumo do que iremos ver hoje nesse post.

Item	Tipo	Descrição	Exemplo
/etc/inittab	Arquivo	Arquivo de configuração do SysV init usado para definir os runlevels e os processos que devem ser iniciados em cada runlevel.	Não aplicável
shutdown	Comando	Comando usado para desligar ou reiniciar o sistema de forma segura. Pode agendar o desligamento ou reinicialização em um horário específico.	`shutdown -h now` (desligar agora)
init	Comando	Processo pai de todos os outros processos em sistemas Unix-like. É responsável por iniciar todos os outros processos com base no runlevel definido.	`init 3` (muda para o runlevel 3)
/etc/init.d/	Diretório	Diretório que contém scripts de inicialização e parada de serviços em sistemas que utilizam SysV init.	`ls /etc/init.d/` (listar scripts)
telinit	Comando	Comando usado para alterar o runlevel do sistema no SysV init. Ele é um link simbólico para o comando `init`.	`telinit 5` (muda para o runlevel 5)
systemd	Sistema de Inicialização	Sistema de inicialização e gerenciamento de serviços moderno que substituiu o SysV init em muitas distribuições Linux.	Não aplicável
systemctl	Comando	Ferramenta de linha de comando para gerenciar serviços e unidades no systemd, como iniciar, parar, reiniciar serviços, além de verificar o status.	`systemctl start nginx` (inicia o serviço nginx)
/etc/systemd/	Diretório	Diretório de configuração do systemd, contendo arquivos de configuração e scripts de serviços personalizados.	`ls /etc/systemd/` (listar arquivos)
/usr/lib/systemd/	Diretório	Diretório que contém arquivos de unidade e scripts de serviços padrão fornecidos pelo systemd.	`ls /usr/lib/systemd/system/` (listar unidades)
wall	Comando	Comando usado para enviar mensagens para todos os usuários conectados ao sistema, exibindo-as em seus terminais.	`echo “Manutenção às 18h” \| wall

Gerenciador de Serviço SysVinit

O SysVinit possui estados do sistema prontos, ou, melhor, estados predefinidos para o sistema. A esses estados predefiidos chamamos de níveis de execução. Os níveis de execução são numerados de 0 a 6:

Runlevel 0: Desliga o sistema. Execute no shell: init 0
Runlevel 1: Modo monousuário (usado para manutenção). Execute no shell: init 1
Runlevel 2: Modo multiusuário sem rede. Praticamente nunca é usado. Execute no shell: init 2
Runlevel 3: Modo multiusuário com rede (sem GUI). Execute no shell: init 3
Runlevel 4: Personalizado (não utilizado por padrão). Praticamente nunca é usado. Execute no shell: init 4
Runlevel 5: Modo multiusuário com rede e GUI. Execute no shell: init 5
Runlevel 6: Reinicializa o sistema. Execute no shell: init 6

/sbin/init é o programa responsável por gerenciar esses níveis. Podemos executar /sbin/init ou apenas init. Durante a inicialização do sistema, o programa init identifica o nível de execução solicitado, definido por um parâmetro do kernel ou no arquivo /etc/inittab e carrega os scripts associados listados ali para o nível de execução especificado.

O arquivo /etc/inittab tem conteúdo com essa sintaxe:

id:runlevels:action:process

Aqui está um exemplo real:

id:5:initdefault:
si::sysinit:/etc/init.d/rcS
l0:0:wait:/etc/rc.d/rc 0

Onde,

id:5:initdefault:: Define o runlevel 5 como o padrão para inicialização.
si::sysinit:/etc/init.d/rcS: Durante a inicialização do sistema, o script /etc/init.d/rcS será executado.
l0:0:wait:/etc/rc.d/rc 0: No runlevel 0 (desligamento), o script /etc/rc.d/rc 0 será executado e o sistema esperará que ele termine antes de prosseguir.

Vamos detalhar melhor esse formato de arquivo:

id:
- Descrição: Identificador único para a linha de configuração. Normalmente, é uma sequência de 2 a 4 caracteres que identifica essa entrada específica no arquivo.
- Exemplo: si, l0, ca
runlevels:
- Descrição: Especifica em quais runlevels essa ação será executada. Pode ser um único número (ex.: 3) ou uma sequência de números (ex.: 2345), representando os runlevels para os quais a configuração se aplica.
- Exemplo: 2345 (aplica-se aos runlevels 2, 3, 4 e 5)
action:
- Descrição: Define a ação que será tomada para o processo especificado. As ações comuns incluem:
  - respawn: Reinicia o processo se ele terminar.
  - wait: Executa o processo uma vez, aguardando sua finalização antes de continuar.
  - once: Executa o processo uma vez sem esperar.
  - initdefault: Define o runlevel padrão que o sistema deve iniciar.
  - sysinit: O processo será executado após a inicialização do sistema, qualquer que seja o nível de execução. O campo runlevels é ignorado.
  - boot: O processo será executado durante a inicialização do sistema. O campo runlevels é ignorado.
  - bootwait: O processo será executado durante a inicialização do sistema e o init aguardará sua conclusão para continuar. O campo runlevels é ignorado.
  - ctrlaltdel: O processo será executado quando o processo init receber o sinal SIGINT, disparado quando o atalho de teclado Ctrl + Alt + Del for pressionado.
- Exemplo: respawn, wait, once, initdefault
process:
- Descrição: Especifica o comando ou script que será executado. Pode ser um caminho completo para um script ou binário que será executado no runlevel indicado.
- Exemplo: /sbin/getty 38400 tty1, /etc/rc.d/rc 3

Veja um exemplo mais completo do arquivo /etc/inittab:

# Default runlevel
id:3:initdefault:

# Configuration script executed during boot
si::sysinit:/etc/init.d/rcS

# Action taken on runlevel S (single user)
~:S:wait:/sbin/sulogin
# Configuration for each execution level
l0:0:wait:/etc/init.d/rc 0
l1:1:wait:/etc/init.d/rc 1
l2:2:wait:/etc/init.d/rc 2
l3:3:wait:/etc/init.d/rc 3
l4:4:wait:/etc/init.d/rc 4
l5:5:wait:/etc/init.d/rc 5
l6:6:wait:/etc/init.d/rc 6

# Action taken upon ctrl+alt+del keystroke
ca::ctrlaltdel:/sbin/shutdown -r now

# Enable consoles for runlevels 2 and 3
1:23:respawn:/sbin/getty tty1 VC linux
2:23:respawn:/sbin/getty tty2 VC linux
3:23:respawn:/sbin/getty tty3 VC linux
4:23:respawn:/sbin/getty tty4 VC linux

# For runlevel 3, also enable serial
# terminals ttyS0 and ttyS1 (modem) consoles
S0:3:respawn:/sbin/getty -L 9600 ttyS0 vt320
S1:3:respawn:/sbin/mgetty -x0 -D ttyS1

Toda vez que /etc/inittab for modificado você terá que executar o comando telinit q. O “q” ou “Q” funcionarão.

O comando telinit q fará com que o init recarregue sua configuração.

Pastas do SysVinit

Os scripts usados pelo init para configurar cada nível de execução ficam armazenados no diretório /etc/init.d/.

Diretórios: /etc/rcX.d/ (onde X é o número do runlevel, de 0 a 6)

/etc/rc0.d/: Associado ao runlevel 0 (desligamento do sistema).
/etc/rc1.d/: Associado ao runlevel 1 (modo monousuário).
/etc/rc2.d/: Associado ao runlevel 2 (modo multiusuário sem rede, em algumas distribuições).
/etc/rc3.d/: Associado ao runlevel 3 (modo multiusuário com rede).
/etc/rc4.d/: Associado ao runlevel 4 (não utilizado por padrão, pode ser personalizado).
/etc/rc5.d/: Associado ao runlevel 5 (modo multiusuário com rede e interface gráfica).
/etc/rc6.d/: Associado ao runlevel 6 (reinicialização do sistema).

Cada diretório /etc/rcX.d/ contém links simbólicos para scripts de inicialização que residem em /etc/init.d/.

Ao mudar para um determinado runlevel, o sistema executa os scripts nos diretórios correspondentes, iniciando ou parando serviços conforme necessário para configurar o ambiente adequado ao runlevel em questão.

Esses links simbólicos começam com:

“S” (Start): Indica que o script deve ser iniciado ao entrar no runlevel.

“K” (Kill): Indica que o script deve ser encerrado ao sair do runlevel.

Os números após “S” ou “K” determinam a ordem em que os scripts são executados (ex.: S20nginx).

abaixo executo ls /etc/rc* para listar todos os diretórios iniciados em rc

elder@debian12:~$ ls /etc/rc
rc0.d/ rc1.d/ rc2.d/ rc3.d/ rc4.d/ rc5.d/ rc6.d/ rcS.d/

Vejamos o conteúdo de /etc/rc3.d

elder@debian12:~$ ls -l /etc/rc3.d/
total 0
lrwxrwxrwx 1 root root 29 mai  7 11:49 K01apache-htcacheclean -> ../init.d/apache-htcacheclean
lrwxrwxrwx 1 root root 18 mai 11 08:43 K01corosync -> ../init.d/corosync
lrwxrwxrwx 1 root root 14 mai  7 11:52 K01drbd -> ../init.d/drbd
lrwxrwxrwx 1 root root 14 mai 11 08:43 K01logd -> ../init.d/logd
lrwxrwxrwx 1 root root 19 mai 11 08:43 K01pacemaker -> ../init.d/pacemaker
lrwxrwxrwx 1 root root 17 mai  7 11:49 S01apache2 -> ../init.d/apache2
lrwxrwxrwx 1 root root 26 mai  4 10:20 S01console-setup.sh -> ../init.d/console-setup.sh
lrwxrwxrwx 1 root root 14 mai  4 10:17 S01cron -> ../init.d/cron
lrwxrwxrwx 1 root root 14 mai  4 12:45 S01dbus -> ../init.d/dbus
lrwxrwxrwx 1 root root 15 mai  7 11:52 S01exim4 -> ../init.d/exim4
lrwxrwxrwx 1 root root 17 mai  7 13:04 S01mariadb -> ../init.d/mariadb
lrwxrwxrwx 1 root root 18 mai 11 08:43 S01openhpid -> ../init.d/openhpid
lrwxrwxrwx 1 root root 14 mai 11 08:43 S01pcsd -> ../init.d/pcsd
lrwxrwxrwx 1 root root 19 mai 11 08:43 S01pcsd-ruby -> ../init.d/pcsd-ruby
lrwxrwxrwx 1 root root 15 mai  7 13:03 S01rsync -> ../init.d/rsync
lrwxrwxrwx 1 root root 13 mai  7 12:12 S01ssh -> ../init.d/ssh
lrwxrwxrwx 1 root root 14 jul 29 13:33 S01sudo -> ../init.d/sudo

os arquivos nesses diretórios são apenas links simbólicos para os scripts reais em /etc/init.d/. Isso Links são usados porque o mesmo script pode ser usado por diferentes níveis de execução.

Como saber a runlevel ou nível de execução que estamos atualemente? Estamos na 1, na 3, na 5? Para saber basta executar o comando runlevel:

$ runlevel
N 3

A letra N na saída mostra que o nível de execução não mudou desde a última inicialização. e 3 é o runlevel atual.

Como sair de uma runlevel e entrar em outra? Basta executar o comando “init x”, onde x é o número da runlevel desejada. Abaixo iremos reiniciar o sistema

init 6

Podemos usar tanto init quanto telinit. Abaixo, telinit s ou telinit S levará o sistema para o nível de execução 1.

telinit s

systemd

unidades (units) é como o systemd chama os serviços. Existem sete tipos distintos de unidades(units) systemd:

Service (.service)
- Descrição: Representa um serviço de sistema, como um daemon ou um script que deve ser executado. O tipo de unidade mais comum. Gerencia a ativação, desativação, e status de serviços.
- Exemplo: nginx.service, sshd.service
Socket (.socket)
- Descrição: Um socket é como um ponto de comunicação que permite que dois programas ou processos diferentes “conversem” entre si, seja no mesmo computador ou através da rede. O socket do systemd gerencia sockets de rede ou IPC (Inter-Process Communication) que estão associados a serviços. O tipo de unidade socket pode ser um socket de sistema de arquivos ou um socket de rede. Pode ser usado para ativar um serviço automaticamente quando há atividade em um socket. Escuta em sockets específicos e ativa serviços correspondentes quando necessário. Todas as unidades socket possuem uma unidade de serviço correspondente, carregada quando o socket recebe uma solicitação.
- Exemplo: cups.socket, sshd.socket
- Descrição 02: Imagine que o socket é como uma linha telefônica. Quando você quer falar com alguém, você “liga” (abre um socket) e, se o outro lado atender (outro programa ou serviço está escutando nesse socket), vocês começam a trocar informações (mensagens de rede, dados, etc.). No contexto do systemd, uma unidade de socket (.socket) faz o papel de “escutador”. Ela fica esperando por conexões ou atividade em uma porta de rede específica ou em um canal de comunicação dentro do próprio computador.
Device (.device)
- Descrição: Representa um dispositivo de hardware detectado pelo sistema. Configura ações específicas para quando um dispositivo é detectado ou removido. Um dispositivo só será considerado como uma unidade systemd se existir uma regra udev para isso. Uma unidade de dispositivo pode ser usada para resolver dependências de configuração quando determinado hardware é detectado, uma vez que as propriedades da regra udev podem ser usadas como parâmetros para a unidade de dispositivo.
- Exemplo: dev-sda.device, dev-usb.device
Mount (.mount)
- Descrição: Representa um ponto de montagem para sistemas de arquivos. Configura a montagem automática de sistemas de arquivos. É semelhante a uma entrada em /etc/fstab.
- Exemplo: home.mount, mnt-data.mount
Automount (.automount)
- Descrição: Funciona em conjunto com as unidades de montagem (.mount) para montar sistemas de arquivos sob demanda. Configura a montagem automática de sistemas de arquivos quando acessados.
- Exemplo: home.automount, mnt-data.automount
Target (.target)
- Descrição: Agrupa outras unidades (como serviços e sockets) para alcançar um estado específico do sistema, como inicialização completa ou desligamento. Define estados ou níveis de execução equivalentes aos runlevels no SysVinit.
- Exemplo: multi-user.target, graphical.target
Snapshot (.snapshot)
- Descrição: Representa o estado atual do sistema que pode ser salvo e restaurado mais tarde. Permite capturar o estado atual das unidades do systemd para restauração posterior. Esse unidade(unit) não está disponível em todas as distribuições Linux.
- Exemplo: mysnapshot.snapshot

O comando systemctl é usado para gerenciar as unidades(units) do systemd. Podemos gerenciar com ativação, desativação, execução, interrupção e monitoramento da unidade, entre outras.

Como exemplo, irei usar o serviço do apache no Debian que é chamado de apache2.service

inicia o apache

elder@debian12:~$ sudo systemctl start apache2.service

para o apache

elder@debian12:~$ sudo systemctl stop apache2.service

reinicia o apache

elder@debian12:~$ sudo systemctl restart apache2.service

verifica o status do apache

elder@debian12:~$ sudo systemctl status apache2.service

verifica se o apache está ativo. Exibe active se unit estiver rodando, ou inactive se não estiver.

elder@debian12:~$ sudo systemctl is-active apache2.service

Habilita unit, ou seja, unit será carregado durante a inicialização do sistema.

elder@debian12:~$ sudo systemctl enable apache2.service

unit não será iniciado com o sistema.

elder@debian12:~$ sudo systemctl disable apache2.service

Verifica se unit é iniciado com o sistema. A resposta é armazenada na variável $?. O valor 0
indica que unit inicia com o sistema e o valor 1 indica que não.

elder@debian12:~$ sudo systemctl is-enabled apache2.service

Se houver apenas a unidade com aquele nome, então poderemos descartar o .service ou outro tipo. Exemplo: systemctl start apache2
Ao invés de …apache2.service

Como alterar o target(destino ou alvo padrão) no systemd?

Target é do uma palavra do inglês que traduzida quer dizer alvo. o systemd chama um conjunto de serviços que precisam ser iniciados para atingir um determinado estado do sistema de target porque ele representa um alvo a ser alcançado. É como se fosse um destino final para a inicialização do sistema.

Sabemos que a unidade(unit) target é similar ao runlevel(nível de execução) do SysVinit e, assim, podemos configurar o sistema para iniciar em diversos modos, como com interface gráfica ou sem.

PELOS PARÂMETROS DO KERNEL

podemos colocar systemd.unit=multi-user.target nos parâmetros do kernel para que o sistema inicie sempre no modo similar ao runlevel 3 do SysVinit.

Esse método é bem difícil e mais complexo.

SYSTEMCTL ISOLATE

Podemos usar systemctl isolate nome_da_target para mudarmos de alvo. isolate Isola o sistema no target target desejado, desativando todos os outros targets ativos no momento. É como reiniciar o sistema para esse target específico.

# systemctl isolate multi-user.target

SYSTEMCTL SET-DEFAULT

Outra maneira de alterar o destino padrão é modificar o link simbólico /etc/systemd/system/default.target para que ele aponte para o destino desejado.

Podemos fazer isso usando o próprio comando systemctl set-default. set-default define o target desejado como o target padrão para futuras inicializações do sistema. Ou seja, sempre que o sistema for reiniciado, ele iniciará nesse target, a menos que seja alterado manualmente.

# systemctl set-default multi-user.target

Veja o resultado com o comando systemctl get-default

$ systemctl get-default
graphical.target

Logicamente, nunca aponte o o target para shutdown.target!

CRIAR LINK SIMBÓLICO PARA /etc/systemd/system/default.target

Podemos criar um link simbólico para /etc/systemd/system/default.target.

Veja abaixo que, em meu caso, há apontamento para /etc/systemd/system/default.target

elder@debian12:~$ ls -l  /etc/systemd/system/default.target
lrwxrwxrwx 1 root root 37 ago  1 10:28 /etc/systemd/system/default.target -> /lib/systemd/system/multi-user.target

Outros Comandos do systemd

systemctl list-unit-files

Dentro do diretório /lib/systemd/system/ é onde ficam os arquivos de configuração. Execute systemctl list-unit-files para listar os arquivos das unidades

elder@debian12:~$ systemctl list-unit-files 
UNIT FILE                                                                 STATE           PRESET  
proc-sys-fs-binfmt_misc.automount                                         static          -       
-.mount                                                                   generated       -       
dev-hugepages.mount                                                       static          -       
dev-mqueue.mount                                                          static          -       
media-cdrom0.mount                                                        generated       -       
proc-sys-fs-binfmt_misc.mount                                             disabled        disabled
sys-fs-fuse-connections.mount                                             static          -       
sys-kernel-config.mount                                                   static          -       
sys-kernel-debug.mount                                                    static          -       
sys-kernel-tracing.mount                                                  static          -       
systemd-ask-password-console.path                                         static          -       
systemd-ask-password-wall.path                                            static          -       
session-9.scope                                                           transient       -       
apache-htcacheclean.service                                               disabled        enabled 
apache-htcacheclean@.service                                              disabled        enabled 
apache2.service                                                           enabled         enabled 
apache2@.service                                                          disabled        enabled 
apparmor.service                                                          enabled         enabled 
apt-daily-upgrade.service                                                 static          -

Podemos usar –type para exibir somente o tipo especificado

elder@debian12:~$ systemctl list-unit-files --type=target

systemctl list-units

Use systemctl list-units para listar as unidades. Também podemos usar systemctl list-units –type=target para selecionar o tipo de unidade a ser exibido

systemd e consumo de energia

O systemd também é responsável por acionar e responder a eventos relacionados ao consumo de energia.

systemctl suspend
Coloca o sistema em modo de suspensão, onde o estado é armazenado na RAM e o sistema entra em um modo de baixa energia.
systemctl hibernate
Coloca o sistema em modo de hibernação, onde o estado é armazenado no disco, e o sistema é desligado completamente.
systemctl hybrid-sleep
Combina a suspensão e a hibernação. O estado é salvo tanto na RAM quanto no disco. O sistema entra em suspensão, mas hiberna se a energia for cortada.
systemctl poweroff
Desliga o sistema completamente.
systemctl reboot
Reinicia o sistema.
systemctl halt
Para todas as operações, mas não desliga a energia. É uma forma de interromper o sistema sem desligá-lo completamente.
systemctl suspend-then-hibernate
Primeiro coloca o sistema em suspensão, depois hiberna após um período definido.

Em /etc/systemd/logind.conf é onde ficam as ações associadas a esses eventos. Podemos alimentar esse arquivo ou criar outros terminado em .conf dentro de /etc/systemd/logind.conf.d/

Porém, logind.conf não é muito usado; em seu lugar, acpid é o principal gerenciador de energia do Linux e permite ajustes mais refinados, como fechar a tampa do laptop, bateria fraca ou níveis de carga da bateria.

Upstart

Os scripts de inicialização usados pelo Upstart estão localizados no diretório /etc/init/. Podemos usar initctl list para listar os serviços.

# initctl list
avahi-cups-reload stop/waiting
avahi-daemon start/running, process 1123
mountall-net stop/waiting
mountnfs-bootclean.sh start/running
nmbd start/running, process 3085
passwd stop/waiting
rc stop/waiting
rsyslog start/running, process 1095

Podemos executar diversos comandos relacionados ao gerenciador de serviços Upstart

# start tty6

# status tty6
tty6 start/running, process 3282

# stop tty6

O Upstart não usa o arquivo /etc/inittab para definir os níveis de execução.

O Ubuntu parou de usar o Upstart em 2015, quando migrou do Upstart para o systemd.

Afinal, como desligar e reiniciar o sistema Linux?

O comando shutdown no Linux é utilizado para desligar, reiniciar ou parar o sistema de forma segura. O comando shutdown atua como intermediário nos procedimentos do SysV ou do systemd, ou seja, executa a ação solicitada chamando a ação correspondente no gerenciador de serviços adotado pelo sistema.

Após o shutdown ser executado, todos os processos recebem o sinal SIGTERM, seguido pelo sinal SIGKILL, e o sistema é encerrado ou muda seu nível de execução.

-h ou -r não são usadas, o sistema alterna para o nível de execução 1 ou o modo de usuário único

Comando	Descrição
`shutdown now`	Desliga o sistema imediatamente.
`shutdown -h now`	Desliga o sistema imediatamente (`-h` significa “halt”).
`shutdown -r now`	Reinicia o sistema imediatamente (`-r` significa “reboot”).
`shutdown +10`	Desliga o sistema após 10 minutos.
`shutdown -r +5`	Reinicia o sistema após 5 minutos.
`shutdown -h 22:00`	Desliga o sistema às 22:00 horas.
`shutdown -c`	Cancela um desligamento agendado.
`shutdown -h now "Message"`	Desliga o sistema imediatamente e envia a mensagem “Message” aos usuários.

Substitua message por um aviso a ser enviado a todas as sessões de terminal dos usuários logados.

Podemos usar a sintaxe abaixo para alterarmos o comportamento padrão do comando shutdown:

$ shutdown [option] time [message]

Apenas time é obrigatório. Veja outros exemplos:

Comando	Formato de Tempo	Descrição
`shutdown -h 23:30`	`hh:mm`	Desliga o sistema às 23:30 horas.
`shutdown -r +15`	`+m`	Reinicia o sistema após 15 minutos.
`shutdown -h +30 "Aviso"`	`+m`	Desliga o sistema após 30 minutos e envia a mensagem “Aviso” aos usuários.
`shutdown now`	`now`	Desliga o sistema imediatamente.
`shutdown -r now`	`now`	Reinicia o sistema imediatamente.
`shutdown +0`	`+0`	Desliga o sistema imediatamente (equivalente a `now`).
`shutdown -h 01:00 "Manutenção"`	`hh:mm`	Desliga o sistema à 01:00 da manhã e envia a mensagem “Manutenção” aos usuários.
`shutdown -c`	N/A	Cancela um desligamento ou reinício agendado anteriormente.

Ctrl + Alt + Del serve para reiniciar o sistema. Podemos limitar os usuários que podem reiniciar no SysV e no systemd. No SysV, altere o arquivo /etc/inittab

Com o comando abaixo, somente nomes de usuário que constem no arquivo /etc/shutdown.allow poderão reiniciar o sistema usando Ctrl Alt Del.

ca::ctrlaltdel:/sbin/shutdown -t1 -a -r now

No systemctl a configuração pode ser feita no arquivo /etc/systemd/system/ctrl-alt-del.target ou /etc/systemd/logind.conf.

Para gerenciar energia com o systemd, execute: systemctl poweroff, systemctl reboot…