All perguntas(unix)

Suponha que um programa peça alguma memória, mas não haja memória livre suficiente. Existem várias maneiras diferentes de o Linux responder. Uma resposta é selecionar alguma outra memória usada, que não foi acessada recentemente, e mover essa memória inativa para swap.

No entanto, vejo muitos artigos e comentários que vão além disso. Eles dizem que mesmo quando há uma grande quantidade de memória livre, o Linux às vezes decide escrever memória inativa para trocar. Gravar para swap com antecedência significa que, quando eventualmente quisermos usar essa memória, não teremos que esperar por uma gravação no disco. Eles dizem que esta é uma estratégia deliberada para otimizar o desempenho.

Eles estão certos? Ou isso é um mito? Cite sua(s) fonte(s).

Por favor, entenda esta questão usando as seguintes definições:

• troca
• memória livre - a memória "livre" exibida pelo comando free . Este é o MemFreevalor de /proc/meminfo. /proc/meminfoé um arquivo de texto virtual fornecido pelo kernel. Consulte proc(5) ou documentos do RHEL .
• mesmo quando há uma grande quantidade de memória livre - para fins de argumento, imagine que há mais de 10% de memória livre.

Referências

Aqui estão alguns termos de pesquisa: linux "troca oportunista" OU (trocar "quando o sistema não tem nada melhor para fazer" OU "quando não tem nada melhor para fazer" OU "quando o sistema está ocioso" OU "durante o tempo ocioso")

No segundo resultado mais alto do Google, um usuário do StackExchange pergunta "Por que usar swap quando há espaço livre mais do que suficiente na RAM?" e copia os resultados do freecomando mostrando cerca de 20% de memória livre. Em resposta a esta pergunta específica, vejo que esta resposta é altamente votada:

O Linux começa a trocar antes que a RAM seja preenchida. Isso é feito para melhorar o desempenho e a capacidade de resposta:

• O desempenho é aumentado porque às vezes a RAM é melhor usada para cache de disco do que para armazenar memória de programa. Portanto, é melhor trocar um programa que está inativo por um tempo e, em vez disso, manter os arquivos usados ​​com frequência no cache.

• A capacidade de resposta é melhorada pela troca de páginas quando o sistema está ocioso, em vez de quando a memória está cheia e algum programa está sendo executado e solicitando mais RAM para concluir uma tarefa.

A troca diminui a velocidade do sistema, é claro - mas a alternativa à troca não é não trocar, é ter mais RAM ou usar menos RAM.

O primeiro resultado no Google foi marcado como uma duplicata da pergunta acima :-). Nesse caso, o autor da pergunta copiou os detalhes mostrando 7 MemFreeGB de 16 GB. A pergunta tem uma resposta aceita e votada:

Trocar apenas quando não há memória livre é apenas o caso se você definir swappinesscomo 0. Caso contrário, durante o tempo ocioso, o kernel fará a troca de memória. Ao fazer isso, os dados não são removidos da memória, mas uma cópia é feita na partição swap.

Isso significa que, se ocorrer uma situação de esgotamento da memória, ela não precisará gravar no disco imediatamente. Neste caso, o kernel pode apenas sobrescrever as páginas de memória que já foram trocadas, para as quais ele sabe que possui uma cópia dos dados.

O swappinessparâmetro basicamente apenas controla o quanto ele faz isso.

A outra citação não afirma explicitamente que os dados trocados também são retidos na memória. Mas parece que você preferiria essa abordagem, se estiver trocando mesmo quando tiver 20% de memória livre, e o motivo pelo qual está fazendo isso é melhorar o desempenho.

Até onde eu sei, o Linux suporta manter uma cópia dos mesmos dados na memória principal e no espaço de troca.

Também notei a alegação comum de que "troca oportunista" acontece "durante o tempo ocioso". Entendo que isso deve ajudar a me tranquilizar de que esse recurso geralmente é bom para o desempenho. Não incluo isso na minha definição acima, porque acho que já tem detalhes suficientes para fazer uma boa pergunta clara. Eu não quero tornar isso mais complicado do que precisa ser.

Motivação original

atop mostra `swout` (troca) quando tenho gigabytes de memória livre. Por quê?

Existem alguns relatórios como este, de Linux escrevendo para trocar quando há muita memória livre. A "troca oportunista" pode explicar esses relatórios. Ao mesmo tempo, pelo menos uma causa alternativa foi sugerida. Como primeiro passo para analisar as possíveis causas: O Linux alguma vez executa "troca oportunista" conforme definido acima?

No exemplo que relatei, a pergunta já foi respondida. A causa não foi a troca oportunista.

Tenho dois servidores hospedados no IDC. Só posso usar as portas 20/21/22/23/3389/33101-33109 para estabelecer conexões entre dois servidores. O dispositivo de rede IDC bloqueará quaisquer outros pacotes cuja porta de origem ou destino não esteja na lista/intervalo 20/21/22/23/80/3389/33101-33109. Mas a porta de origem do SSH é aleatória.

Usando o comando pode-se especificar facilmente uma porta remota.ssh username@server -p remote_port

Então, existe um sshparâmetro de comando ou alguma outra maneira de especificar uma porta de origem local para que eu possa usar, por exemplo, a porta 33101 para estabelecer a conexão SSH?

Minha topologia de rede é assim:

Aqui está meu arquivo de exemplo

user@linux:~$ cat file.txt 
Line 1
Line 2
Line 3
Line 4
Line 5
user@linux:~$ 

Eu posso imprimir a linha 2-4 comgrep -A2 'e 2' file.txt

user@linux:~$ grep -A2 'e 2' file.txt 
Line 2
Line 3
Line 4
user@linux:~$ 

Também posso imprimir o número da linha comgrep -n

user@linux:~$ grep -nA2 'e 2' file.txt 
2:Line 2
3-Line 3
4-Line 4
user@linux:~$ 

Além disso, o mesmo pode ser feito comsed -n 2,4p file.txt

user@linux:~$ sed -n 2,4p file.txt 
Line 2
Line 3
Line 4
user@linux:~$ 

Mas não tenho certeza de como imprimir o número da linha comsed

Seria possível imprimir o número da linha com sed?

Ao tentar ligar /dev/tcp/www.google.com/80, digitando

/dev/tcp/www.google.com/80

Bash diz no such file or directory. Ao olhar para o código de outras pessoas online, eles usam sintaxe como

 3<>/dev/tcp/www.google.com/80

Percebi que isso também funciona:

</dev/tcp/www.google.com/80

Por que esses símbolos são necessários para chamar certas coisas no bash?

Estou basicamente procurando arquivos e depois classificar pelo tamanho. O script funciona se eu não classificar o tamanho por ser humano legível. Mas eu quero que o tamanho seja legível para humanos. Como posso classificar tamanhos que são legíveis por humanos?

Por exemplo:

 ls -l | sort -k 5 -n | awk '{print $9 " " $5}'

Isso funciona como esperado, recebi o tamanho dos meus arquivos em bytes ascendentes:

1.txt 1
test.txt 3
bash.sh* 573
DocGeneration.txt 1131
andres_stuff.txt 1465
Branches.xlsx 15087
foo 23735
bar 60566
2016_stuff.pdf 996850

Agora, quero que o tamanho seja legível por humanos, então adicionei um parâmetro -h ao LS e agora alguns arquivos estão fora de ordem:

 ls -lh | sort -k 5 -n | awk '{print $9 " " $5}'

1.txt 1
DocGeneration.txt 1.2K
andres_stuff.txt 1.5K
test.txt 3
Branches.xlsx 15K
foo 24K
bar 60K
bash.sh* 573
2016_stuff.pdf 974K

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?