All perguntas(unix)

Piscar é uma prática comum desde os primórdios da computação, especialmente para cursores.

No entanto, quando corro stracepara verificar suas chamadas de sistema, tanto um emulador de terminal konsolequanto um shell bash, não registra nenhum tipo de timer (through timer_settime()) ou timer de intervalo (through setitimer()). Enquanto isso, esses programas não podiam usar o spinlock para esperar um determinado tempo.

Os terminais reais são capazes de fazer isso, pois seus controladores podem entender a sequência de controle de escape do piscar. Mas os monitores gráficos não podem fazer essas coisas aparentemente.

Então, como esses programas fazem seu texto piscar, especialmente em um ambiente gráfico? O texto também pode piscar no terminal gráfico não-X (como se você pressionasse Ctrl+Alt+F2).

Como foi inventado o cursor do terminal piscante? Esta questão mostra a razão pela qual eles foram inventados e detalhes técnicos sobre como os terminais reais os implementam.

Como funcionam os aplicativos de linha de comando como o Vim? Especificamente, como eles assumem o controle do terminal da maneira que fazem? Além disso, para referência futura, existe um termo específico para aplicativos que assumem o controle do terminal da maneira que o Vim faz?

Para uma aula sobre criptografia, estou tentando drenar o pool de entropia no Linux (por exemplo, fazer /proc/sys/kernel/random/entropy_availir para 0 e bloquear a leitura de um comando de /dev/random), mas não consigo fazer isso acontecer. Eu deveria obter leituras de /dev/randompara bloquear. Se eu executar estes dois comandos:

watch -n 0.5 cat /proc/sys/kernel/random/entropy_avail

para assistir a entropia e então:

od -d /dev/random

para despejar o pool aleatório, o valor do watchcomando paira entre 3700 e 3900, e ganha e perde apenas um pouco enquanto eu executo este comando. Deixei os dois comandos serem executados por cerca de três minutos sem nenhuma alteração substancial discernível no tamanho do arquivo entropy_avail. Eu não fiz muito no computador durante esse tempo. Pesquisando no Google, descobri que talvez um gerador de números aleatórios de hardware possa ser tão bom que a entropia não caia, mas se eu fizer isso:

cat /sys/devices/virtual/misc/hw_random/rng_available

Não vejo nada, apenas recebo uma linha em branco. Então tenho algumas perguntas:

1. O que está reabastecendo minha entropia tão bem e como posso encontrar a fonte específica de aleatoriedade?
2. Existe alguma maneira de desativar temporariamente as fontes de aleatoriedade para que eu possa forçar esse bloqueio a acontecer?

Quero entender como o pacote APT é gerenciado em geral, considerando a seguinte situação em que me deparei hoje:

Eu estava tentando adicionar o MongoDB à minha máquina Debian. apt search mongodbmostrou resultados de boa aparência e, antes de tentar instalar, li a documentação do MondoDB que dizia:

Siga estas etapas para executar o MongoDB Community Edition em seu sistema. Estas instruções assumem que você está usando o pacote mongodb-org oficial -- não o pacote mongodb não oficial fornecido pelo Debian -- e está usando as configurações padrão.

A partir disso, entendi e fiquei surpreso que o que recebo do Debian não apt installé oficial pelos desenvolvedores do aplicativo. Isso soa pior do que "não recomendado".

Eu entendo que o repositório de pacotes Debian APT tende a mostrar versões antigas e nunca se destina a acompanhar as últimas atualizações de ponta. Há tantas maneiras de lidar com isso, mas agora estou preocupado com as palavras não oficiais . Isso significa que os pacotes relacionados ao MongoDB (ou qualquer outro aplicativo) no repositório APT não são oficialmente aprovados pelos desenvolvedores do aplicativo? Ou foi lançado oficialmente pelos desenvolvedores, mas "evite porque não é a versão mais recente"? Ou alguém (alguma entidade?) copiou do pacote de instalação oficial e colou no APT?

Não estou tentando entender apenas esse caso específico com o MongoDB. Em vez disso, quero entender a "política" geral sobre aplicativos e APT. Como funciona, como deveria funcionar?

Se esta é uma pergunta noob, desculpe, mas não consegui encontrar uma boa explicação online. Quaisquer links ou referência seriam apreciados.

Estou tentando executar topcom vários PIDs usando -popção e xargs. No entanto, topfalha ao executar com erro top: failed tty get:

$ pgrep gvfs | paste -s -d ',' | xargs -t top -p
top -p 1598,1605,1623,1629,1635,1639,1645,1932,2744
top: failed tty get

Eu usei a -topção para xargsver o comando completo que está prestes a ser executado. Parece bom e eu posso executá-lo com sucesso manualmente:

top -p 1598,1605,1623,1629,1635,1639,1645,1932,2744

No entanto, ele não é executado com xargs. Por que é que?

Eu gostaria de produzir isso na conclusão do meu script bash.

 /\_/\
( o.o )
 > ^ <

Eu tentei o seguinte, mas todos retornam erros.

echo /\\_/\\\n\( o.o \)\n > ^ <
echo  \/\\_\/\\\r\n( o.o )\r\n > ^ <
echo /\\_/\\\n\( o.o \)\n \> ^ <

Como faço para escapar desses caracteres para que o bash os renderize como uma string?

Por exemplo, se eu executar sudo apt-get -y upgradese houver um pacote que exija uma reinicialização para atualizar, o sinalizador sim fará com que o sistema seja reinicializado após o comando concluir a atualização de tudo? Ou ainda exigirá uma reinicialização manual?

SO e software:

• Debian Buster 10 -> kernel versão 4.19 em um Raspbian HW

• apt1.8.2 ( armhf)

Estou procurando um utilitário de backup com backups incrementais, mas de uma maneira mais complicada.

Eu tentei rsync, mas não parece ser capaz de fazer o que eu quero, ou mais provavelmente, eu não sei como fazer isso.

Então este é um exemplo do que eu quero alcançar com isso. Tenho os seguintes arquivos:

testdir
├── picture1
├── randomfile1
├── randomfile2
└── textfile1

Eu quero executar o utilitário de backup e basicamente criar um arquivo (ou um tarball) de todos esses arquivos em um diretório diferente:

$ mystery-command testdir/ testbak
testbak
└── 2020-02-16--05-10-45--testdir.tar

Agora, digamos que no dia seguinte, eu adicione um arquivo, de modo que minha estrutura se pareça com:

testdir
├── picture1
├── randomfile1
├── randomfile2
├── randomfile3
└── textfile1

Agora, quando executo o comando misterioso, obterei outro tarball para esse dia:

$ mystery-command testdir/ testbak
testbak
├── 2020-02-16--05-10-45--testdir.tar
└── 2020-02-17--03-24-16--testdir.tar

Aqui está o kicker: eu quero que o utilitário de backup detecte o fato de que picture1, randomfile1, randomfile2e textfile1não foram alterados desde o último backup, e apenas faça backup dos arquivos novos/alterados, que neste caso é randomfile3, de modo que:

tester@raspberrypi:~ $ tar -tf testbak/2020-02-16--05-10-45--testdir.tar 
testdir/
testdir/randomfile1
testdir/textfile1
testdir/randomfile2
testdir/picture1
tester@raspberrypi:~ $ tar -tf testbak/2020-02-17--03-24-16--testdir.tar 
testdir/randomfile3

Então, como último exemplo, digamos que no dia seguinte eu mudei textfile1e adicionei picture2e picture3:

$ mystery-command testdir/ testbak
testbak/
├── 2020-02-16--05-10-45--testdir.tar
├── 2020-02-17--03-24-16--testdir.tar
└── 2020-02-18--01-54-41--testdir.tar
tester@raspberrypi:~ $ tar -tf testbak/2020-02-16--05-10-45--testdir.tar 
testdir/
testdir/randomfile1
testdir/textfile1
testdir/randomfile2
testdir/picture1
tester@raspberrypi:~ $ tar -tf testbak/2020-02-17--03-24-16--testdir.tar 
testdir/randomfile3
tester@raspberrypi:~ $ tar -tf testbak/2020-02-18--01-54-41--testdir.tar 
testdir/textfile1
testdir/picture2
testdir/picture3

Com este sistema, eu economizaria espaço apenas fazendo backup das alterações incrementais entre cada backup (com obviamente o backup mestre que tem todos os arquivos iniciais), e teria backups das alterações incrementais, por exemplo, se eu fizesse uma alteração no dia 2, e alterei a mesma coisa novamente no dia 3, ainda consigo obter o arquivo com a alteração do dia 2, mas antes da alteração do dia 3.

Eu acho que é meio como o GitHub funciona :)

Eu sei que provavelmente poderia criar um script que executasse um diff e selecionasse os arquivos para backup com base no resultado (ou mais eficientemente, basta obter uma soma de verificação e comparar), mas quero saber se há algum utilitário que possa fazer isso ta mais facil :)

#!/bin/sh
echo "Noise $1"
echo "Enhancement $2"
for snr in 0 5 10 15 20 25
do
  python evaluate.py --noise $1 --snr 25 --iterations 1250 --enhancement $2
done

Se $2não for especificado, não quero passar o --enhancement $2argumento para meu script python. Como eu faria isso?

Eu quero tarum diretório e gravar o resultado em stdout, depois canalizá-lo para um programa de compactação, assim:

tar -cvf - /tmp/source-dir | lzip -o /media/my-usb/result.lz -

Eu tenho usado pipe o tempo todo com comandos que geram várias linhas de texto. Agora estou me perguntando o que aconteceria quando eu canalizasse um comando (rápido) com uma saída muito grande, como tare um comando de compactação muito lento seguido? Vai taresperar que sua saída seja consumida por lzip? Ou apenas faz o mais rápido possível e envia tudo para a RAM? Será um desastre no sistema com pouca RAM se o último for verdade.