All perguntas(unix)

O TCP KeepAlive (opção de soquete SO_KEEPALIVE) é governado por três opções: tempo após o qual o mecanismo é acionado, intervalo de sondagem e número de sondagens com falha após o qual a conexão é declarada interrompida.

Seus padrões são:

• tcp_keepalive_time = 7200
• tcp_keepalive_intvl = 75
• tcp_keepalive_probes = 9

Enviar testes após 1¼ minutos parece razoável, e declarar falha após 9 testes com falha também, mas qual é a ideia por trás do tempo inicial de 2 horas ?

Mesmo tcp(7) diz

Observe que os mecanismos subjacentes de rastreamento de conexão e os tempos limite do aplicativo podem ser muito mais curtos.

O ponto principal de habilitar o keepalive é evitar que quaisquer elementos de rede com estado descartem as informações de estado, mas esses elementos tendem a descartar as conexões em alguns minutos . Com alguns servidores com taxa limitada, o curlshort --keepalive-timeparece melhorar significativamente a confiabilidade dos downloads.

Então, por que o padrão é tão longo?

Estou tentando pesquisar recursivamente uma string com grep, mas recebo isso:

$ grep -r "stuff" *
grep: unrecognized option '---corporate-discount.csv'
Usage: grep [OPTION]... PATTERN [FILE]...
Try 'grep --help' for more information.

Como posso impedir que o Bash passe arquivos começando -como argumento?

Existe um script (vamos chamá-lo de echoer) que imprime para exibir um monte de informações. Eu gostaria de poder ver apenas linhas depois que um padrão for encontrado.

Eu imagino o uso de uma solução para se parecer com

echoer | solution_command <pattern>

Idealmente patternseria uma expressão regular, mas strings de valor rígido seriam suficientes para mim.

Em nossa caixa Linux temos USB -> dispositivo serial que sempre foi identificado como /dev/ttyACM0. Então eu escrevi um aplicativo e até ontem, tudo funcionou bem. Mas de repente (sim, durante a apresentação remota...) o aparelho parou de funcionar. Após uma pesquisa rápida, descobri que a conexão mudou para /dev/ttyACM1. Foi um pouco prematuro, mas agora tenho um problema - como identificar inequivocamente meu dispositivo? Como, por exemplo, a unidade de armazenamento pode ser inicializada usando UUID, embora /dev/sd**tenha mudado. Existe alguma maneira de fazer isso para dispositivos seriais?

Agora eu uso uma solução estúpida:

for(int i = 0; i < 10; i ++)
{
    m_port = std::string("/dev/ttyACM") + (char)('0' + i);
    m_fd = open(m_port.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
}

O link para o dispositivo que usamos.

Eu tenho uma pergunta sobre como criar meu próprio arquivo de unidade (serviço) para o Systemd.

Li a documentação e tive algumas dúvidas. Depois de pesquisar, encontrei esta resposta muito útil que fornece alguns detalhes sobre algumas das perguntas que eu estava tendo.

Como escrever um arquivo systemd .service executando systemd-tmpfiles

Embora eu ache essa resposta útil, ainda há uma parte que não entendo. Principalmente esta parte:

Como realmente queremos que esse serviço seja executado mais tarde, em vez de mais cedo, especificamos uma cláusula "Depois". Na verdade, isso não precisa ser o mesmo que o destino WantedBy (geralmente não é)

Meu entendimento de After é que é bastante direto. O serviço (ou o que você estiver definindo) será executado após a unidade listada em Depois.

Da mesma forma, WantedBy parece bastante direto. Você está definindo que a unidade que você lista tem um Desejo para o seu serviço. Portanto, para um destino como multiusuário ou gráfico, sua unidade deve ser executada para que o systemd considere esse destino alcançado.

Agora, supondo que meu entendimento de como essas declarações funcionam está correto até agora, minha pergunta é esta: Por que funcionaria listar a mesma unidade nas cláusulas After e WantedBy?

Por exemplo, definir uma unidade que é After multi-user.target e também WantedBy multi-user.target me parece que levaria a uma situação impossível em que a unidade precisa ser iniciada após o alvo ser atingido, mas também precisa ser iniciado para que a meta seja considerada "atingida".

Estou entendendo mal alguma coisa?

No meu terminal imprimiu um número aparentemente aleatório 127. Acho que está imprimindo o valor de alguma variável e para verificar minha suspeita, defini uma nova variável v=4. Executar echo $?novamente me deu 0como saída.

Estou confuso, pois esperava que 4 fosse a resposta.

Kitty é um terminal para Linux. Como faço para copiar e colar com ele. CTRL+ cnão funciona? E não há opção de clicar com o botão direito. O botão direito do mouse também não funciona para copiar.

Fechar aviso de votação : enquanto a duplicata vinculada faz a mesma pergunta, os comentários e a única resposta não fornecem uma resposta que seja extraída de uma fonte autorizada. A resposta à minha pergunta por Thomas Dickey , de fato fornece a resposta que eu estava procurando. Assim, a duplicata proposta não é útil, no entanto, a resposta de Thomas aqui é adequada.

De acordo com a resposta do G-Man na pergunta do superusuário e na conta pessoal neste comentário do PerlDuck , os diretórios que possuem grande quantidade de entradas chegam a um tamanho superior a 4096 bytes (o que pode ser visto com a ls -lsaída), mas uma vez que as entradas são removidas - o número nunca diminui.

A pergunta é "por que"? É devido à forma como o ext4sistema de arquivos está configurado para reter os metadados do diretório? Obviamente, remover o diretório e recriá-lo não é uma solução, pois exclui o inode original e cria um novo. O que pode ser feito para diminuir o número manualmente?

queremos substituir a extensão do arquivo de script

então fizemos o seguinte:

 new_name=` echo run_fix.bash  |  sed 's/[.].*$//' `
 new_file_extension=".in_hold.txt"
 new_name=$new_name$new_file_extension

 echo $new_name
 run_fix.in_hold.txt

mas sinto que minha abordagem não é tão elegante

note - porque a extensão de script pode ser bash ou perl ou python e também a extensão de destino pode ser qualquer coisa depois de "." queremos substituição global

Estou usando redhat 7.2

Eu usei o terminal para copiar arquivos de uma unidade para outra.

sudo mv -vi /location/to/drive1/ /location/to/drive2/

No entanto, isso parou de repente, algumas horas depois, e sem erro, depois de criar um diretório.

Minha própria solução para isso geralmente é uma mistura de hash e comparação, o que é principalmente uma bagunça demorada, pois agora tenho que me recuperar de uma cópia intermediária sem realmente saber quais arquivos estão faltando (escrito como uma linha muito longa para zsh - observe que este script não funciona no bash conforme escrito):

source_directory="/path/to/source_directory/";
target_directory="/path/to/target_directory/";
while read hash_and_file; do {
    echo "${hash_and_file}" | read hash file;
    echo "${file}" | sed "s/^/${source_directory}/g" | read copy_from;
    echo "${copy_from}" | sed "s/${source_directory}/${target_directory}/g" | read copy_to;
    mv -v "${copy_from}" "${copy_to}" | tee -a log;
    rm -v "${copy_from}" | tee -a log; };
done <<<$(
    comm -23 <( find ${source_directory} -type f -exec sha256sum "{}" \; |
                sed "s: ${source_directory}: :g" | sort;
           ) <( find ${target_directory} -type f -exec sha256sum "{}" \; |
                sed "s: ${target_directory}: :g" | sort; ) )

Isso é propenso a erros se o nome diretório de destino ou diretório_origem fizerem parte do caminho e excluir arquivos se eles não tiverem sido movidos porque foram marcados como duplicados. Além disso, ele não fornece o diretório de origem no final.

Existe uma prática recomendada de como recuperar de mv interrompido?