All perguntas(unix)

Eu estava escrevendo um Makefile (no Ubuntu 20.04, se for relevante) e notei um comportamento interessante com o echo. Pegue este Makefile simples:

test.txt:
        @echo -e 'hello\nworld'
        @echo -e 'hello\nworld' > test.txt

Quando eu executo make, eu esperaria ver a mesma coisa no stdout que no test.txt, mas na verdade não vejo. Eu recebo isso no stdout:

hello
world

mas isso em test.txt:

-e hello
world

Enquanto isso, se eu remover -ede ambas as linhas no Makefile, recebo isso no stdout:

hello\nworld

e isso em test.txt:

hello
world

Isso me fez pensar se echodetecta o redirecionamento e se comporta de maneira diferente, mas não quando eu apenas o executo manualmente no shell /bin/echo -e 'hello\nworld' > test.txt(que produz helloe worldem linhas separadas, como eu normalmente esperaria). Cheguei até a confirmar que o Makefile está usando /bin/echo em vez de um shell embutido adicionando uma @echo --versionlinha.

O que está acontecendo aqui?

Eu tenho um sistema de arquivos com muitos arquivos pequenos que eu apago regularmente (os arquivos são um cache que pode ser facilmente regenerado). É muito mais rápido simplesmente criar um novo sistema de arquivos em vez de executar rm -rfou rsyncexcluir todos os arquivos (ou seja, excluir com eficiência um diretório grande contendo milhares de arquivos ).

O único problema com a criação de um novo sistema de arquivos para limpar o sistema de arquivos é que seu UUID muda, levando a alterações em, por exemplo, /etc/fstab.

Existe uma maneira de simplesmente "desvincular" um diretório de, por exemplo, um sistema de arquivos ext4 ou limpar completamente sua lista de inodes?

Eu tropecei no pacote bsdutils no Debian. A descrição diz:

Este pacote contém o mínimo de utilitários BSD necessários para um sistema Debian: logger, renice, script, scriptlive, scriptreplay e wall. Os utilitários BSD padrão restantes são fornecidos por bsdextrautils.

Da mesma forma, a descrição do bsdmainutils também menciona o BSD:

Este pacote contém muitos pequenos programas que muitas pessoas esperam encontrar quando usam um sistema Unix no estilo BSD.

Fiquei surpreso ao ver que esses pacotes se relacionam ao BSD, no contexto de um sistema Linux.

Esses pacotes usam algum código do BSD? O que é um sistema Unix estilo BSD ?

Estou tentando obter o código de saída da função que estou chamando repetidamente na parte "condition" de um whileloop Bash:

while <function>; do 
    <stuff> 
done 

Quando esse loop termina devido a um erro, preciso do código de saída de <function>. Alguma ideia de como posso conseguir isso?

Recentemente notei que muitos scripts estão usando /usr/bin/envem seu shebang . Eu vi isso principalmente usando Bash e Python , mas até agora nunca em conjunto com POSIX sh ( ash, dash,...).

Eu me pergunto por que, e se meus scripts de shell POSIX , destinados a serem altamente portáteis, podem se beneficiar da envabordagem?

Existe um consenso geral sobre se usar:

• padrão:

  #!/bin/sh
  

• meio Ambiente:

  #!/usr/bin/env sh
  

Deixe-me enfatizar isso o suficiente:

Nunca vi isso com sh.

Criei um script para executar backups automatizados no meu servidor CentOS 7. Os backups são armazenados no diretório /home/backup. O script funciona, mas agora gostaria de incorporar uma forma de contar os arquivos após o backup acontecer e se o número for maior que 5, excluir o backup mais antigo.

Abaixo está o que eu tenho para o meu script de backup.

#!/bin/bash

#mysqldump variables

FILE=/home/backup/databasebk_!`date +"Y-%m-%d_%H:%M"`.sql
DATABASE=database
USER=root
PASS=my password

#backup command process

mysqldump --opt --user=${USER} --password=${PASS} ${DATABASE} > ${FILE}

#zipping the backup file

gzip $FILE

#send message to the user with the results

echo "${FILE}.gz was created:"
ls -l ${FILE}.gz

# This is where I would like to count the number of files 
# in the directory and if there are more than 5 I would like
# to delete the oldest file. Any help is greatly appreciated

Obrigado -Mike

Eu quero testar alguns links físicos em uma configuração. As ferramentas de software que posso usar para testar isso exigem um dispositivo de bloco para ler/gravar de/para. Os dispositivos de bloco que tenho disponíveis não podem saturar o link físico, então não posso testá-lo completamente.

Eu sei que posso configurar um dispositivo de bloco virtual que é apoiado por um arquivo. Então, minha ideia era de alguma forma configurar um dispositivo de bloco virtual para /dev/null, mas o problema é que não consigo ler a partir dele. Existe uma maneira de configurar um dispositivo de bloco virtual que grava em /dev/null, mas apenas retorna sempre zero quando lido?

Obrigado por qualquer ajuda!

Que comando sed/awk posso usar? Apenas sort -uirá remover todas as instâncias

Entrada:

abc
abc
def
abc
abc
def

Saída esperada:

abc
def
abc
def

Considere as dependências de objetos compartilhados de /bin/bash, que incluem /lib64/ld-linux-x86-64.so.2(ligador/carregador dinâmico):

ldd /bin/bash
    linux-vdso.so.1 (0x00007fffd0887000)
    libtinfo.so.6 => /lib/x86_64-linux-gnu/libtinfo.so.6 (0x00007f57a04e3000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f57a04de000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f57a031d000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f57a0652000)

A inspeção /lib64/ld-linux-x86-64.so.2mostra que é um link simbólico para /lib/x86_64-linux-gnu/ld-2.28.so:

ls -la /lib64/ld-linux-x86-64.so.2 
lrwxrwxrwx 1 root root 32 May  1 19:24 /lib64/ld-linux-x86-64.so.2 -> /lib/x86_64-linux-gnu/ld-2.28.so

Além disso, os próprios filerelatórios /lib/x86_64-linux-gnu/ld-2.28.sosão vinculados dinamicamente:

file -L /lib64/ld-linux-x86-64.so.2
/lib64/ld-linux-x86-64.so.2: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=f25dfd7b95be4ba386fd71080accae8c0732b711, stripped

Eu gostaria de saber:

1. Como o próprio vinculador/carregador dinamicamente ( /lib64/ld-linux-x86-64.so.2) pode ser vinculado dinamicamente? Ele se conecta em tempo de execução?
2. /lib/x86_64-linux-gnu/ld-2.28.soestá documentado para lidar com binários a.out ( man ld.so), mas /bin/bashum ELF é executável?

O programa ld.so lida com binários a.out, um formato usado há muito tempo; ld-linux.so* (/lib/ld-linux.so.1 para libc5, /lib/ld-linux.so.2 para glibc2) lida com ELF, que todo mundo vem usando há anos.

Eu quero uma maneira de executar um comando aleatoriamente, digamos 1 em cada 10 vezes. Existe um coreutil embutido ou GNU para fazer isso, idealmente algo como:

chance 10 && do_stuff

onde do_stuffé executado apenas 1 em 10 vezes? Eu sei que poderia escrever um script, mas parece uma coisa bastante simples e eu queria saber se existe uma maneira definida.