recuperar o redirecionamento de saída std para /dev/null

Não, você não pode alterar o identificador do arquivo.

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

Não, você não pode armazenar os dados sem armazená-los em algum lugar .

Alguém provavelmente escreveu um buffer circular - o que permitiria que você visse (digamos) os últimos 100k de dados. Alternativamente, se o programa estiver rodando normalmente sem comando, você pode enviar a saída para a tela e executá-la via screen.

quando não estou recuperando, o stdout pode ser descartado, quando começo a recuperar, o stdout pode ser redirecionado para um arquivo de log.

Isso pode ser feito canalizando a saída para um script de shell, como o seguinte:

#! /bin/sh
# a-script.sh
while IFS= read -d input
do
  printf "%s\n" input >> /some/file
done 

Observe que o redirecionamento é feito dentro do loop, especificamente para que o arquivo de saída seja aberto novamente a cada iteração. Então, para começar:

ln -s /dev/null /some/file
cmd | a-script.sh

Então, quando você quiser os logs:

ln -sf /some/log/file /some/file

E a próxima iteração do loop começará a gravar /some/log/fileem vez de em /dev/null.

Se o seu comando registra muito, isso pode resultar em uma penalidade severa de desempenho.

Quando você faz cmd > /dev/null, o shell, em um novo processo filho, abre fd 1 /dev/nulle executa cmd.

cmdfaz alguns write(1, "output"...)para gravar dados em stdout (ou possivelmente em outras chamadas de sistema de gravação, como send, sendmsgou pwrite), independentemente do que esse fd está aberto.

No Linux, /proc/$pid_of_cmd/fd/1será apenas um link simbólico mágico para /dev/null, o arquivo fd 1 está aberto, então tail -f thatserá o mesmo que tail -f /dev/null.

Você pode interceptar essas write()chamadas do sistema stracee decodificar o resultado:

strace -zqqs99999 -xxa0 -o /dev/stdout -e write -p "$pid" |
   perl -ne 'print chr(hex($_)) for /\\x(..)/g'

Ou:

strace -zqqs99999 -xxa0 -o /dev/stdout -e write -p "$pid" |
   perl -ne 'if (/^write\(1,/) {print chr(hex($_)) for /\\x(..)/g}'

Para apenas os write()s para stdout (fd 1). Ou:

strace -yzqqs99999 -xxa0 -o /dev/stdout -e write -p "$pid" |
   perl -ne 'if (/^\Qwrite(1<\x2f\x64\x65\x76\x2f\x6e\x75\x6c\x6c>,\E "(.*)"/) {
     print chr(hex($_)) for $1 =~ /\\x(..)/g}'

Somente para write()s para stdout (fd 1) e somente quando stdout estiver aberto em /dev/null.

Observe que, se você redirecionar a saída de perlpara algo diferente de um dispositivo tty, ele começará a armazenar em buffer por blocos em vez de por linha, portanto, você verá apenas a saída em lotes de alguns kibibytes. Você pode desativar esse buffer definindo a $|variável como 1:

strace -zqqs99999 -xxa0 -o /dev/stdout -e write -p "$pid" |
   perl -ne 'BEGIN{$| = 1}
             print chr(hex($_)) for /\\x(..)/g' > file

Como alternativa, em vez de fazer cmd > /dev/null, faça cmd | cat > /dev/null.

Então cmdo stdout do 's será um pipe, e no Linux, /proc/$pid_of_cmd/fd/1se comportará como um pipe nomeado, então se você fizer:

kill -s STOP "$pid_of_cat"
cat "/proc/$pid_of_cmd/fd/1"

Na verdade, você redirecionará o pipe para seu novo catcomando.

Se você terminar aquele novo cat, você vai querer retomar o outro ( kill -s CONT "$pid_of_cat") para reabrir a torneira /dev/nullnaquele cano.

Para realmente alterar para onde vai o stdout do processo, você pode anexar um depurador:

gdb --pid "$pid_of_cmd"

Então no gdb:

call close(1)
p open("/path/to/some/file", 0x241, 0600)
detach

(0x241 para O_WRONLY|O_TRUNC|O_CREAT)

Verifique se open()retorna fd 1. Caso contrário, você pode precisar de alguma chamada para dup2()e um arquivo close().