Como encontrar arquivos com 100% de caracteres NUL no conteúdo?

Qual é o comando da linha de comando do Linux que pode identificar esses arquivos?

AFAIK o findcomando (ou grep) só pode corresponder a uma sequência específica dentro do arquivo de texto. Mas quero combinar o conteúdo inteiro, ou seja, quero ver quais arquivos correspondem à expressão regular \0+, ignorando o (s) caractere (s) de final de linha . Talvez o find . cat | grepidioma possa funcionar, mas não sei como fazer grep ignorar linhas (e tratar o arquivo como binário).

Antecedentes: todos os dias, quando meu laptop congela, minha partição btrfs perde informações: os arquivos abertos para gravação recebem seu conteúdo substituído por zeros (o tamanho do arquivo permanece mais ou menos intacto). Uso a sincronização e não quero que esses arquivos falsos se propaguem: preciso de uma maneira de identificá-los para que possa obtê-los do backup.

Você pode grepobter using caracteres usando o modo regex Perl:

$ echo -ne "\0\0" > nul.bin
$ echo -ne "\0x\0" > non-nul.bin
$ grep -P "[^\0]" *.bin
Binary file non-nul.bin matches

Então você pode usar isso:

for path in *.foo
do
    grep -P "[^\0]" "$path" || echo "$path"
done

Eu concordo com o que D_Bye diz sobre encontrar a raiz do problema.

De qualquer forma, verifique se um arquivo contém apenas \0e / ou \nvocê pode usar tr:

<file tr -d '\0\n' | wc -c

Que retorna 0 para arquivos nulos / nova linha e vazios.

Eu suspeito que esses arquivos sejam escassos, ou seja, eles não têm espaço em disco alocado para eles, eles apenas especificam o tamanho do arquivo ( duinformaria 0 para eles).

Nesse caso, com o GNU find, você pode fazer (assumindo que nenhum caminho do arquivo contenha caracteres de nova linha):

find . -type f -size +0 -printf '%b:%p\n' | grep '^0:' | cut -d: -f2-

Aqui está um pequeno programa python que pode fazer isso:

import sys

def only_contains_nulls(fobj, chunk_size=1024):
    first = True
    while True:
        data = fobj.read(chunk_size)
        if not data:
            if first:
                return 1  # No data
            else:
                return 0
        if data.strip("\0"):
            return 1
        first = False

if __name__ == '__main__':
    with open(sys.argv[1]) as f:
        sys.exit(only_contains_nulls(f))

E em ação:

$ printf '\0\0\0' > file
$ ./onlynulls file && echo "Only nulls" || echo "Non-null characters"
Only nulls
$ printf a >> file
$ ./onlynulls file && echo "Only nulls" || echo "Non-null characters"
Non-null characters

Você pode verificar vários arquivos usando descoberta de -exec, xargs, GNU parallel, e programas semelhantes. Como alternativa, isso imprimirá nomes de arquivos que precisam ser tratados:

files=( file1 file2 )
for file in "${files[@]}"; do
    ./onlynulls "$file" || printf '%s\n' "$file"
done

Lembre-se de que se você passar a saída disso para outro programa, os nomes de arquivos podem conter novas linhas, portanto, você deve delimitá-lo de maneira diferente (apropriadamente, com \0).

Se você tiver muitos arquivos, seria melhor usar uma opção para processamento paralelo, pois isso lê apenas um arquivo por vez.

Encontre arquivos que contenham apenas caracteres nulos '\ 0' e caracteres de nova linha '\ n'.
O qin sed faz com que cada pesquisa de arquivo seja encerrada imediatamente após encontrar qualquer caractere não nulo em uma linha.

find -type f -name 'file-*' |
  while IFS= read -r file ;do 
      out=$(sed -n '1=; /^\x00\+$/d; i non-null
                      ; q' "$file")
      [[ $out == "1" ]] &&  echo "$file"
  done

Faça arquivos de teste

> file-empty
printf '%s\n' 'line1' 'line2' 'line3'      > file-with-text           
printf '%4s\n' '' '' xx | sed 's/ /\x00/g' > file-with-text-and-nulls
printf '%4s\n' '' '' '' | sed 's/ /\x00/g' > file-with-nulls-and-newlines
printf '%4s'   '' '' '' | sed 's/ /\x00/g' > file-with-nulls-only

resultado

./file-with-nulls-and-newlines
./file-with-nulls-only

Este one-liner é a forma mais eficiente de encontrar 100% arquivos nul usando GNU find, xargse grep(assumindo que o último é construído com o apoio PCRE):

find . -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -r0 grep -LP "[^\x00]" --

As vantagens deste método sobre outras respostas fornecidas são:

• arquivos não esparsos são incluídos na pesquisa.
• arquivos não legíveis não são passados ​​para o grep, evitando Permission deniedavisos.
• grepinterromperá a leitura dos dados dos arquivos após localizar qualquer byte diferente de nulo ( LC_ALL=Cé usado para garantir que cada byte seja interpretado como um caractere ).
• arquivos vazios (zero bytes) não são incluídos nos resultados.
• menos grepprocessos verificam com eficiência vários arquivos.
• caminhos contendo novas linhas ou começando com -são tratados corretamente.
• funciona na maioria dos sistemas embarcados que não possuem Python / Perl.

Passar a -Zopção para grepe usar xargs -r0 ...permite que outras ações sejam executadas nos arquivos 100% nul (por exemplo: limpeza):

find . -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -0 grep -ZLP "[^\x00]" -- |
  xargs -r0 rm --

Eu também recomendo usar as findopções -Ppara evitar seguir links simbólicos e -xdevevitar percorrer sistemas de arquivos (por exemplo: montagens remotas, árvores de dispositivos, montagens de ligação, etc).

Para ignorar o (s) caractere (s) de final de linha , a seguinte variante deve funcionar (embora eu não ache que seja uma boa ideia):

find . -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -r0 grep -LP "[^\x00\r\n]" --

Juntando tudo, incluindo a remoção de arquivos indesejados (100% de caracteres nul / nova linha) para impedir o backup:

find -P . -xdev -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -0 grep -ZLP "[^\x00\r\n]" -- |
  xargs -0 rm --

Eu não recomendo incluir arquivos vazios (zero bytes), eles geralmente existem para fins muito específicos .

Para usar o GNU sed, você pode usar a -zopção, que define uma linha como seqüências terminadas em zero e corresponde e exclui linhas vazias da seguinte forma:

if [ "$( sed -z '/^$/d' "$file" | head -c 1 | wc -c )" -eq 0 ]; then
    echo "$file contains only NULL!"
fi

O comando head inbetween é apenas uma otimização.

Pitão

Único arquivo

Defina o alias:

alias is_binary="python -c 'import sys; sys.exit(not b\"\x00\" in open(sys.argv[1], \"rb\").read())'"

Teste-o:

$ is_binary /etc/hosts; echo $?
1
$ is_binary `which which`; echo $?
0

Vários arquivos

Encontre todos os arquivos binários recursivamente:

IS_BINARY='import sys; sys.exit(not b"\x00" in open(sys.argv[1], "rb").read())'
find . -type f -exec bash -c "python -c '$IS_BINARY' {} && echo {}" \;

Para encontrar todos os arquivos não binários, altere &&com ||.