Perguntas[process](unix)

Não sou um usuário forte de Linux, mas quero entender melhor o material neste post aqui que fala sobre namespaces Linux

https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory

Acho que minha incapacidade de compreensão pode estar relacionada à compreensão insuficiente de "comando", "processo" e talvez algumas outras coisas.

Primeiro, deixe-me explicar um experimento simples que estou usando para minha educação. Abri duas janelas de terminal PUTTY. Em cada janela, fiz um ssh root@[ip of machine]. Agora que tenho 2 sessões SSH para minha máquina Linux, começo meus experimentos.

Na primeira janela, fiz isso:

root@localhost:~# unshare --pid /bin/bash
bash: fork: Cannot allocate memory

Na segunda janela, fiz isso:

root@localhost:~# ps -aux | grep unshare
root       58188  0.0  0.0   6480  2284 pts/3    R+   21:49   0:00 grep --color=auto unshare

Aqui estão minhas perguntas:

1. A segunda janela não mostra nenhuma indicação de unshare --pid /bin/bash. Isso ocorre porque o /bin/bashcomando ou o /bin/bashprocesso já havia terminado? É por isso que muitos usuários de Linux na internet recomendam usar o --forkpara que o /bin/bashseja executado no namespace recém-criado?

2. A resposta aceita declarou isto: "Depois que o bash começar a rodar, o bash irá bifurcar vários novos subprocessos para fazer algumas coisas." Não entendi o significado desta frase. Então, na segunda janela do terminal, eu rodei isto:

root@localhost:~# unshare -pf /bin/bash
root@localhost:~# ps -a
    PID TTY          TIME CMD
  58278 pts/2    00:00:00 sudo
  58279 pts/2    00:00:00 su
  58280 pts/2    00:00:00 bash
  58291 pts/2    00:00:00 unshare
  58292 pts/2    00:00:00 bash
  58299 pts/2    00:00:00 ps

PID 58278 a PID58299 é o que o autor quis dizer com "o bash bifurcará vários novos subprocessos para fazer algumas coisas"?

Se uma exceção de CPU no kernel, como acesso ruim à memória ou opcode inválido, acontecer no contexto de manutenção de um processo de usuário (como syscall ou page-in), ou em um kthreadprocesso, então, até que panic_on_oopsseja definido, informações úteis serão despejadas e a tarefa simplesmente morrerá. Sem pânico. Às vezes, o sistema permanece absolutamente utilizável. O suficiente para o usuário tentar sincronizar seus discos, encerrar programas graciosamente e, de outras maneiras, se preparar para a reinicialização de emergência.

Mas infelizmente, se a exceção acontece em contexto atômico (como interrupção ou softirq), a ação tomada é sempre Kernel Panic (com descrição "Fatal exception in interrupt") — independentemente de quaisquer configurações ou configurações de tempo de compilação. É triste. Por que não é possível simular um retorno de interrupção e manter o sistema funcionando na esperança de que algumas partes ainda funcionem? Obrigado.

Eu sei que posso colocar um infinito mdelay()no caminho do código de "exceção em interrupção" em vez de panic(), para apenas paralisar a CPU local. Mas geralmente não há muita coisa que possa ser feita depois que isso acontece... Mesmo que haja centenas de CPUs na máquina, todas elas logo travam. Então não é muito útil.

Temos este comando GNU tar conforme mostrado:

$ tar -xjf /dev/st0 --to-command='sh -c '\''printf "%s\n" "$TAR_SIZE $TAR_REALNAME" >> "$TAR_ARCHIVE.sizes.txt"'\'

Existe alguma maneira de obtermos taro PID dentro dele --to-command? Algo assim:

$ [...] --to-command='sh -c '\''printf "%s\n" "$TAR_SIZE $TAR_REALNAME" >> "$TAR_ARCHIVE.sizes. $TAR_PID .txt"'\'

(observe a adição de fictício $TAR_PIDperto do final)

Eu li as páginas de manual do GNU tar 1.34, mas não vejo nenhuma variável relevante.

Executei um contêiner usando a imagem alpina e executei timeoutum comando nele. Após a timeoutexecução do comando, resta um processo inativo no Alpine e não consigo eliminá-lo usando o comando kill. Meu fluxo de execução é o seguinte: Execute um contêiner alpino

# cat /etc/os-release
NAME="Alpine Linux"
ID=alpine
VERSION_ID=3.20.0
PRETTY_NAME="Alpine Linux v3.20"
HOME_URL="https://alpinelinux.org/"
BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"

Use o timeoutpara executar um comando

# timeout -k 10 5 /bin/sleep 20
Terminated

Depois disso, um processo morto com timeout é deixado no contêiner e não pode ser eliminado com kill.

# ps -ef
PID   USER     TIME  COMMAND
    1 root      0:00 sleep infinity
   18 root      0:00 sh
   33 root      0:00 [timeout]
   36 root      0:00 ps -ef
# kill -9 33
# ps -ef
PID   USER     TIME  COMMAND
    1 root      0:00 sleep infinity
   18 root      0:00 sh
   33 root      0:00 [timeout]
   37 root      0:00 ps -ef

versão de tempo limite

# timeout --help
BusyBox v1.36.1 (2024-05-21 13:38:37 UTC) multi-call binary.

Usage: timeout [-s SIG] [-k KILL_SECS] SECS PROG ARGS

Run PROG. Send SIG to it if it is not gone in SECS seconds.
Default SIG: TERM.If it still exists in KILL_SECS seconds, send KILL.

Sou completamente novo no Linux, então me perdoe se isso parece uma pergunta absurda.

Estou tentando abrir novas abas no Firefox sem uma URL do terminal. Então meu comando é:

$ firefox -new-tab -search foo1

Agora, quando tento fazer isso novamente na esperança de abrir uma nova aba procurando por um novo item, diga:

$ firefox -new-tab -search foo2

em vez disso, ele abre uma nova janela. Então pensei que talvez se eu conseguisse o PID do navegador anterior, eu poderia executar o comando de nova guia naquele PID e, assim, a nova guia realmente abriria na mesma janela. Posso obter o PID com relativa facilidade se executar:

$ firefox -new-tab -search foo1 </dev/null >/dev/null 2>&1 &

Mas, na verdade, usar o PID para executar um novo comando nesse PID é algo que eu não tenho ideia.

Toda e qualquer contribuição é apreciada. Obrigado!

Fundo

Eu estava usando sudo renice -20 -p <pid>pensando que faria meus vídeos converterem mais rápido.

Ao testar o tempo não surtiu efeito e aí descobri que velocidade não tem nada a ver com gentileza.

Pergunta

Existe um comando que permite que um processo ou comando seja concluído mais rapidamente, talvez limitando outros processos?

Pelo que vi online você chama o método kill em c++ para ver se o processo está vivo. o problema com isso é que os PIDs são rycleados e o mesmo PID que você está procurando pode não ser o mesmo processo. Eu tenho um programa que possui dois processos que não são filhos um do outro. A única maneira de se comunicar com eles é IPC. Eu gostaria que meu processo de host fosse encerrado quando o processo do cliente fosse encerrado. Para fazer isso, preciso saber quando o processo do cliente não está mais ativo.

No Windows, eles têm o que é chamado de manipulador de processo que reservará o PID de ser reciclado até que o processo que criou o identificador seja encerrado. Estou me perguntando como conseguir isso para sistemas macOS/Linux (POSIX).

O código problemático como PIDs são reciclados.

if (0 == kill(pid, 0))
{
    // Process exists.
}

existe uma maneira de recuperar std redirecionado para /dev/null? Eu tentei tail -f /proc/{PID}/fd/1, parece que só funciona, exceto redireciona para /dev/null.

ou seja

tail -f /proc/${cmd_pid}/fd/1

funciona cmd > log.txtmas nãocmd > /dev/null

------------atualizar------------

na verdade, meu problema será log.txtmuito grande se sempre registrar o stdout. seria melhor se eu pudesse controlar quando registrar ou interromper o registro (sem interromper o cmdprocesso em si).

então se é possível redirecionar o stdout para algum tmpsistema de arquivos que não ocupa nenhum recurso, e quando eu precisar posso recuperar o stdout?

Estou usando Ubuntu 22.04.1on WSL 2(embora o fato de ser Unixrelevante apenas para esta pergunta)

Como é que, quando executamos tmuxuma zshsessão, a árvore de processos (que eu resumi um pouco) muda de

init(Ubuntu)─┬─SessionLeader───Relay(9)─┬─ssh-agent
                                        └─zsh───pstree

para

init(Ubuntu)─┬─SessionLeader───Relay(9)─┬─ssh-agent
                                        ├─tmux: server───zsh───pstree
                                        └─zsh───tmux: client

Aqui, pstreeé apenas o comando que me informa a árvore do processo, daí sua presença acima.

Quando rodamos tmuxem zsh, o que acontece é que zshroda fork()para criar um processo fork que é filho de zsh(ou seja, tmux: clientacima). Não tenho certeza de como tmux: server, um processo que é irmão do processo que o gerou, surge.

Se eu fizer:

sleep 1 

contra

sleep 1 & wait $!

haverá alguma diferença em termos de uso da CPU para gerar um processo em primeiro plano versus um processo em segundo plano? Ou o desempenho de ambas as linhas será exatamente igual?