All perguntas(unix)

Em awk, o primeiro argumento para as funções sub()e gsub(), o segundo argumento para a match()função e o terceiro argumento opcional para split(), é uma expressão regular estendida.

Esse argumento pode ser uma expressão arbitrária avaliada como uma string interpretada como uma expressão regular ou pode ser uma constante de expressão regular.

Em awk, uma constante de expressão regular é escrita /RE/para alguma expressão regular RE(um " EREtoken" na awkgramática).

Pergunta: Supondo que REpermaneça o mesmo (alguma expressão regular não variável), há alguma diferença prática entre using /RE/e using "RE"(um " STRINGtoken" na awkgramática) em uma chamada para, por exemplo, sub()? Como alternativa: Existe alguma awkimplementação conhecida que faça diferença entre essas duas formas de representar uma expressão regular em uma chamada para as funções mencionadas acima?

O motivo da pergunta é que me lembro de ter que modificar algum awkcódigo que tentei usar "RE"como expressão regular em uma chamada para sub()ou gsub(), porque, por qualquer motivo, a awkimplementação em questão fez a coisa errada, a menos que eu chamasse a função com /RE/.

Infelizmente, isso foi há algum tempo (mais de 2 anos), então não me lembro dos detalhes e não tenho certeza de qual Unix eu usava na época (possivelmente OpenBSD), mas desde então venho querendo fazer a pergunta.

O código a seguir fará com que a instrução 'if' saia antecipadamente e não execute o comando 'echo' no bloco 'if'. Estou me perguntando por que isso acontece apenas no bloco 'if', mas não na parte principal do script. Observação: entendo que alterar ':=' para ':-' resolverá o problema - não estou procurando corrigir o problema, estou procurando entender a diferença entre o ambiente de execução do bloco 'if' que faz com que isso aconteça em primeiro lugar.

#!/bin/bash

if true; then
        VAR=${$1:='val'}
        echo "This does not run"
fi


VAR=${$1:='val'}
echo "This does run"

A saída é

line 4: ${$1:='val'}: bad substitution
line 7: ${$1:='val'}: bad substitution
This does run

Novamente - não estou interessado em corrigir a mensagem de erro de substituição incorreta, entendo como fazer isso e por que isso acontece. O que eu quero entender é porque a echo "This does not run"linha não roda quando há uma substituição ruim acima dela em um bloco 'if'.

Reproduzido nas seguintes versões bash:

GNU bash, versão 5.1.16(1)-release (x86_64-pc-linux-gnu)

GNU bash, versão 4.2.46(2)-release (x86_64-redhat-linux-gnu)

Por que ainda posso ssh na minha máquina Ubuntu usando uma senha? Este é o /etc/ssh/sshd_configarquivo do meu Ubuntu 20.04 na hospedagem da ovh (mostrando apenas as linhas não comentadas para abreviar):

Include /etc/ssh/sshd_config.d/*.conf
Port xxx
PermitRootLogin no
AllowUsers      user1 user2
PubkeyAuthentication yes
AuthorizedKeysFile      .ssh/authorized_keys .ssh/authorized_keys2
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM yes
X11Forwarding yes
PrintMotd no
AcceptEnv LANG LC_*
Subsystem       sftp    /usr/lib/openssh/sftp-server

As permissões dos arquivos relevantes parecem estar OK:

$ stat -c %a /home/user1/.ssh/
700

$ stat -c %a /home/user1/.ssh/authorized_keys`
600

Eu corri sudo service ssh restarte sudo service sshd restart.

Por que ainda consigo fazer login na minha máquina Ubuntu por senha no ssh? Consigo logar por usuário e senha pelo ssh (PuTTY), ele só pede senha. Ambos user1 e user2 têm suas chaves na pasta inicial .ssh. O que está faltando?

Eu verifiquei o arquivo de inclusão:

-rw------- 1 root root   27 Dec  1 12:52 50-cloud-init.conf
...:/etc/ssh/sshd_config.d$ sudo cat 50-cloud-init.conf
PasswordAuthentication yes

então eu acho que é a causa? No entanto, minha configuração não substituiria essa configuração? uma vez que está incluído acima (em linha)?

Por que o uso de *(1)*remove tudo de um diretório? Então como selecionar todos os arquivos que tem (1)no meio do nome?

O comando usado é rm *(1)*ou rm -rf *(1)*(não lembro exatamente). Era o shell padrão do Ubuntu.

Estou usando Linux 5.15 com Ubuntu 22.04.

Eu tenho um processo que usa muita memória. Requer mais memória do que tenho RAM na minha máquina. A primeira vez que o executei, foi morto pelo OOM Killer. Eu entendo isso: o sistema ficou sem memória, o OOM Killer foi acionado, meu processo foi encerrado. Isso faz sentido. Também tenho certeza de que foi isso que aconteceu: dei uma olhada dmesge está tudo lá.

Então eu adicionei algum espaço de troca. Não me importo se esse processo demorar muito para ser executado: não o executarei com frequência.

Executei o processo novamente. Desta vez, funcionou por mais tempo do que da primeira vez. Todo o sistema ficou muito lento, daquele jeito que os sistemas ficam quando estão trocando muito. Parecia estar funcionando... e então morreu. Não apenas o processo morreu, mas o processo shell que era seu pai também morreu, e o processo Tmux que era seu pai, e o processo shell que era pai do processo Tmux, e até mesmo o processo do terminal GNOME que era seu pai ! Mas então o processo de assassinato parou: nenhum outro pai morreu.

A princípio, pensei que o OOM Killer havia sido acionado novamente - embora ainda houvesse muito espaço de troca disponível - e que ele havia escolhido encerrar o processo do terminal GNOME. Mas eu verifiquei dmesge journalctl -knão havia nada de novo lá. Não havia sinal de que o OOM Killer havia sido acionado.

Então, primeira pergunta: existe alguma circunstância em que o OOM Killer pode ser acionado sem registrar nada no buffer de anel do kernel?

Fiquei intrigado com o fato de que o kernel do Linux parecia ter começado a trocar, mas de alguma forma não havia trocado o suficiente... ou não havia trocado rápido o suficiente... ou algo assim.

Então eu aumentei vm.swappiness. Isso realmente não deve afetar a estabilidade do sistema: é apenas um botão para girar para otimizar o desempenho. Mesmo com o kernel vm.swappinessdefinido 0, ainda deve iniciar a troca quando a memória livre em uma zona cair abaixo de um limite crítico.

Mas parecia que tinha começado a trocar, mas não havia trocado o suficiente ... então aumentei vm.swappinesspara 100incentivá-lo a trocar um pouco mais.

Então eu executei o processo novamente. Todo o sistema ficou muito lento, daquela forma que os sistemas fazem quando estão trocando muito ... até que o processo seja executado com sucesso até a conclusão.

Então, segunda pergunta: por que o kernel não usou o espaço de troca disponível, mesmo quando a memória livre caiu abaixo do limite crítico e certamente havia muito espaço de troca disponível? Por que a mudança vm.swappinessfez a diferença?

Atualizar:

Testes adicionais revelaram que a configuração vm.swappinessnão é uma solução confiável. Eu tive algumas falhas mesmo com vm.swappinessset to 100. Isso pode melhorar as chances de o processo ser concluído com sucesso, mas não tenho certeza.

Tenho a seguinte lista de arquivos:

main.acn
main.acr
main.alg
main.aux
main.glg
main.glo
main.gls
main.ist
main.lof
main.log
main.lot
main.nlo
Saída principal
main.pdf 
main.tex
main.toc

Eu quero rm todos os main.*arquivos, exceto o arquivo main.tex e main.pdf .

Eu tentei, rm main.* !("main.tex","main.pdf")mas isso não funcionou e removi todos os main.* sem exceção.

Alguma ideia?

Estou fazendo algum processamento tentando obter quantas linhas diferentes em um arquivo contendo 160.353.104 linhas. Aqui está minha saída de pipeline e stderr.

$ tail -n+2 2022_place_canvas_history.csv | cut -d, -f2 | tqdm --total=160353104 |\
  sort -T. -S1G | tqdm --total=160353104 | uniq -c | sort -hr > users

100%|████████████████████████████| 160353104/160353104 [0:15:00<00:00, 178051.54it/s]
 79%|██████████████████████      | 126822838/160353104 [1:16:28<20:13, 027636.40it/s]

zsh: done tail -n+2 2022_place_canvas_history.csv | cut -d, -f2 | tqdm --total=160353104 | 
zsh: killed sort -T. -S1G | 
zsh: done tqdm --total=160353104 | uniq -c | sort -hr > users

Minha linha de comando PS1 ou PS2 imprimiu os códigos de retorno de todos os processos do pipeline. ✔ 0|0|0|KILL|0|0|0O primeiro caractere é uma marca de seleção verde que significa que o último processo retornou 0 (sucesso). Outros números são códigos de retorno para cada um dos processos em pipeline, na mesma ordem. Então, notei que meu quarto comando obteve KILLstatus, este é meu comando de classificação sort -T. -S1Gdefinindo o diretório local para armazenamento temporário e buffer de até 1GiB.

A questão é, por que ele retornou KILL, isso significa que algo enviado KILL SIGNa ele? Existe uma maneira de saber "quem matou"?

Atualizações

Depois de ler Marcus Müller Answer , primeiro tentei carregar os dados no Sqlite.

Então, talvez este seja um bom momento para lhe dizer que, não, não use um fluxo de dados baseado em CSV. Um simples

sqlite3 place.sqlite

e nesse shell (supondo que seu CSV tenha uma linha de título que o SQLite possa usar para determinar as colunas) (é claro, substitua $second_column_name pelo nome dessa coluna)

.import 022_place_canvas_history.csv canvas_history --csv
SELECT $second_column_name, count($second_column_name)   FROM canvas_history 
GROUP BY $second_column_name;

Isso estava demorando muito, então deixei processando e fui fazer outras coisas. Enquanto eu pensava mais sobre este outro parágrafo de Marcus Müller Resposta :

Você só quer saber com que frequência cada valor apareceu na segunda coluna. Classificar isso antes só acontece porque sua ferramenta ( uniq -c) é ruim e precisa que as linhas sejam classificadas antes (literalmente não há uma boa razão para isso. Apenas não está implementado que ela possa conter um mapa de valores e sua frequência e aumentar isso à medida que eles aparecer).

Então eu pensei, eu posso implementar isso. Quando voltei ao computador, meu processo de importação do Sqlite parou por causa de um SSH Broken Pip, acho que ele não transmitiu dados por um longo tempo, fechou a conexão. Ok, que boa oportunidade para implementar um contador usando um dict/map/hashtable. Então eu escrevi o seguinte distinctarquivo:

#!/usr/bin/env python3
import sys

conter = dict()

# Create a key for each distinct line and increment according it shows up. 
for l in sys.stdin:
    conter[l] = conter.setdefault(l, 0) + 1 # After Update2 note: don't do this, do just `couter[l] = conter.get(l, 0) + 1`

# Print entries sorting by tuple second item ( value ), in reverse order
for e in sorted(conter.items(), key=lambda i: i[1], reverse=True):
    k, v = e
    print(f'{v}\t{k}')

Então eu usei pelo pipeline de comando follow.

tail -n+1 2022_place_canvas_history.csv | cut -d, -f2 | tqdm --total=160353104 | ./distinct > users2

Estava indo muito rápido, projeção de tqdmmenos de 30 minutos, mas quando chegou em 99% estava ficando cada vez mais lento. Este processo estava usando muita RAM, cerca de 1,7 GB. Máquina que estou trabalhando com esses dados, a máquina que tenho armazenamento suficiente, é um VPS com apenas 2GiB de RAM e ~1TiB de armazenamento. Pensei que poderia estar ficando tão lento porque o SO estava tendo que lidar com essa memória enorme, talvez fazendo alguma troca ou outras coisas. Eu esperei de qualquer maneira, quando finalmente chegou em 100% no tqdm, todos os dados foram enviados para o ./distinctprocesso, depois de alguns segundos obtive a seguinte saída:

160353105it [30:21, 88056.97it/s]                                                                                            
zsh: done       tail -n+1 2022_place_canvas_history.csv | cut -d, -f2 | tqdm --total=160353104 | 
zsh: killed     ./distinct > users2

Desta vez, principalmente por causa do assassino sem memória, como visto na seção Marcus Müller Answer TLDR.

Então, acabei de verificar e não tenho swap ativado nesta máquina. Desativei depois de concluir sua configuração com dmcrypt e LVM, pois você pode obter mais informações nestas minhas respostas .

Então, o que estou pensando é habilitar minha partição de troca LVM e tentar executá-la novamente. Também em algum momento acho que vi tqdm usando 10GiB de RAM. Mas tenho certeza de que vi erroneamente ou btopsaída confusa, pois depois mostrou apenas 10MiB, não acho que o tqdm usaria muita memória, pois apenas conta e atualiza algumas estatísticas ao ler um novo arquivo \n.

No comentário de Stéphane Chazelas a esta questão dizem:

Os logs do sistema possivelmente lhe dirão.

Gostaria de saber mais sobre isso, devo encontrar algo no journalctl? Se for o caso, como fazer?

De qualquer forma, como Marcus Müller Answer diz, carregar o csv no Sqlite pode ser de longe a solução mais inteligente, pois permitirá operar em dados de várias maneiras e provavelmente tem alguma maneira inteligente de importar esses dados sem falta de memória.

Mas agora estou duas vezes curioso sobre como descobrir por que o processo foi morto, como quero saber sobre o meu sort -T. -S1Ge agora sobre o meu ./distinct, o último quase certo que era sobre memória. Então, como verificar os logs que dizem por que esses processos foram eliminados?

Atualização2

Então, habilitei minha partição SWAP e aceitei a sugestão de Marcus Müller deste comentário de pergunta. Usando coleções de pythons.Counter. Então meu novo código ( distinct2) fica assim:

#!/usr/bin/env python3
from collections import Counter
import sys

print(Counter(sys.stdin).most_common())

Então, eu executei o Gnu Screen para que, mesmo se eu obtivesse um pipe quebrado novamente, eu pudesse simplesmente retomar a sessão e executá-lo no seguinte pipeline:

tail -n+1 2022_place_canvas_history.csv | cut -d, -f2 | tqdm --total=160353104 --unit-scale=1 | ./distinct2 | tqdm --unit-scale=1 > users5

Isso me deu a seguinte saída:

160Mit [1:07:24, 39.6kit/s]
1.00it [7:08:56, 25.7ks/it]

Como você pode ver, levou muito mais tempo para classificar os dados do que contá-los. Uma outra coisa que você pode notar é que a saída da segunda linha do tqdm mostra apenas 1.00it, significa que tem apenas uma única linha. Então eu verifiquei o arquivo user5 usando head:

head -c 150 users5 
[('kgZoJz//JpfXgowLxOhcQlFYOCm8m6upa6Rpltcc63K6Cz0vEWJF/RYmlsaXsIQEbXrwz+Il3BkD8XZVx7YMLQ==\n', 795), ('JMlte6XKe+nnFvxcjT0hHDYYNgiDXZVOkhr6KT60EtJAGa

Como você pode ver, ele imprimiu toda a lista de tuplas em uma única linha. Para resolver isso eu usei o bom e velho sed como segue sed 's/),/)\n/g' users5 > users6. Depois disso, verifiquei o conteúdo de users6 usando head, como segue com sua saída:

$ head users6
[('kgZoJz/...c63K6Cz0vEWJF/RYmlsaXsIQEbXrwz+Il3BkD8XZVx7YMLQ==\n', 795)
 ('JMlte6X...0EtJAGaezxc4e/eah6JzTReWNdTH4fLueQ20A4drmfqbqsw==\n', 781)
 ('LNbGhj4...apR9YeabE3sAd3Rz1MbLFT5k14j0+grrVgqYO1/6BA/jBfQ==\n', 777)
 ('K54RRTU...NlENRfUyJTPJKBC47N/s2eh4iNdAKMKxa3gvL2XFqCc9AqQ==\n', 767)
 ('8USqGo1...1QSbQHE5GFdC2mIK/pMEC/qF1FQH912SDim3ptEFkYPrYMQ==\n', 767)
 ('DspItMb...abcd8Z1nYWWzGaFSj7UtRC0W75P7JfJ3W+4ne36EiBuo2YQ==\n', 766)
 ('6QK00ig...abcfLKMUNur4cedRmY9wX4vL6bBoV/JW/Gn6TRRZAJimeLw==\n', 765)
 ('VenbgVz...khkTwy/w5C6jodImdPn6bM8izTHI66HK17D4Bom33ZrwuGQ==\n', 758)
 ('jjtKU98...Ias+PeaHE9vWC4g7p2KJKLBdjKvo+699EgRouCbeFjWsjKA==\n', 730)
 ('VHg2OiSk...3c3cr2K8+0RW4ILyT1Bmot0bU3bOJyHRPW/w60Y5so4F1g==\n', 713)

Bom o suficiente para trabalhar mais tarde. Agora acho que devo adicionar uma atualização depois de tentar verificar quem matou meu tipo usando dmesg ou journalctl. Eu também estou querendo saber se existe uma maneira de tornar este script mais rápido. Talvez criando um threadpool, mas tenho que verificar o comportamento do dict de pythons, também pensei em outras estruturas de dados, pois a coluna que estou contando é uma string de largura fixa, talvez usando uma lista para armazenar a frequência de cada user_hash diferente. Também li a implementação python do Counter, é apenas um dict, praticamente a mesma implementação que eu tinha antes, mas em vez de usar dict.setdefaultapenas used dict[key] = dict.get(key, 0) + 1, foi um uso incorreto de setdefaultnenhuma necessidade real para esse cenário.

Atualização3

Então eu estou ficando tão fundo na toca do coelho, totalmente perdido o foco do meu objetivo. Comecei a procurar por ordenação mais rápida, talvez escrever algum C ou Rust, mas percebi que já tenho os dados que vim buscar processados. Então, estou aqui para mostrar a saída do dmesg e uma dica final sobre o script python. A dica é: pode ser melhor apenas contar usando dict ou Counter, do que classificar sua saída usando a ferramenta de classificação gnu. Provavelmente classificar classifica mais rápido que a função buitin classificada em python.

Sobre o dmesg, foi bem simples encontrar memória insuficiente, basta sudo dmesg | lesspressionar Gpara ir até o fim, do ?que pesquisar de volta, do que pesquisar por Outstring. Encontrei dois deles, um para o meu script python e outro para o meu tipo, aquele que iniciou esta pergunta. Aqui estão essas saídas:

[1306799.058724] Out of memory: Killed process 1611241 (sort) total-vm:1131024kB, anon-rss:1049016kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:2120kB oom_score_adj:0
[1306799.126218] oom_reaper: reaped process 1611241 (sort), now anon-rss:0kB, file-rss:0kB, shmem-rss:0kB
[1365682.908896] Out of memory: Killed process 1611945 (python3) total-vm:1965788kB, anon-rss:1859264kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:3748kB oom_score_adj:0
[1365683.113366] oom_reaper: reaped process 1611945 (python3), now anon-rss:0kB, file-rss:0kB, shmem-rss:0kB

É isso, muito obrigado por ajudar até agora, espero que ajude os outros também.

Ao usar netplan generate, continuei recebendo uma mensagem de erro:

gateway4foi preterido, use rotas padrão em vez disso.

Para atribuições de endereços IP estáticos no netplan, sempre usei a estrutura:

network:
  version: 2
  renderer: networkd
  ethernets:
    eno1:
      dhcp4: false
      dhcp6: false
     addresses:
      - 192.168.10.10/24
     gateway4: 192.168.10.1
     nameservers:
      addresses: [192.168.10.1]

Obviamente gateway4está referenciando gateway4: 192.168.10.1, mas como podemos corrigi-lo?

Estou tentando clonar um SSD de 500 GB para um SSD de 1 TB. Por algum motivo, ele continua falhando quando os dados que estão sendo copiados atingem 8 GB. Este é o terceiro SSD de 1 TB que experimentei e todos ficaram presos no mesmo lugar. Eu executei o seguinte comando:

dd if=/dev/sda of=/dev/sdb bs=1024k status=progress

Eu também tentei clonar a unidade usando o Clonezilla, que falha no mesmo local. Eu usei o GParted para reformatar a unidade e configurá-la para um sistema de arquivos EXT4, mas ela ainda fica presa no mesmo local. Sda é interno e sdb é conectado externamente.

O erro que estou recebendo diz:

7977443328 bytes (8.0 GB, 7.4 GB) copied, 208s, 38.4 MB/s
dd: error reading '/dev/sda': Input/output error
7607+1 records in
7607+1 records out

Obrigado a @roaima pela resposta abaixo. Consegui executar ddrescuee copiou a maioria dos dados. Retirei o SSD interno e conectei os SSDs novos e antigos a uma caixa CentOS via USB3. Eu corri o seguinte:

ddrescue -v /dev/sdb /dev/sdc tmp --force

Durou mais de 15 horas. Parou durante a noite. Mas o bom é que voltou de onde parou quando executei o comando novamente.

Eu usei screenpara não ficar preso em uma única sessão na segunda vez :) . Eu costumava Ctrl+csair do comando ddrescue depois que 99,99% dos dados foram resgatados, pois estavam pendurados por horas. Consegui inicializar a partir da nova unidade e inicializou. Aqui está o estado em que eu saí do ddrescue:

Initial status (read from mapfile)
rescued: 243778 MB, tried: 147456 B, bad-sector: 0 B, bad areas: 0

Current status
     ipos:  474344 MB, non-trimmed:    1363 kB,  current rate:       0 B/s
     ipos:  474341 MB, non-trimmed:        0 B,  current rate:       0 B/s
     opos:  474341 MB, non-scraped:   522752 B,  average rate:   8871 kB/s
non-tried:        0 B,  bad-sector:   143360 B,    error rate:       0 B/s
  rescued:  500107 MB,   bad areas:      123,        run time:  8h  1m 31s
pct rescued:   99.99%, read errors:      354,  remaining time:     14h 31m
                              time since last successful read:      6m  7s
Scraping failed blocks... (forwards)^C
  Interrupted by user

Espero que isso ajude os outros. Acho que meu disco antigo estava começando a falhar. Espero que nenhum dado tenha sido perdido. Agora vamos redimensionar a partição LUKS :)

Parece que cleare bash Ctrl- Lsão bem diferentes; clearremove completamente todas as informações anteriores do terminal (para que você não possa rolar para cima) enquanto Ctrl- Lapenas rola a tela para que o cursor fique no topo da página para que você ainda possa rolar para cima e ver as informações anteriores. Eu prefiro o Ctrl- Lsistema. Existe uma maneira de substituir clearpara que ele faça um Ctrl- Lem vez de limpar todas as informações anteriores do terminal? Este não é um grande problema, mas estou apenas me perguntando por curiosidade se existe uma maneira de alias clearapontar para minha funcionalidade preferida Ctrl.L

Como observação lateral, acabei de notar que o PowerShell também tem uma ligação para Ctrl- Le funciona da mesma maneira que Ctrl- Lno bash; parece que os designers do PowerShell tiraram muito do bash, enquanto cmd.exeos consoles não têm essa funcionalidade.