Redirecionar STDERR / STDOUT de um processo APÓS o início, usando a linha de comando?

No shell, você pode fazer o redirecionamento > <etc., mas que tal APÓS o início de um programa?

Aqui está como vim fazer essa pergunta: um programa em execução no fundo do meu terminal continua emitindo texto irritante. É um processo importante, então eu tenho que abrir outro shell para evitar o texto. Eu gostaria de poder>/dev/null ou algum outro redirecionamento para continuar trabalhando no mesmo shell.

Antes de fechar e reabrir seu tty (por exemplo, fazer logoff e logon novamente, o que também pode encerrar alguns de seus processos em segundo plano no processo), você só tem uma opção:

• anexe ao processo em questão usando o gdb e execute:
  • p dup2 (aberto ("/ dev / null", 0), 1)
  • p dup2 (aberto ("/ dev / null", 0), 2)
  • destacar
  • Sair

por exemplo:

$ tail -f /var/log/lastlog &
[1] 5636

$ ls -l /proc/5636/fd
total 0
lrwx------ 1 myuser myuser 64 Feb 27 07:36 0 -> /dev/pts/0
lrwx------ 1 myuser myuser 64 Feb 27 07:36 1 -> /dev/pts/0
lrwx------ 1 myuser myuser 64 Feb 27 07:36 2 -> /dev/pts/0
lr-x------ 1 myuser myuser 64 Feb 27 07:36 3 -> /var/log/lastlog

$ gdb -p 5636
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Attaching to process 5636
Reading symbols from /usr/bin/tail...(no debugging symbols found)...done.
Reading symbols from /lib/librt.so.1...(no debugging symbols found)...done.
Loaded symbols for /lib/librt.so.1
Reading symbols from /lib/libc.so.6...(no debugging symbols found)...done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/libpthread.so.0...(no debugging symbols found)...done.
[Thread debugging using libthread_db enabled]
[New Thread 0x7f3c8f5a66e0 (LWP 5636)]
Loaded symbols for /lib/libpthread.so.0
Reading symbols from /lib/ld-linux-x86-64.so.2...(no debugging symbols found)...done.
Loaded symbols for /lib64/ld-linux-x86-64.so.2

(no debugging symbols found)
0x00007f3c8eec7b50 in nanosleep () from /lib/libc.so.6

(gdb) p dup2(open("/dev/null",0),1)
[Switching to Thread 0x7f3c8f5a66e0 (LWP 5636)]
$1 = 1

(gdb) p dup2(open("/dev/null",0),2)
$2 = 2

(gdb) detach
Detaching from program: /usr/bin/tail, process 5636

(gdb) quit

$ ls -l /proc/5636/fd
total 0
lrwx------ 1 myuser myuser 64 Feb 27 07:36 0 -> /dev/pts/0
lrwx------ 1 myuser myuser 64 Feb 27 07:36 1 -> /dev/null
lrwx------ 1 myuser myuser 64 Feb 27 07:36 2 -> /dev/null
lr-x------ 1 myuser myuser 64 Feb 27 07:36 3 -> /var/log/lastlog
lr-x------ 1 myuser myuser 64 Feb 27 07:36 4 -> /dev/null
lr-x------ 1 myuser myuser 64 Feb 27 07:36 5 -> /dev/null

Você também pode considerar:

• usando screen; A tela fornece vários TTYs virtuais com os quais você pode alternar sem precisar abrir novas sessões SSH / telnet / etc,
• usando nohup; isso permite que você feche e reabra sua sessão sem perder nenhum processo em segundo plano no processo.

Isso fará:

strace -ewrite -p $PID

Não é tão limpo (mostra linhas como:) write(#,<text you want to see>), mas funciona!

Você também pode não gostar do fato de que os argumentos são abreviados. Para controlar isso, use o -sparâmetro que define o comprimento máximo de cadeias exibidas.

Ele captura todos os fluxos, então você pode filtrar isso de alguma forma:

strace -ewrite -p $PID 2>&1 | grep "write(1" 

mostra apenas as chamadas do descritor 1. 2>&1é redirecionar STDERR para STDOUT, como straceescreve para STDERR por padrão.

riffing excelente pesquisa de vladr (e outros):

crie os dois arquivos a seguir no mesmo diretório, algo no seu caminho, digamos $ HOME / bin:

silence.gdb, contendo (da resposta de vladr):

p dup2(open("/dev/null",0),1)
p dup2(open("/dev/null",0),2)
detach
quit

e silêncio, contendo:

#!/bin/sh
if [ "$0" -a "$1" ]; then
 gdb -p $1 -x $0.gdb
else
 echo Must specify PID of process to silence >&2
fi

chmod +x ~/bin/silence  # make the script executable

Agora, da próxima vez que você esquecer de redirecionar o firefox, por exemplo, e seu terminal começar a ficar cheio de mensagens inevitáveis ​​"(firefox-bin: 5117): Gdk-WARNING **: colisão XID, problemas à frente":

ps  # look for process xulrunner-stub (in this case we saw the PID in the error above)
silence 5117  # run the script, using PID we found

Você também pode redirecionar a saída do gdb para / dev / null se não quiser vê-la.

Redirecione a saída de um processo em execução para outro terminal, arquivo ou tela:

tty
ls -l /proc/20818/fd
gdb -p 20818

Dentro do gdb :

p close(1)
p open("/dev/pts/4", 1)
p close(2)
p open("/tmp/myerrlog", 1)
q

Desanexe um processo em execução do terminal bash e mantenha-o vivo:

[Ctrl+z]
bg %1 && disown %1
[Ctrl+d]

Explicação:

20818 - apenas um exemplo do processo em execução pid
p - imprima o resultado do comando gdb
close (1) - feche a saída padrão
/ dev / pts / 4 - terminal para gravar no
fechamento (2) - feche a saída de erro
/ tmp / myerrlog - arquivo para gravar em
q - sair do gdb
bg% 1 - executar o trabalho parado 1 no fundo
rejeitado% 1 - desanexar o trabalho 1 do terminal

Não é uma resposta direta à sua pergunta, mas é uma técnica que eu tenho achado útil nos últimos dias: execute o comando inicial usando 'screen' e, em seguida, desanexe.

esta é a parte do script bash com base nas respostas anteriores, que redirecionam o arquivo de log durante a execução de um processo aberto, é usado como postscript no logrotateprocesso

#!/bin/bash

pid=$(cat /var/run/app/app.pid)
logFile="/var/log/app.log"

reloadLog()
{
    if [ "$pid" = "" ]; then
        echo "invalid PID"
    else
        gdb -p $pid >/dev/null 2>&1 <<LOADLOG
p close(1)
p open("$logFile", 1)
p close(2)
p open("$logFile", 1)
q
LOADLOG
        LOG_FILE=$(ls /proc/${pid}/fd -l | fgrep " 1 -> " | awk '{print $11}')
        echo "log file set to $LOG_FILE"
    fi
}

reloadLog

Dupx é um utilitário * nix simples para redirecionar a saída / entrada / erro padrão de um processo já em execução.

https://www.isi.edu/~yuri/dupx/

Você pode usar o reredirect ( https://github.com/jerome-pouiller/reredirect/ ).

Tipo

reredirect -m FILE PID

e as saídas (padrão e erro) serão gravadas em FILE.

O README da reredirect também explica como restaurar o estado original do processo, como redirecionar para outro comando ou redirecionar apenas stdout ou stderr.

reredirectTambém forneça um script chamado relinkque permite redirecionar para o terminal atual:

relink PID
relink PID | grep usefull_content

(O reredirect parece ter os mesmos recursos que o Dupx descrito em outra resposta, mas isso não depende do Gdb).