Perguntas[systemd](server)

Observou alguns processos relacionados ao systemd que nunca param. Investigando, eles estão conectados a serviços baseados em Java, potencialmente causados ​​por aqueles que estão sendo iniciados manualmente via su.

$ sudo loginctl user-status username
username (1014)
           Since: Tue 2025-01-28 04:03:56 CST; 2 days ago
           State: closing
        Sessions: 100
          Linger: no
            Unit: user-1014.slice
                  ├─session-100.scope
                  │ ├─1037532 bash /some/script
                  │ ├─1037541 /usr/lib/jvm/jdk/bin/java -parameters
                  │ ├─1039230 /usr/java/default/bin/java -parameters
                  │ ├─1039510 /usr/java/default/bin/java -parameters
                  │ └─1056980 /usr/java/default/bin/java -parameters
                  └─[email protected]
                    └─init.scope
                      ├─1007530 /usr/lib/systemd/systemd --user
                      └─1007534 (sd-pam)

Embora os processos do systemd não parem seja semelhante a systemd --user & sd-pam Os processos nunca param , aqui a fatia compartilhada parece ser mais interessante.

a) Os serviços anexados ao segmento do usuário significam que eles potencialmente compartilhariam limites de recursos com esse usuário, não com a conta de serviço?

b) Existem outras implicações dos serviços executados no segmento do usuário?

c) Há alguma solução alternativa razoável para evitar que isso aconteça, além de usar scripts de inicialização/serviços systemd adequados?

Editar: só para esclarecer, observei isso depois das ações de outros usuários. Pessoalmente, já briguei com pessoas por não se tornarem outros usuários por pelo menos 10 anos :)

Tenho uma situação (acho) muito particular no meu Linux embarcado que não consigo resolver corretamente...

Devido a verificações específicas (personalizadas) a serem executadas em sistemas de arquivos na inicialização antes de montá-los, eu uso um ramdisk inicial para verificar e montar todos os sistemas de arquivos solicitados e, então, os transfiro para o sistema de arquivos raiz quando o init é concluído (então nenhum /etc/fstabdispositivo é usado para montar, mas eles são montados por meio de um script que reside dentro do ramdisk inicial).

Para ser mais específico, a /bootpartição ( mmcblk1p1) é montada primeiro (no modo SOMENTE LEITURA); dentro dessa partição, tenho um arquivo ( rootfs.squashfs) correspondente a uma imagem squashfs do sistema de arquivos raiz de destino... então, após algumas outras operações (não relevantes para o propósito deste post), o script ramdisk inicial acaba montando a imagem squashfs /rootfse, no final do script init, a raiz do sistema é alternada /rootfs(via switch-rootcomando);

O problema surge na reinicialização do sistema (ou desligamento): quando o sistema tenta desmontar todos os sistemas de arquivos montados, a desmontagem /bootfalha (porque o dispositivo está ocupado, como é óbvio, já que o sistema de arquivos raiz é montado a partir de um arquivo squashfs que reside em /boot).

Existe uma maneira de evitar desmontar /bootna reinicialização/desligamento/desligamento, evitando assim a falha de umount? Como ele é montado somente para leitura, não deve ser arriscado, não é? Ou estou esquecendo de algo?

PS: Não sei se pode ser útil e/ou relevante: a inicialização do meu sistema operacional é gerenciada via systemd.

isto é baseado em respostas para O systemd pode executar um comando *antes* de uma reinicialização?

a maneira atual de "iniciar ou reiniciar" um serviço é:

systemctl is-active nginx && systemctl reload nginx || systemctl start nginx

Estou pensando se há uma maneira melhor de usar alvos e coisas assim. Estou com a sensação de que ainda estou tentando usar ferramentas systemd como outras ferramentas init.

O caso em que eu usaria isso é após ajustes manuais na conf, que podem funcionar, mas travar durante o teste de estresse, e então eu preciso iniciar ou reiniciar após novos ajustes no arquivo de configuração. Obviamente, a "solução" aqui pode ser algo que não é aceitável em produção, pois isso é feito em uma caixa vm/dev.

Isso começou depois de instalar o Google Chrome (para funcionalidade de navegador headless). Estou concluindo que tem algo a ver com o Chrome. Nas primeiras horas após a instalação, eu estava construindo um script de curta duração chamando o Chrome em um navegador remoto.

2 lados da questão. É aceitável que o systemd seja executado continuamente e, se sim, como os alertas podem ser suprimidos?

Tenho recebido os relatórios abaixo há dias para as 2 contas de revendedor (4 no total a cada hora). Observe que o tempo do processo está em "dias".

Time:         Sat Oct 19 08:44:54 2024 -0400
Account:      accountname
Resource:     Process Time
Exceeded:     376436 > 1800 (seconds)
Executable:   /usr/lib/systemd/systemd
Command Line: (sd-pam)
PID:          35343 (Parent PID:35342)
Killed:       No

e

Time:         Sat Oct 19 08:44:54 2024 -0400
Account:      accountname
Resource:     Process Time
Exceeded:     376436 > 1800 (seconds)
Executable:   /usr/lib/systemd/systemd
Command Line: /lib/systemd/systemd --user
PID:          35342 (Parent PID:35342)
Killed:       No

Depois de adicionar as 4 linhas a seguir ao csf.piginore e reiniciar o LFD, os alertas continuam chegando.

pcmd: /usr/lib/systemd/systemd
pexe: /usr/lib/systemd/systemd
cmd: (sd-pam)
cmd: /lib/systemd/systemd --user

** Editar ** adicionando imagens para a resposta do grawity.

Isto não é sobreExecStartPre

Um caso de uso ao ajustar serviços é testar um arquivo de configuração antes de reiniciar o serviço.

por exemplo.

$ vim /etc/nginx.conf
$ nginx -t && restart_nginx

o equivalente ao systemd é ainda ter que lembrar da verificação antes de reiniciar.

Existe algo que evita esse provável erro humano? algo como ExecRestartStopPre? Ou seja, algo que ele executará antes da etapa de parada de uma reinicialização?

Eu tenho um aplicativo da web que lida com a entrada do usuário e, como parte disso, executa alguns comandos systemd-run --user --scope ...para limitar o uso de memória e CPU.

O aplicativo funciona bem quando executado normalmente, mas quando executado como um serviço systemd, recebo:

Failed to connect to bus: No medium found

O que preciso fazer na unidade para que o serviço habilite isso?

Como é comum, lxdfornece duas unidades do systemd: lxd.sockete lxd.service. Quando lxd.socketé iniciado, ele inicia lxd.serviceassim que qualquer aplicativo (como lxc) tenta acessar o daemon lxd.

Gostaria lxdde iniciar na inicialização, sem precisar executar nenhum comando. No entanto, quando tento ativar lxd.service, ele ativa lxd.socket:

# systemctl enable lxd.service
Created symlink /etc/systemd/system/sockets.target.wants/lxd.socket → /usr/lib/systemd/system/lxd.socket.

O que está acontecendo aqui? Como posso ativar lxd.service?

O sistema está executando o Fedora 39. Estes são os arquivos da unidade:

/usr/lib/systemd/system/lxd.service:

[Unit]
Description=LXD - main daemon
After=network-online.target openvswitch-switch.service lxcfs.service lxd.socket
Requires=network-online.target lxcfs.service lxd.socket
Documentation=man:lxd(1)

[Service]
Environment=LXD_DOCUMENTATION=/usr/share/doc/lxd-doc/html
Environment=LXD_OVMF_PATH=/usr/share/edk2/ovmf
Environment=LXD_UI=/usr/share/lxd-ui/ui
ExecStart=/usr/bin/lxd --group lxd
ExecStartPost=/usr/bin/lxd waitready --timeout=600
KillMode=process
TimeoutStartSec=600s
TimeoutStopSec=30s
Restart=on-failure
LimitNOFILE=1048576
LimitNPROC=infinity
TasksMax=infinity

[Install]
Also=lxd-containers.service lxd.socket

/usr/lib/systemd/system/lxd.socket:

[Unit]
Description=LXD - unix socket
Documentation=man:lxd(1)

[Socket]
ListenStream=/var/lib/lxd/unix.socket
SocketGroup=lxd
SocketMode=0660
Service=lxd.service

[Install]
WantedBy=sockets.target

Eu tenho uma máquina virtual rápida e o serviço systemd systemd-zserdbd.servicefalha com

Dec 01 17:45:32 server-new systemd[1]: Starting systemd-remount-fs.service...

...

Dec 01 17:45:32 server-new (-userdbd)[183]: systemd-userdbd.service: Failed at step NAMESPACE spawning /usr/lib/systemd/systemd-userdbd: Read-only file system
Dec 01 17:45:32 server-new (-userdbd)[185]: systemd-userdbd.service: Failed at step NAMESPACE spawning /usr/lib/systemd/systemd-userdbd: Read-only file system
Dec 01 17:45:32 server-new systemd[1]: Started systemd-journald.service.
Dec 01 17:45:32 server-new (-userdbd)[186]: systemd-userdbd.service: Failed at step NAMESPACE spawning /usr/lib/systemd/systemd-userdbd: Read-only file system
Dec 01 17:45:32 server-new (-userdbd)[187]: systemd-userdbd.service: Failed at step NAMESPACE spawning /usr/lib/systemd/systemd-userdbd: Read-only file system
Dec 01 17:45:32 server-new (-userdbd)[188]: systemd-userdbd.service: Failed at step NAMESPACE spawning /usr/lib/systemd/systemd-userdbd: Read-only file system

...

Dec 01 17:45:32 server-new systemd-fsck[180]: /usr/bin/fsck.xfs: XFS file system.
Dec 01 17:45:32 server-new systemd[1]: Finished systemd-remount-fs.service.

...

Dec 01 17:45:32 server-new systemd[1]: Reached target local-fs-pre.target.

...

Dec 01 17:45:33 server-new systemd[1]: Reached target local-fs.target.

O erro é bastante óbvio: systemd-userdbd.servicerequer um sistema de arquivos raiz gravável, mas é iniciado antes que o sistema de arquivos seja remontado como gravável.

Portanto, eu queria adicionar a dependência necessária via systemctl edit systemd-userdbd.service --drop-in=wait-for-rw-rootwith

[Unit]
Wants=local-fs.target
After=systemd-userdbd.socket systemd-remount-fs.service local-fs.target

Mas isso parece criar uma dependência circular no momento da inicialização. A remontagem dos sistemas de arquivos leva uma eternidade até que o systemd atinja o tempo limite.

1. Como posso garantir que isso systemd-userdbd.serviceseja iniciado depois que o sistema de arquivos raiz se tornar gravável sem criar uma dependência circular?
2. (Uma questão mais geral) Como analiso o que cria a dependência circular?

Preciso executar um script quando uma interface de rede específica é ativada com systemd/networkctl, ou seja, cada vez que ela entra no estado "roteável".

• Quando a interface sobe ou desce, o dispositivo permanece "ativo", ou seja, não posso depender da unidade "sys-subsystem-net-devices-$DEVICE.device".

• Tentei criar uma unidade de caminho para assistir "/sys/class/net/$DEVICE/operstate", mas isso parece não funcionar com o sistema de arquivos sysfs.

Alguma outra maneira de fazer isso?

Nos meus logs do diário, vejo entradas como:

systemd[865]: app-org.kde.konsole-fbe1036742844b1ea3cd54e064c0a794.scope: Killing process 14893

Aparentemente, o konsole inicia um escopo por instância (e há um bug para adicionar um por guia), mas tendo vários konsoles abertos, recebo:

$ systemctl list-unit-files --all | grep konsole
$ systemctl list-units --all | grep konsole
$ systemctl list-units --type scope
init.scope
session-1.scope