Como posso excluir todas as mensagens de "permissão negada" de "localizar"?


794

Preciso ocultar todas as mensagens de permissão negada de:

find . > files_and_folders

Estou experimentando quando essa mensagem surge. Preciso reunir todas as pastas e arquivos para os quais não surgem.

É possível direcionar os níveis de permissão para o files_and_foldersarquivo?

Como ocultar os erros ao mesmo tempo?

Respostas:


259

Nota:
* Essa resposta provavelmente é mais profunda do que o caso de uso justifica e find 2>/dev/nullpode ser boa o suficiente em muitas situações. Pode ainda ser interessante para uma perspectiva de plataforma cruzada e para a discussão de algumas técnicas avançadas de shell, com o objetivo de encontrar uma solução o mais robusta possível, mesmo que os casos evitados possam ser amplamente hipotéticos.
* Se o seu sistema estiver configurado para mostrar mensagens de erro localizadas , prefixe as findchamadas abaixo com LC_ALL=C( LC_ALL=C find ...) para garantir que as mensagens em inglês sejam relatadas, para que grep -v 'Permission denied'funcione conforme o esperado. Invariavelmente, no entanto, quaisquer mensagens de erro que não são exibidas estará então em Inglês também.

Se seu shell é bashouzsh , existe uma solução robusta e razoavelmente simples , usando apenas findrecursos compatíveis com POSIX ; Embora bashela própria não faça parte do POSIX, a maioria das plataformas Unix modernas vem com ela, tornando esta solução amplamente portátil:

find . > files_and_folders 2> >(grep -v 'Permission denied' >&2)

Nota: Há uma pequena chance de que parte da grepsaída possa chegar após a find conclusão, porque o comando geral não espera o comando interno >(...)terminar. Em bash, você pode impedir isso anexando | catao comando.

  • >(...)é uma substituição do processo de saída (raramente usada) que permite redirecionar a saída (neste caso, stderr output ( ) para o stdin do comando interno . Além de e , também os suporta, em princípio , mas tentando combiná-los com o redirecionamento de stderr , como é feito aqui ( ), parece ser silenciosamente ignorado (em ).2>>(...)
    bashzshksh2> >(...)ksh 93u+

    • grep -v 'Permission denied'filtra para fora ( -v) todas as linhas (do findfluxo stderr de comando) que contenham a frase Permission deniede saídas das linhas restantes para stderr ( >&2).

Esta abordagem é:

  • robusto : grepé aplicado apenas a mensagens de erro (e não a uma combinação de caminhos de arquivos e mensagens de erro, potencialmente levando a falsos positivos) e mensagens de erro que não sejam negadas pela permissão são passadas para o stderr.

  • efeito colateral free : findo código de saída é preservado: a incapacidade de acessar pelo menos um dos itens do sistema de arquivos encontrados resulta em código de saída 1(embora isso não indique se ocorreram outros erros além dos negados pela permissão).


Soluções compatíveis com POSIX:

As soluções totalmente compatíveis com POSIX têm limitações ou exigem trabalho adicional.

Se finda saída deve ser capturada em um arquivo de qualquer maneira (ou suprimida por completo), a solução baseada em pipeline da resposta de Jonathan Leffler é simples, robusta e compatível com POSIX:

find . 2>&1 >files_and_folders | grep -v 'Permission denied' >&2

Observe que a ordem dos redirecionamentos é importante: 2>&1deve vir primeiro .

A captura de saída stdout em um arquivo antecipadamente permite 2>&1enviar apenas mensagens de erro pelo pipeline, que greppode operar sem ambiguidade.

A única desvantagem é que o código de saída geral será do grepcomando , não do comandofind , o que significa: se não houver nenhum erro ou apenas erros de permissão negada, o código de saída será 1( falha de sinalização ), caso contrário ( erros diferentes dos negados pela permissão) 0- que é o oposto da intenção.
Dito isso, findo código de saída raramente é usado de qualquer maneira , pois muitas vezes transmite pouca informação além de falhas fundamentais , como a passagem de um caminho inexistente.
No entanto, o caso específico de apenas algunsdos caminhos de entrada inacessíveis devido à falta de permissões, é refletido no findcódigo de saída (no GNU e no BSD find): se ocorrer um erro de permissão negada para qualquer um dos arquivos processados, o código de saída será definido como 1.

A seguinte variação aborda isso:

find . 2>&1 >files_and_folders | { grep -v 'Permission denied' >&2; [ $? -eq 1 ]; }

Agora, o código de saída indica se ocorreu algum erro diferente Permission denied : 1caso 0contrário , caso contrário.
Em outras palavras: o código de saída agora reflete a verdadeira intenção do comando: success ( 0) é relatado, se nenhum erro ou apenas erros com permissão negada ocorrerem.
Isso é sem dúvida ainda melhor do que apenas passar findo código de saída, como na solução na parte superior.


gniourf_gniourf nos comentários propõe uma generalização (ainda compatível com POSIX) desta solução usando redirecionamentos sofisticados , que funcionam mesmo com o comportamento padrão de imprimir os caminhos de arquivo no stdout :

{ find . 3>&2 2>&1 1>&3 | grep -v 'Permission denied' >&3; } 3>&2 2>&1

Em resumo: o descritor de arquivo personalizado 3é usado para trocar temporariamente stdout ( 1) e stderr ( 2), para que somente as mensagens de erro possam ser canalizadas grepvia stdout.

Sem esses redirecionamentos, os dados (caminhos do arquivo) e as mensagens de erro seriam canalizados para o grepstdout e grep, portanto, não seriam capazes de distinguir entre a mensagem de erro Permission denied e um arquivo (hipotético) cujo nome contém a frase Permission denied.

Como na primeira solução, no entanto, o código de saída relatado será grep, e não find, mas a mesma correção acima pode ser aplicada.


Notas sobre as respostas existentes:

  • Há vários pontos a serem observados sobre a resposta de Michael Brux , find . ! -readable -prune -o -print:

    • Requer GNU find ; notavelmente, não funcionará no macOS. Obviamente, se você precisar apenas do comando para trabalhar com o GNU find, isso não será um problema para você.

    • Alguns Permission deniederros ainda podem surgir: find ! -readable -prunerelata esses erros para os itens filhos de diretórios para os quais o usuário atual tem rpermissão, mas não possui permissão x(executável). O motivo é que, como o próprio diretório é legível, -prunenão é executado e a tentativa de descer para esse diretório aciona as mensagens de erro. Dito isto, o caso típico é a rfalta de permissão.

    • Nota: O ponto a seguir é uma questão de filosofia e / ou caso de uso específico, e você pode decidir que não é relevante para você e que o comando se adapta bem às suas necessidades, especialmente se simplesmente imprimir os caminhos for o que você faz:

      • Se você conceituar a filtragem das mensagens de erro negadas por permissão como uma tarefa separada que deseja aplicar a qualquer find comando, a abordagem oposta de impedir proativamente os erros negados por permissão requer a introdução de "ruído" no findcomando, que também introduz complexidade e armadilhas lógicas .
      • Por exemplo, o comentário mais votado na resposta de Michael (até o momento em que este artigo foi escrito) tenta mostrar como estender o comando incluindo um -namefiltro, da seguinte forma:
        find . ! -readable -prune -o -name '*.txt'
        Isso, no entanto, não funciona conforme o esperado, porque a -printação à direita é necessária (uma explicação pode ser encontrada nesta resposta ). Essas sutilezas podem introduzir bugs.
  • A primeira solução na resposta de Jonathan Leffler , find . 2>/dev/null > files_and_folderscomo ele mesmo afirma, cegamente silencia todas as mensagens de erro (e a solução é complicada e não totalmente robusto, como ele também explica). Pragmaticamente falando , no entanto, é a solução mais simples , pois você pode se contentar em supor que todo e qualquer erro esteja relacionado à permissão.

  • A resposta de névoa , sudo find . > files_and_folders, é conciso e pragmático, mas mal aconselhado para qualquer outra coisa do que simplesmente imprimir nomes de arquivos , por razões de segurança: porque você está executando como a raiz do usuário, "o risco de ter todo o seu sistema a ser confuso por um erro no achado ou uma versão mal-intencionada ou uma invocação incorreta que escreve algo inesperadamente, o que não poderia acontecer se você executasse isso com privilégios normais "(de um comentário sobre a resposta da névoa por triplicado ).

  • A 2ª solução na resposta de viraptor , find . 2>&1 | grep -v 'Permission denied' > some_filecorre o risco de falsos positivos (devido ao envio de uma mistura de stdout e stderr através do gasoduto), e, potencialmente, ao invés de relatar não erros negou--permission via stderr, captura-los ao lado dos caminhos de saída no arquivo de saída.


4
Apenas uma pergunta rápida: por que você usa uma substituição de processo e não apenas um pipe find . 2>&1 > files_and_folders | grep -v 'Permission denied' >&2:?
gniourf_gniourf

2
@ LéoLéopoldHertz 준영: Se você não deseja enviar para um arquivo externo, faça mais encanamentos:{ find . 3>&2 2>&1 1>&3 | grep -v 'Permission denied' >&3; } 3>&2 2>&1
gniourf_gniourf

2
@ LéoLéopoldHertz: Apenas que seja compatível com POSIX. As substituições de processo >(...)são específicas do Bash.
gniourf_gniourf

2
Não tenho certeza de que a preservação do código de saída de findseja enfatizada e anunciada: findo código de saída é notoriamente inútil. Aqui, é muito provável que seja diferente de zero (e inútil).
gniourf_gniourf

3
O POSIX requer explicitamente a execute/searchpermissão no modo de arquivo para 'pesquisar' um diretório (recuperar os inodes dos arquivos contidos). findfaz isso para descer para um subdiretório (além de exigir readpermissão para listar os arquivos em um diretório). Este não é um 'bug' ou 'erro de portabilidade'.
wjordan

542

Usar:

find . 2>/dev/null > files_and_folders

Isso oculta não apenas os Permission deniederros, é claro, mas todas as mensagens de erro.

Se você realmente deseja manter outros erros possíveis, como muitos saltos em um link simbólico, mas não a permissão negada, provavelmente precisará adivinhar que não possui muitos arquivos chamados 'permissão negada' e tentar:

find . 2>&1 | grep -v 'Permission denied' > files_and_folders

Se você deseja estritamente filtrar apenas o erro padrão, pode usar a construção mais elaborada:

find . 2>&1 > files_and_folders | grep -v 'Permission denied' >&2

O I / O redirecionamento no findcomando é: 2>&1 > files_and_folders |. O canal redireciona a saída padrão para o grepcomando e é aplicado primeiro. O 2>&1erro padrão é enviado para o mesmo local da saída padrão (o tubo). O > files_and_foldersenvia saída padrão (mas não o erro padrão) para um arquivo. O resultado líquido é que as mensagens gravadas com erro padrão são enviadas pelo canal e a saída regular de findé gravada no arquivo. Os grepfiltros filtram a saída padrão (você pode decidir o quão seletiva você deseja que seja e pode ter que alterar a ortografia dependendo do código de idioma e do sistema operacional) e o final>&2significa que as mensagens de erro sobreviventes (gravadas na saída padrão) voltam ao erro padrão mais uma vez. O redirecionamento final pode ser considerado opcional no terminal, mas seria uma boa idéia usá-lo em um script para que as mensagens de erro apareçam no erro padrão.

Existem inúmeras variações sobre esse tema, dependendo do que você deseja fazer. Isso funcionará em qualquer variante do Unix com qualquer derivado de shell Bourne (Bash, Korn, ...) e qualquer versão do POSIX compatível com find.

Se você deseja se adaptar à versão específica de findseu sistema, pode haver opções alternativas disponíveis. O GNU, findem particular, possui inúmeras opções não disponíveis em outras versões - veja a resposta atualmente aceita para um desses conjuntos de opções.


9
Se você é como eu, observe que a falta de espaço é importante! 2>/dev/null, sem espaço!
Nik

20
O 2>é uma única unidade sem espaços; você pode ter um espaço entre ele e o nome do arquivo. Da mesma forma com outros redirecionamentos, como 2>&1(que redireciona o erro padrão para o mesmo local da saída padrão) ou 2>&-fecha o erro padrão, etc. Consulte Redirecionamentos para obter os detalhes sangrentos restantes. (O código acima é genérico POSIX-como o escudo, não é específico para bash.)
Jonathan Leffler

3
Eu tive que usar um P maiúsculo, porque é isso que meu terminal produziria: encontre. 2> & 1 | grep -v 'Permissão negada'
David Doria

4
Como isso é uma solução aceitável? 1) Você está redirecionando TODOS os erros para dev / null 2) Você está filtrando uma sequência de erros explícita !! Dependendo disso, é notoriamente quebradiço e se o seu arquivo estivesse em um diretório chamado 'permissão negada'? Opa!
Gunchars

10
Estou objetando contra seqüências de caracteres de erro grepping para modificar a saída do programa. Funcionará na maioria das vezes, mas simples não é a solução correta (encontre com permissões abaixo). Para dar um exemplo do porquê, isso não funcionará no OSX porque o erro é "Permissão negada". Mesmo para qualquer outro sistema onde há mesmo diferenças minúsculas na cadeia de erro (internacionalização alguém?)
Gunchars

285

Usar:

find . ! -readable -prune -o -print

ou mais geralmente

find <paths> ! -readable -prune -o <other conditions like -name> -print
  • para evitar "permissão negada"
  • E NÃO suprimir (outras) mensagens de erro
  • E obtenha o status de saída 0 ("todos os arquivos foram processados ​​com sucesso")

Trabalha com: find (GNU findutils) 4.4.2. Fundo:

  • O -readableteste corresponde aos arquivos legíveis. O !operador retorna verdadeiro, quando teste é falso. E ! -readablecorresponde a diretórios não legíveis (& arquivos).
  • A -pruneação não desce no diretório
  • ! -readable -prune pode ser traduzido para: se o diretório não estiver legível, não desça nele.
  • O -readableteste leva em consideração as listas de controle de acesso e outros artefatos de permissões que o -permteste ignora.

Veja também find(1) a página de manual para muitos mais detalhes.


6
as diferenças já são mencionadas. se você não entende, as respostas talvez não façam diferença para você? STDOUT é o mesmo - STDERR é diferente (você recebe as outras mensagens de erro com esta resposta) - $? é diferente (0 é "bem-sucedido" com esta resposta, quando nenhum outro erro ocorre - é sempre> 0 "não é bem-sucedido" ao redirecionar para dev / null) - talvez alguém precise de "correto" $? em um script
Michael Brux

6
@Masi a falha mais óbvia é a resposta de Jonathan (grep -v) irá excluir nome do arquivo que contém 'Permissão negada' :)
Fruit

65
Acho apropriado acrescentar aqui que, se você precisar adicionar outros critérios de pesquisa, isso deve ser feito com -o:find . ! -readable -prune -o -name '*.txt'
tempestadept

22
Observe que o POSIX findnão inclui -readablecomo opção; nem o findBSD e, portanto, o Mac OS X (não tenho certeza sobre outros sistemas). Portanto, onde você tem o GNU findgarantido, isso funciona muito bem, mas não é óbvio como adaptar isso, se você não pode garantir que o sistema tenha o GNU findinstalado. (Ele vai funcionar bem em Linux, que pode ou não pode trabalhar em outro lugar.)
Jonathan Leffler

6
find . ! -readable -prune -o -name '*.txt'parece não funcionar no Ubuntu 14.04 usando o find 4.2.2. Parece inore o -name. Por alguma razão estranha, eu tenho sucesso comfind . \( ! -readable -prune \) -o -name '*.txt' -print
con-f-use

110

Se você deseja iniciar a pesquisa a partir da raiz "/", provavelmente verá resultados como:

find: /./proc/1731/fdinfo: Permission denied
find: /./proc/2032/task/2032/fd: Permission denied

É por causa da permissão. Para resolver isso:

  1. Você pode usar o comando sudo:

    sudo find /. -name 'toBeSearched.file'

Ele pede a senha do super usuário, quando digitar a senha, você verá o resultado que realmente deseja. Se você não tem permissão para usar o comando sudo, o que significa que você não tem uma senha de superusuário, primeiro peça ao administrador do sistema para adicioná-lo ao arquivo sudoers.

  1. Você pode usar o redirecionamento da Saída de erro padrão de (geralmente exibição / tela) para algum arquivo e evitar ver as mensagens de erro na tela! redirecione para um arquivo especial / dev / null:

    find /. -name 'toBeSearched.file' 2>/dev/null
  2. Você pode usar o redirecionamento da Saída de erro padrão de (geralmente exibição / tela) para a saída padrão (geralmente exibição / tela) e depois canalizar com o comando grep com o parâmetro -v "invert" para não ver as linhas de saída com 'Permissão negada' pares de palavras:

    find /. -name 'toBeSearched.file' 2>&1 | grep -v 'Permission denied'

7
@scottmrogowski, exceto que não responde à pergunta ... 1. peça ao administrador do sistema para adicioná-lo ao arquivo sudoers. 2.sudo find...
Stephen

1
Exatamente o que eu estava procurando!
DankMasterDan

92

Eu tive que usar:

find / -name expect 2>/dev/null

especificando o nome do que eu queria encontrar e dizendo para redirecionar todos os erros para / dev / null

espera ser o local do programa esperado que eu estava procurando.


3
@Masi, o comando na resposta não usa expect. Em vez disso, expecté simplesmente o nome do arquivo que este comando tentará encontrar.
Dhruv Kapoor 10/02

2
Redirecionar cegamente toda a saída stderr apenas para ignorar uma única classe de mensagens de erro geralmente é uma má idéia - você perderá todos os outros erros arbitrários no processo.
Josip Rodin

59

Tubulação stderrpara /dev/nullusando 2> / dev / null

find . -name '...' 2>/dev/null


2
Isso funciona bem para mim, mesmo no Mac OSX. Ou até mesmofind . -name '...' -print 2>/dev/null
shadowsheep 19/02/19

30

Você também pode usar os predicados -perme -prunepara evitar descer para diretórios ilegíveis (consulte também Como remover instruções de impressão com "permissão negada" do programa find? - Unix e Linux Stack Exchange ):

find . -type d ! -perm -g+r,u+r,o+r -prune -o -print > files_and_folders

4
-perm -g+r,u+r,o+rapenas corresponde aos arquivos que têm a rpermissão (leitura) definida para todas as três entidades de segurança do arquivo , o que não tem relação direta com a possibilidade de o usuário atual ler ou não esse arquivo. Ele tem o potencial de perder arquivos que o usuário atual pode ler e corresponder a arquivos que não podem.
mklement0

Eu acho find . -type d ! \( -perm -u+r -o -perm -g+r -o -perm -o+r \) -prune -o -printque seria a boa solução.
Mattia72

2
@ Mattia72: Não, é fundamentalmente impossível de imitar totalmente -readablecom -perm- ver meu comentário anterior e considere este exemplo: echo 'hi' > file; sudo chown nobody:nobody file; sudo chmod o-r file; find file -perm -u=rimpressões file, porque o seu utilizador ler bit é definido, mas ele se relaciona com o do nobodyusuário, e não o usuário atual. O usuário atual não pode ler este arquivo; tente cat file. Veja também: esta resposta minha.
precisa saber é o seguinte

23

Redirecionar erro padrão. Por exemplo, se você estiver usando o bash em uma máquina unix, poderá redirecionar o erro padrão para / dev / null assim:

find . 2>/dev/null >files_and_folders

20

Embora as abordagens acima não tratem do caso para o Mac OS X, porque o Mac Os X não suporta -readablecomutadores, é assim que você pode evitar erros de 'permissão negada' na saída. Isso pode ajudar alguém.

find / -type f -name "your_pattern" 2>/dev/null.

Se você estiver usando algum outro comando com find, por exemplo, para encontrar o tamanho dos arquivos de determinado padrão em um diretório 2>/dev/null, ainda funcionará como mostrado abaixo.

find . -type f -name "your_pattern" -exec du -ch {} + 2>/dev/null | grep total$.

Isso retornará o tamanho total dos arquivos de um determinado padrão. Observe o 2>/dev/nullcomando no final do comando find.


Boa ligação ao OS X! A resposta de Jonathan explica a parte 2>/dev/null. Você pode, por favor, explicar a parte -exec du -ch {} + 2>/dev/null | grep total$.
Léo Léopold Hertz,

1
@Masi Você pode usar qualquer comando com a -execopção para executar outras ações nos arquivos ou diretórios encontrados por findcomando. du -ch file_patterncalcula o tamanho de cada arquivo correspondente file_patterne a última linha dessa saída é o total geral de todos os arquivos correspondentes file_pattern. Veja a página de manual para du. grep totalapenas filtra a linha que extrai o total geral (que é a última linha).
Bunti

13

Esses erros são impressos na saída de erro padrão (fd 2). Para filtrá-los, basta redirecionar todos os erros para / dev / null:

find . 2>/dev/null > some_file

ou primeiro, junte-se ao stderr e ao stdout e, em seguida, salve esses erros específicos:

find . 2>&1 | grep -v 'Permission denied' > some_file

11

Resposta simples:

find . > files_and_folders 2>&-

2>&-fecha ( -) o descritor de arquivo de erro padrão ( 2) para que todas as mensagens de erro sejam silenciadas.

  • O código de saída ainda será 1se algum Permission deniederro ' ' seria impresso

Resposta robusta para o GNU find:

find . -type d \! \( -readable -executable \) -prune -print -o -print > files_and_folders

Passe opções extras para findisso -prune(evite a descida para), mas ainda -printqualquer diretório ( ) que não ( ) tenha permissões e , ou ( ) qualquer outro arquivo.-typed\!-readable-executable-o-print

  • -readablee -executableopções são extensões GNU, não fazem parte do padrão POSIX
  • Ainda pode retornar ' Permission denied' em arquivos anormais / corrompidos (por exemplo, consulte o relatório de bug que afeta os sistemas de arquivos montados em contêiner usando lxcfs<v2.0.5)

Resposta robusta que funciona com qualquer compatível com POSIX find(GNU, OSX / BSD, etc)

{ LC_ALL=C find . 3>&2 2>&1 1>&3 > files_and_folders | grep -v 'Permission denied'; [ $? = 1 ]; } 3>&2 2>&1

Use um pipeline para transmitir o fluxo de erro padrão grep, removendo todas as linhas que contêm a 'Permission denied'sequência.

LC_ALL=Cdefine o locale POSIX usando uma variável de ambiente , 3>&2 2>&1 1>&3e 3>&2 2>&1 descritores de arquivos duplicados para canalizar o fluxo de erros padrão para grepe [ $? = 1 ]usos []para inverter o código de erro retornado por grepaproximar o comportamento original de find.

  • Também filtrará quaisquer 'Permission denied'erros devido ao redirecionamento de saída (por exemplo, se o files_and_foldersarquivo em si não for gravável)

Como você acha da proposta de resposta da JordiFerran? - - Você pode comparar sua resposta?
Léo Léopold Hertz # 25/16

2
O script de shell dessa resposta, conforme indicado, não é de uso geral (lista apenas os diretórios correspondentes a $ {m_find_name}) e contém várias opções não relevantes para a pergunta (nice, / home *, -maxdepth 5, -follow). Esta resposta aborda a questão específica de 'filtrar diretórios legíveis, mas não executáveis' de forma mais concisa, enquanto permanece de uso geral.
wjordan

1
@wjordan: Obrigado. Eu removi meus comentários, mas um ponto ainda se aplica: a -permsolução baseada em não vale a pena apresentar, porque mais fundamentalmente do que a citação sugere faz algo diferente do que o pretendido: é um teste puramente centrado em arquivo , relacionado ao proprietário do arquivo e group, nenhum dos quais tem relação garantida com o usuário que está chamando o comando (veja esta resposta minha. Parece que sua solução GNU revisada agora não captura erros de permissão negados decorrentes de arquivos .
mklement0

Não reconheço a sintaxe que você está usando (nem como GNU nem como BSD), mas deixe-me ilustrar meu argumento com um exemplo independente: echo 'hi' > file; sudo chown nobody:nobody file; sudo chmod o-r file; find file -perm -u=rprints file, porque seu bit de leitura do usuário está definido, mas está relacionado ao nobodyusuário , não o usuário atual. O usuário atual não pode ler este arquivo; tente cat file.
mklement0

1
@ mklement0 obrigado pela discussão, eu consegui produzir o comportamento que você descreveu em outro teste (não sei o que fiz de errado na primeira vez), parece que -permisso não funciona para determinar as permissões atuais do usuário. Removida essa alternativa desta resposta.
Wdordan

4

Para evitar apenas os avisos de permissão negada, diga ao find para ignorar os arquivos ilegíveis, removendo-os da pesquisa. Adicione uma expressão como OR à sua localização, como

find / \! -readable -prune -o -name '*.jbd' -ls

Isso geralmente diz para (corresponder a um arquivo ilegível e removê-lo da lista) OR (corresponder a um nome como * .jbd e exibi-lo [com ls]) . (Lembre-se de que, por padrão, as expressões são AND juntas, a menos que você use -or.) Você precisa de -ls na segunda expressão, caso contrário, a localização pode adicionar uma ação padrão para mostrar uma das correspondências, o que também mostrará todos os arquivos ilegíveis .

Mas se você está procurando arquivos reais no seu sistema, geralmente não há razão para procurar no / dev, que possui muitos arquivos, portanto, você deve adicionar uma expressão que exclua esse diretório, como:

find / -mount \! -readable -prune  -o  -path /dev -prune  -o  -name '*.jbd' -ls

Então (corresponda arquivo ilegível e remova da lista) OR (corresponda ao caminho / dev e remova da lista) OR (corresponda ao arquivo como * .jbd e exiba-o) .


4

usar

sudo find / -name file.txt

É estúpido (porque você eleva a pesquisa) e não seguro, mas muito mais curto para escrever.


Você pesquisa aqui todo o sistema de arquivos e quer dizer com isso "elevar a pesquisa". Por que você chama isso de inseguro? Porque está pesquisando todo o sistema de arquivos?
Léo Léopold Hertz #

2
Porque o sudo executa o comando find com permissões de root, o que basicamente é uma má ideia. Segregação e princípios de privilégios mínimos são violados.
mist

3
A "elevação" aqui é dos privilégios, de raiz, com sudo. Você corre o risco de todo o sistema ser danificado por um bug findou versão maliciosa ou por uma invocação incorreta que escreve algo inesperadamente, o que não poderia acontecer se você executasse isso com privilégios normais.
Tripleee

2

Nenhuma das respostas acima funcionou para mim. Tudo o que encontro na Internet se concentra em: ocultar erros. Nenhum lida adequadamente com o código de retorno / código de saída do processo. Uso o comando find nos scripts do bash para localizar alguns diretórios e depois inspecionar o conteúdo deles. Eu avalio o comando encontrar sucesso usando o código de saída: um valor zero funciona, caso contrário, falha.

A resposta fornecida acima por Michael Brux funciona algumas vezes. Mas eu tenho um cenário em que falha! Eu descobri o problema e o consertei. Preciso remover arquivos quando:

it is a directory AND has no read access AND/OR has no execute access

Veja a questão principal aqui é: AND / OR. Uma boa sequência de condições sugerida que li é:

-type d ! -readable ! -executable -prune

Isso nem sempre funciona. Isso significa que uma ameixa é acionada quando uma correspondência é:

it is directory AND no read access AND no execute access

Essa sequência de expressões falha quando o acesso de leitura é concedido, mas nenhum acesso de execução é.

Após alguns testes, percebi isso e mudei minha solução de script de shell para:

bom encontrar / home * / -maxdepth 5 -seguir \
    \ (-tipo d -a ! \ (-readable -a -executable \) \) -une -une \
    -o \
    \ (-type d -a -readable -a - executável -a -name "$ {m_find_name}" \) -print

A chave aqui é colocar o "não verdadeiro" para uma expressão combinada:

has read access AND has execute access

Caso contrário, ele não terá acesso total, o que significa: removê-lo. Isso provou funcionar para mim em um cenário em que as soluções sugeridas anteriormente falharam.

A seguir, forneço detalhes técnicos para perguntas na seção de comentários. Peço desculpas se os detalhes forem excessivos.

  • Por que usar o comando nice? Eu tenho a ideia aqui . Inicialmente, pensei que seria bom reduzir a prioridade do processo ao procurar um sistema de arquivos inteiro. Percebi que não faz sentido para mim, pois meu script é limitado a poucos diretórios. Reduzi -maxdepth para 3.
  • ¿Por que pesquisar em / home * /? Isso não é relevante para este segmento. Eu instalo todos os aplicativos manualmente através da compilação do código fonte com usuários não privilegiados (não root). Eles são instalados em "/ home". Posso ter vários binários e versões vivendo juntos. Preciso localizar todos os diretórios, inspecionar e fazer backup de maneira mestre-escravo. Eu posso ter mais de um "/ home" (vários discos sendo executados em um servidor dedicado).
  • Por que usar -follow? Os usuários podem criar links simbólicos para diretórios. É utilidade depende, eu preciso manter o registro dos caminhos absolutos encontrados.

Obrigado pela sua resposta e boas observações! Abri uma recompensa aqui para visualizar melhor sua resposta. Eu acho que é uma boa descoberta não impedir o acesso de leitura e execução. - - Você pode explicar por que usa nicee find $HOME -maxdepth 5 -follow ...?
Léo Léopold Hertz # 22/16

2
O script shell como indicado não é de uso geral (apenas listas de diretórios de correspondência ${m_find_name}), e contém várias opções que não são relevantes para a questão ( nice, /home*, -maxdepth 5, -follow). Adicionei uma resposta que aborda a questão específica de 'filtrar diretórios legíveis, mas não executáveis' de forma mais concisa, enquanto permanece de uso geral.
wjordan

2

Você pode usar o grep -v invert-match

-v, --invert-match        select non-matching lines

como isso:

find . > files_and_folders
cat files_and_folders | grep -v "permission denied" > files_and_folders

Deve à magia


2

- = Para MacOS = -

Faça um novo comando usando o alias: basta adicionar na linha ~ / .bash_profile:

alias search='find / -name $file 2>/dev/null'

e na nova janela do Terminal, você pode chamá-lo:

$ file=<filename or mask>; search

por exemplo:

$ arquivo = etc; procurar


1

Se você estiver usando CSH ou TCSH, aqui está uma solução:

( find . > files_and_folders ) >& /dev/null

Se você deseja saída para o terminal:

( find . > /dev/tty ) >& /dev/null

No entanto, como a FAQ "csh-whynot" descreve, você não deve usar o CSH.


Quero grep todos os arquivos txt e excluir o diretório / arquivos ocultos, omitir a mensagem "Permissão negada" a ser impressa. Estou usando o shell csh. Eu usei os comandos abaixo e eles não estão funcionando encontrar. -tipo f-nome " .txt" -não -caminho '* / \. ' Localização "egrep -v" Permission denied ". -tipo f-nome " .txt" -não -caminho '* / \. '2> / dev / null Ficando abaixo do erro. find: os caminhos devem preceder a expressão: 2 Uso: find [-H] [-L] [-P] [-Olevel] [-D help | tree | search | stat | rates | opt | exec] [path ...] [expressão]
yadav
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.