Linha de Comando em Linux: Find – Parte 03, Depuração(Debug) de Erros

 

Obs.: Esse post pode ser ignorado, já que a maioria dos usuários não precisam/fazem uso  de depuração com o comando find. Mas se você for um curioso igual a mim vale a pena dá uma olhada!

Na parte 01 do nosso laboratório vimos a estrutura de uso para o comando find.

Na parte 02 vimos o uso de opções que afeta como a ferramenta find se comporta ao pesquisar links.

Nessa parte 03 iremos ver opções para depuração/debug de erro.

Da estrutura abaixo iremos ver “[-D debug_opções]”

find [-H] [-L] [-P] [-D debug_opções] [-O nível] [Caminho…] [expressão]

 

Opções de Debug “find -D”

 

find -D help

Executando “find -D help” obtemos a lista de opções a serem usadas com com “find -D”

[elder@centos65 Labs]$ find -D help

help       Exibe as opções para -D
tree       Exibe expressões em formato de árvore(com ramificações)
search     Navega pela árvore das pastas verbosamente(exibindo mais informações))
stat       Exibe mensagens com stat(2) e lstat(2) enquanto examina arquivos
rates      Exibe um resumo indicando com qual frequência cada predicado obteve sucesso ou falhou.
opt        Mostra informações relativas à otimizações. Veja -O
exec       Exibe informações para -exec, -execdir, -ok e -okdir

 

find -D tree

Para entendermos “find -D tree” é importante revermos a estrutura do comando find novamente. Vamos ver esse simples exemplo

find /home/elder/Labs/ -name “lista*”

  • find = O comando para encontrar arquivos. esse tá fácil né? 🙂
  • /home/elder/Labs/  =  O caminho. É nesse caminho que queremos que o find busque por arquivos
  • -name “lista*” =  Expressão. Com  -name  dizemos ao find que queremos que ele encontre arquivos que tenham a palavra “lista” no início dos seus nomes.  -name, assim como -type, -size, é chamado de predicado no manual do comando find.

 

-D tree faz find exibir  a expressão que usamos em formato de árvore e de forma bem detalhada. tão detalhada que analisar pela primeira vez dá uma dor no coração de tão confusa!!!

No post anterior vimos que existem opções que não aparecem mas estão lá por padrão. Esse é o caso de “-P” que faz find não seguir links e também de “-print” que faz cada resultado aparecer um abaixo do outro em uma nova linha.

Então, digitar

find /home/elder/Labs/ -name “lista*”

é a mesma coisa que

find -P /home/elder/Labs/ -name “lista*”  -print

 

Executando o comando acima temos dois arquivos encontrados. “lista_de_nomes.txt” e “lista_de_nomes_LINK.txt”:

[elder@centos65 Labs]$ find   /home/elder/Labs/     -name  "lista*"  
/home/elder/Labs/pastaLabs/lista_de_nomes.txt
/home/elder/Labs/lista_de_nomes_LINK.txt

 

Vamos executar o mesmo comando acrescentando -D tree.

[elder@centos65 Labs]$ find -D tree /home/elder/Labs/ -name "lista*"
Predicate List:
[(] [-name] [)] [-a] [-print] 
Eval Tree:
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
    no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
Normalized Eval Tree:
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
    no left.
    right:
        pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
        no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
Optimized Eval Tree:
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
    no left.
    right:
        pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
        no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
Optimized command line:
-name lista* [0,8] -a [0,8] -print [1] 
/home/elder/Labs/pastaLabs/lista_de_nomes.txt
/home/elder/Labs/lista_de_nomes_LINK.txt

 

Vamos tentar entender por partes:

  1. As duas primeiras linhas listam os predicados que usamos. Nesse caso usamos -name e -print.  -print aparece por  fazer parte do comando mas de forma oculta. Há também o -a que parece ser adição???

    Predicate List:
    [(] [-name] [)] [-a] [-print]
  2. Após, observamos que todo esse resultado que aparece se divide em 3 partes
    Eval Tree:  Árvore de avaliação
    Normalized Eval Tree:
    Árvore de avaliação Normalizada
    Optimized Eval Tree:
    Árvore de avaliação otimizada.
  3. Aqui e acolá vems alguns termos como
    cost=Nothing: Sabemos que  find trabalha com custos; os custos baratos são os testes processados de forma mais rápida e os caros são os testes mais demorados.
    rate=0,80:  O tempo que find levou para terminar o processamento????
  4. Cada árvore está dividida em
    right: Direita   🙂
    left: Esquerda 🙂É bom frisarmos que “-D tree” analisa apenas  expressão, que nesso caso do comando acima é -name “lista*” -a -print.  Lembrando que lá no comecinho desse post não digitamos -a -print mas ele está lá, apenas oculto por ser um comportamento padrão.É importante notar que em Eval Tree aparecem apenas
    left: pred=[-name lista*]  ao lado esquerdo
    right: pred=[-print]  ao lado direito.

    Já tanto em Normalized Eval tree No modo Optimized Eval Tree são acrescentados alguns detalhes a mais. Como por exemplo:
    left: pred=[-a]
    right: pred=[-name lista*]
    right: pred=[-print]

  5.  Por fim, em optimized Eval tree também aparece o comando e seus predicados e entre parênteses o rate, ou seja, uma taxa de velocidade para avalização se houve ou não otimização.

    Optimized command line:
    -name lista* [0,8] -a [0,8] -print [1]

  6. As duas últimas linhas são os arquivos encontrados por find
    /home/elder/Labs/pastaLabs/lista_de_nomes.txt /home/elder/Labs/lista_de_nomes_LINK.txt

 

find -D search

-D search mostra em detalhes o comando find acessando pasta e suas subpastas

 

Antes de executarmos o comando é bom vermos a estrutura da pasta em que estamos trabalhando. Obs.: Omiti os arquivos para não ficar muito cumprido.

[elder@centos65 ~]$ tree -d ~/Labs/ 
/home/elder/Labs/
├── minhaPasta
│   ├── pasta_filha_de_minhaPasta
│   └── pastaLabs_LINK -> ../pastaLabs
└── pastaLabs

Agora sim, executamos o comando find com -D search. Abaixo não colei todo o resultado para que não poluir a tela.

[elder@centos65 ~]$ find  -D search   /home/elder/Labs/  -name "*lista_de_nomes*" 
consider_visiting: fts_info=FTS_D , fts_level= 0, prev_depth=-2147483648 fts_path=`/home/elder/Labs/', fts_accpath=`/home/elder/Labs/'
consider_visiting: fts_info=FTS_NSOK, fts_level= 1, prev_depth=0 fts_path=`/home/elder/Labs/tree.html', fts_accpath=`tree.html'
consider_visiting: fts_info=FTS_D , fts_level= 1, prev_depth=1 fts_path=`/home/elder/Labs/minhaPasta', fts_accpath=`minhaPasta'
consider_visiting: fts_info=FTS_NSOK, fts_level= 2, prev_depth=1 fts_path=`/home/elder/Labs/minhaPasta/pastaLabs_LINK', fts_accpath=`pastaLabs_LINK'
consider_visiting: fts_info=FTS_NSOK, fts_level= 2, prev_depth=2 fts_path=`/home/elder/Labs/minhaPasta/arquivos2.txt', fts_accpath=`arquivos2.txt'
consider_visiting: fts_info=FTS_D , fts_level= 2, prev_depth=2 fts_path=`/home/elder/Labs/minhaPasta/pasta_filha_de_minhaPasta', fts_accpath=`pasta_filha_de_minhaPasta'
consider_visiting: fts_info=FTS_NSOK, fts_level= 3, prev_depth=2 fts_path=`/home/elder/Labs/minhaPasta/pasta_filha_de_minhaPasta/arquivos_de_textos1.txt', fts_accpath=`arquivos_de_textos1.txt'
...................

Podemos ver como find acessa as pastas. Ele as separa por níveis.

 

find -D stat

Exibe mensagens com os system calls stat(2) e lstat(2) enquanto examina arquivos. O programa find tenta minimizar essas chamadas

??? bom, não obtive resultados no uso dessa opção. ?????

 

find -D opt

Mostra informações relativas à otimizações. Veja a opção -O

Essa opção nos deixa ainda mais confusos devido à quantidade de informações retornadas. Nem demorarei muito tempo aqui 🙂

Predicate List:
[(] [-name] [)] [-a] [-print] 
Eval Tree:
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
    no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
Normalized Eval Tree:
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
    no left.
    right:
        pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
        no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
-O0: promoting cheap predicate -name lista* into name_list
predlist before merge sort:
        pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
        no left.
        right:
            pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
            no children.
predlist after merge sort:
        pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
        no left.
        right:
            pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
            no children.
Not an arm swap candidate (Right subtree has side-effects):
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
    no left.
    right:
        pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
        no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
Not an arm swap candidate (Doesn't have two arms):
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
no left.
right:
    pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
    no children.
Not an arm swap candidate (Not a binary operation):
pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
no children.
Not an arm swap candidate (Not a binary operation):
pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
no children.
Optimized Eval Tree:
pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
left:
    pred=[-a] type=bi_op prec=and cost=Nothing rate=0,80 no side effects 
    no left.
    right:
        pred=[-name lista*] type=primary prec=no cost=Nothing rate=0,80 no side effects 
        no children.
right:
    pred=[-print] type=primary prec=no cost=Nothing rate=1,0 side effects 
    no children.
Optimized command line:
-name lista* [0,8] -a [0,8] -print [1] 
/home/elder/Labs/pastaLabs/lista_de_nomes.txt
/home/elder/Labs/lista_de_nomes_LINK.txt

 

find -D exec

Exibe informações para -exec, -execdir, -ok e -okdir

??? bom, não obtive resultados no uso dessa opção. ?????

 

Conclusão

Para quem é o uso dessas opções de depuração?  Fica difícil dizer. Para nós, meros mortais usar essa depuração parece um pouco distante. Mas por curiosidade tentei fazer alguns testes superficiais. Sim, isso é importante ressaltar: testes superficiais.

 

Leitor voraz e um dos administradores do GNU/Linux Brasil no Whatsapp, facebook, youtube e nesse dito site: www.gnulinuxbrasil.com.br

One thought on “Linha de Comando em Linux: Find – Parte 03, Depuração(Debug) de Erros

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *