Resumo:  Aprenda a localização correta dos arquivos no Filesystem Hierarchy Standard (FHS) em um sistema Linux® e saiba como encontrar arquivos e comandos importantes. Use o material deste artigo para se preparar para o exame LPI 101 de certificação de administrador de sistema Linux ou simplesmente para explorar a organização e o gerenciamento de arquivos

Visão Geral

Neste artigo, você irá aprender sobre o Filesystem Hierarchy Standard (FHS). Aprenda a:

• Reconhecer onde localizar arquivos no FHS
• Encontrar arquivos e comandos no seu sistema Linux
• Encontrar outros arquivos e diretórios importantes definidos no FHS e compreender suas finalidades

Este artigo ajuda na preparação para o Objetivo 104.7 no Tópico 104 do exame 101 do Linux Professional Institute Junior Level Administration (LPIC-1). Esse objetivo tem peso 2.

Para tirar o máximo dos artigos desta série, é necessário ter conhecimento básico de Linux e possuir um sistema Linux funcional em que seja possível praticar os comandos aqui abordados. Algumas vezes, é possível que versões diferentes de determinado programa formatem a saída de modo distinto, assim, pode ser que seus resultados não sejam exatamente iguais às listas e figuras exibidas neste documento. Em particular, grande parte da saída mostrada é altamente dependente dos pacotes que já estão instalados em nossos sistemas. Sua própria saída pode ser bem diferente, apesar de que deve ser possível reconhecer as similaridades importantes.

O Filesystem Hierarchy Standard é um documento que especifica o layout comum de diretórios em um sistema Linux ou outro sistema do tipo UNIX®. Ao localizar os arquivos no mesmo local geral em todas as distribuições Linux, o FHS simplifica o desenvolvimento de software independente de distribuição. O FHS também é usado no Linux Standard Base (consulte Resources). O FHS permite que os usuários e o software antecipem o local de arquivos e diretórios instalados. Um sistema de arquivos compatível com FHS pressupõe que o sistema operacional suporta os recursos de segurança básicos encontrados na maioria dos sistemas de arquivos Linux.

Na essência do FHS, estão duas características independentes de arquivos:

 Compartilhável vs. não compartilhável

Estático vs. variável 

Arquivos estáticos mudam somente por meio de intervenção do administrador do sistema, como na instalação ou atualização de um pacote, e inclui documentação, bibliotecas e binários. Arquivos variáveis são todos os outros arquivos, como logs, arquivos de spool, bancos de dados e dados do usuário, que estão sujeitos a alteração por parte de usuários e de processos do sistema.

Estas distinções permitem que arquivos com diferentes conjuntos de características sejam armazenados em diferentes sistemas de arquivos. A Tabela 1 é um exemplo do documento do FHS mostrando um layout que estaria em conformidade com o FHS.

Geralmente, os sistemas Linux contêm centenas de milhares de arquivos. Um sistema Fedora 13 de 64 bits que instalei recentemente tem mais de 75.000 arquivos apenas na hierarquia /usr. Muitas das minhas outras instalações têm mais de 100.000 arquivos e, frequentemente, 200.000 arquivos ou mais. As próximas quatro seções tratam de ferramentas para ajudar você a encontrar arquivos, especialmente programas, nesse vasto mar de dados.

Se você tem usado vários sistemas Linux, pode ter notado que, se fizer o login como root, poderá executar comandos comofdisk, que não poderia executar se fosse um usuário. Se você executar um programa na linha de comando, o shell bash (ou outro) procura em uma lista de diretórios para encontrar o programa solicitado. A lista de diretórios é especificada na variável de ambiente PATH, e o path do root pode incluir /sbin, enquanto paths de usuários não root não o incluem. A Listagem 1 mostra exemplos de path de usuários de duas distribuições diferentes, bem como um exemplo de path do root.

ian@pinguino:~$ # An Ubuntu 9.10 system
ian@pinguino:~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

[ian@echidna ~]$ # An openSUSE 11.2 system
ian@attic4:~> echo $PATH
/usr/lib64/mpi/gcc/openmpi/bin:/home/ian/bin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/u
sr/X11R6/bin:/usr/games:/usr/lib64/jvm/jre/bin:/usr/lib/mit/bin:/usr/lib/mit/sbin

[root@echidna ~]# # And as root
attic4:~ # echo $PATH
/usr/lib64/mpi/gcc/openmpi/bin:/sbin:/usr/sbin:/usr/local/sbin:/root/bin:/usr/local/bin:/
usr/bin:/bin:/usr/bin/X11:/usr/X11R6/bin:/usr/games:/usr/lib64/jvm/jre/bin:/usr/lib/mit/b
in:/usr/lib/mit/sbin

Como se pode ver, a variável PATH é apenas uma lista de nomes de diretório, separada por dois pontos. Como o comando fdiskestá realmente localizado em /sbin/fdisk, apenas o primeiro e o último desses caminhos permitiriam que o usuário o executasse, digitando fdisk sem fornecer um nome totalmente qualificado (/sbin/fdisk).

Normalmente, seu caminho é definido em um arquivo de inicialização, como .bash_profile ou .bashrc. É possível alterá-lo para o processo de bash atual especificando um novo caminho. Lembre-se de exportar a variável PATH se quiser que o novo valor esteja disponível para outros processos que iniciar a partir deste. Um exemplo é mostrado na Listagem 2.

                    
ian@attic4:~> fdisk
Absolute path to 'fdisk' is '/sbin/fdisk', so running it may require superuser privileges
 (e.g. root).
ian@attic4:~> export PATH=/sbin:$PATH
ian@attic4:~> fdisk

Usage: fdisk [-l] [-b SSZ] [-u] device
E.g.: fdisk /dev/hda  (for the first IDE disk)
  or: fdisk /dev/sdc  (for the third SCSI disk)
  or: fdisk /dev/eda  (for the first PS/2 ESDI drive)
  or: fdisk /dev/rd/c0d0  or: fdisk /dev/ida/c0d0  (for RAID devices)

Na seção anterior, você viu por que o comando fdisk pode não estar disponível, caso tenha tentado executá-lo. No entanto, existem diversos outros comandos úteis que podem ajudá-lo a encontrar qual comando, de fato, seria executado se você digitasse o nome de um comando.

É possível usar o comando which para buscar seu caminho e descobrir qual comando será executado (se houver algum) quando você digitar um comando. A Listagem 3 mostra um exemplo de como encontrar o comando fdisk.

                     
ian@attic4:~> which fdisk
which: no fdisk in (/usr/lib64/mpi/gcc/openmpi/bin:/home/ian/bin:/usr/local/bin:/usr/bin:
/bin:/usr/bin/X11:/usr/X11R6/bin:/usr/games:/usr/lib64/jvm/jre/bin:/usr/lib/mit/bin:/usr/
lib/mit/sbin)
ian@attic4:~> export PATH=/sbin:$PATH
ian@attic4:~> which fdisk
/sbin/fdisk

O comando which mostra a primeira ocorrência de um comando em seu caminho. Se você quiser saber se há diversas ocorrências, adicione a opção -a, como mostra a Figura 4.

                    
ian@attic4:~> which awk
/usr/bin/awk
ian@attic4:~> which -a awk
/usr/bin/awk
/bin/awk
/usr/bin/X11/awk
            

Aqui, encontramos o comando awk em três locais: em /usr/bin (que é o diretório principal para comandos no sistema), em /bin (que contém comandos que podem ser usados pelo administrador do sistema e pelos usuários, mas que são necessários quando nenhum outro sistema de arquivos estiver montado) e também em /usr/bin/X11 (que contém os binários para o Sistema Window X).

Outro artigo desta série, "Learn Linux 101: Criar e alterar links físicos e simbólicos," mostra como verificar se todos esses três diferentes arquivos representam, ao final, o mesmo comando gawk subjacente, como mostra a Listagem 5.

                    
ian@attic4:~> ls -l $(which -a awk)
lrwxrwxrwx 1 root root 4 2010-02-09 00:46 /bin/awk -> gawk
lrwxrwxrwx 1 root root 8 2010-02-09 00:46 /usr/bin/awk -> /bin/awk
lrwxrwxrwx 1 root root 8 2010-02-09 00:46 /usr/bin/X11/awk -> /bin/awk
            

Existem alguns comandos que o comando which não encontrará, como builtins de shell. O comando type é um builtin que dirá como uma cadeia de caracteres de comando dada será avaliada para execução. A Listagem 6 usa which e type para mostrar que o comando type não é um executável encontrado em seu caminho, mas um builtin de shell.

                   
ian@attic4:~> which type
which: no type in (/usr/lib64/mpi/gcc/openmpi/bin:/home/ian/bin:/usr/local/bin:/usr/bin:/
bin:/usr/bin/X11:/usr/X11R6/bin:/usr/games:/usr/lib64/jvm/jre/bin:/usr/lib/mit/bin:/usr/l
ib/mit/sbin)
ian@attic4:~> type type
type is a shell builtin
            

Se você desejar mais informações do que apenas a localização de um programa, use o comando whereis. Por exemplo, é possível encontrar as man pages ou outras informações, como mostrado na Listagem 7.

                    
ian@attic4:~> whereis awk
awk: /bin/awk /usr/bin/awk /usr/lib64/awk /usr/bin/X11/awk /usr/share/awk 
/usr/share/man/man1/awk.1.gz /usr/share/man/man1p/awk.1p.gz
            

Observe que a cópia de awk em /sbin não foi encontrada por whereis. Os diretórios usados por whereis são fixos, então o comando nem sempre poderá achar aquilo que você está procurando. O comando whereis também pode procurar arquivos de origem, especificar caminhos de procura alternativos e procurar entradas incomuns. Consulte as man pages para ver como substituir esse comportamento ou alterar os caminhos fixos usados por whereis.

Em um artigo anterior desta série, "Learn Linux, 101: Gerenciamento de arquivo e diretório", você aprendeu como encontrar arquivos baseados em nome (incluindo curingas), caminho, tamanho ou registro de data e hora. Em outro artigo anterior desta série, "Learn Linux, 101: Criar e alterar links físicos e simbólicos, você aprendeu como encontrar os links para um arquivo ou nó-i específico.

O comando find é o canivete suíço das ferramentas de procura de arquivos nos sistemas Linux. Outros dois recursos interessantes são a capacidade de encontrar arquivos com base em nome de usuário ou grupo e a capacidade de encontrar arquivos com base em permissões.

Suponha que você queira ver quais arquivos um usuário tem na hierarquia /tmp. A Listagem 8 mostra como o usuário root pode encontrar todos os arquivos do usuário ian em /tmp.

                    
attic4:~ # find /tmp -user ian
/tmp/kde-ian
/tmp/kde-ian/closeditems
/tmp/kde-ian/closeditems/_1.66
/tmp/kde-ian/systemsettingsR27913.tmp
/tmp/.ICE-unix/2288
/tmp/orbit-ian
/tmp/orbit-ian/linc-12f7-0-33cb4ce9b1fbf
/tmp/orbit-ian/linc-7d00-0-70e5ebaa4ddac
/tmp/orbit-ian/linc-12ea-0-68260abbd2051
/tmp/orbit-ian/linc-12ea-0-3377ca55c0bd2
/tmp/ksocket-ian
/tmp/ksocket-ian/klauncherMT2183.slave-socket
...

Também é possível encontrar arquivos por grupo usando o teste -group. Além disso, é possível encontrar arquivos que não pertencem a nenhum usuário ou grupo no sistema usando as opções -nouser e -nogroup. Assim como em outros testes, é possível negar o teste usando !. Geralmente, eu defino meu número do usuário para 1000, já que esse é o padrão em alguns sistemas. Também crio um grupo chamado ian sendo 1000 o número do grupo. Outros sistemas ainda começam com 500 ou, por padrão, colocam novos usuários no grupo "users". Parte do meu material de pesquisa mais antigo que foi arquivado a partir de um sistema Red Hat 6.2 ainda tem o usuário 500. A Listagem 9 mostra como encontrar alguns diretórios que não pertencem ao meu grupo de usuários atual. O research/rh62/involution pertence ao usuário 500 e ao grupo 4, nenhum dos quais existe em meu sistema atual. Para encontrar arquivos ou diretórios por ID numérico do usuário ou do grupo, use os testes -uid ou -gid.

                    
ian@attic4:~> find -L research -maxdepth 2 -type d ! -group ian
research/rh62/involution
research/rh62/programs
research/lost+found
find: `research/lost+found': Permission denied
ian@attic4:~> ls -ld research/rh62/involution
drwxr-xr-x. 2 500 4 4096 1999-11-10 08:09 research/rh62/involution

Para encontrar arquivos por permissão, é possível usar o teste -perm junto com expressões simbólicas semelhantes àquelas usadas com os comandos chmod ou umask. É possível procurar permissões exatas, mas normalmente é mais útil prefixar a expressão de permissão com um hífen, para indicar que você deseja arquivos com aquele conjunto de permissões, mas que não liga para as outras permissões. A Listagem 10 ilustra como encontrar arquivos que são executáveis por usuário, grupo e qualquer pessoa, e duas formas diferentes de encontrar arquivos que não podem ser lidos por outras pessoas.

                    
ian@attic4:~> find . -maxdepth 1 -type f -perm -uga=x
./.xinitrc.template
ian@attic4:~> ls -l ./.xinitrc.template
-rwxr-xr-x 1 ian users 1446 2010-02-09 08:55 ./.xinitrc.template
ian@attic4:~> find . -maxdepth 1 ! -perm  -o=r
./.Xauthority
./.pulse
...
ian@attic4:~> find . -maxdepth 1 ! -perm  -0004
./.Xauthority
./.pulse
...

Abordamos vários tipos importantes de procura que é possível fazer com o comando find. Para reduzir ainda mais sua saída, é possível combinar expressões múltiplas e é possível adicionar expressões regulares à combinação. Para aprender mais sobre esse comando versátil, use a man page, ou melhor, use info find se você possui o sistema de informações instalado.

A Listagem 11 mostra um exemplo final de procura com find. Esse exemplo faz um cd para /usr/include para manter o comprimento da listagem gerenciável, depois encontra todos os arquivos contendo packet em seu nome de caminho sem se importar com maiúsculas e minúsculas. O segundo exemplo restringe ainda mais essa saída para arquivos que não são diretórios e que possuem pelo menos 1500 bytes de tamanho. A saída real no seu sistema pode ser diferente, dependendo de quais pacotes você instalou.

                    
ian@attic4:/usr/include> find . -iregex ".*packet.*"
./c++/4.4/java/net/DatagramPacket.h
./c++/4.4/gnu/classpath/jdwp/processor/PacketProcessor.h
./c++/4.4/gnu/classpath/jdwp/transport/JdwpPacket.h
./c++/4.4/gnu/classpath/jdwp/transport/JdwpReplyPacket.h
./c++/4.4/gnu/classpath/jdwp/transport/JdwpCommandPacket.h
./netpacket
./netpacket/packet.h
./net/if_packet.h
./linux/if_packet.h
ian@attic4:/usr/include> find . -iregex ".*packet.*" ! -type d -size +1500c
./c++/4.4/java/net/DatagramPacket.h
./c++/4.4/gnu/classpath/jdwp/transport/JdwpPacket.h
./netpacket/packet.h
./linux/if_packet.h

Observe que a expressão regular deve corresponder ao caminho completo retornado por find, e lembre-se da diferença entre expressões regulares e curingas.

O comando find pesquisa todos os diretórios que você especificar, sempre que você executá-lo. Para acelerar as coisas, use outro comando, locate, que usa um banco de dados de informações armazenadas sobre caminhos em vez de pesquisar no sistema de arquivos todas as vezes.

O comando locate procura arquivos correspondentes em um banco de dados que geralmente é atualizado diariamente por uma tarefa cron.

O comando locate faz correspondência em relação a qualquer parte de um nome de caminho, não apenas em relação ao nome do arquivo. Coloque o nome de arquivo em aspas simples e inclua pelo menos um caractere globbing para tornar a correspondência mais precisa. A Listagem 12 mostra como encontrar caminhos que contêm a cadeia de caracteres bin/ls e mostra dois exemplos de como usar o caractere globbing para restringir a saída.

                    
ian@attic4:~> locate /bin/ls
/bin/ls
/bin/lsmod
/usr/bin/lsattr
/usr/bin/lsb_release
/usr/bin/lscpu
/usr/bin/lsdev
/usr/bin/lshal
/usr/bin/lsof
/usr/bin/lsscsi
/usr/bin/lsusb
ian@attic4:~> locate '\/bin/ls'
/bin/ls
ian@attic4:~> locate '/bin/ls*'
/bin/ls
/bin/lsmod

O banco de dados padrão usado por locate é armazenado no sistema de arquivos /var, em um local como /var/lib/locatedb. Isso pode ser diferente em sistemas que usam pacotes slocate ou mlocate para fornecer segurança ou velocidade adicional. É possível encontrar estatísticas em seu banco de dados locate usando locate -S, como mostra a Listagem 13.

                    
ian@attic4:~> locate -S
Database /var/lib/locatedb is in the GNU LOCATE02 format.
Locate database size: 3011297 bytes
All Filenames: 259149
File names have a cumulative length of 15751703 bytes.
Of those file names,

        11421 contain whitespace,
        0 contain newline characters,
        and 0 contain characters with the high bit set.
        Compression ratio 80.88% (higher is better)

O banco de dados é criado ou atualizado usando o comando updatedb. Ele normalmente é executado diariamente como uma tarefa cron. O arquivo /etc/updatedb.conf ou, às vezes, /etc/sysconfig/locate, é o arquivo de configuração para updatedb. Para habilitar atualizações diárias, o usuário root precisa editar /etc/updatedb.conf e definir DAILY_UPDATE=yes. Para criar o banco de dados imediatamente, execute o comando updatedb como root.

Outras considerações sobre o uso de locate incluem considerações sobre segurança e sobre E/S do arquivo de rede para compilações diárias do banco de dados updatedb. Consulte as man pages e os arquivos de configuração updatedb para obter mais detalhes.

O objetivo do FHS é manter o sistema de arquivos o menor possível. No entanto, ele deve conter todos os arquivos necessários para fazer o boot, restaurar, recuperar ou reparar o sistema, incluindo os utilitários que um administrador experiente precisaria para estas tarefas. Observe que a inicialização de um sistema exige que existam arquivos suficientes no sistema de arquivos root para permitir a montagem de outros arquivos de sistema.

A Tabela 2 mostra a finalidade dos diretórios que o FHS requer no sistema de arquivos root (ou /). O diretório ou um link simbólico para ele devem estar presentes, exceto para aqueles marcados como opcionais, que são necessários somente se o subsistema correspondente estiver presente.

As hierarquias /usr e /var são complexas o suficiente para ter seções inteiras do FHS dedicadas a elas. O sistema de arquivos /usr é a segunda maior seção do sistema de arquivos, contendo dados compartilháveis somente leitura. Ele pode ser compartilhado entre sistemas, apesar de as práticas atuais não fazerem isto frequentemente.

O sistema de arquivos /var contém arquivos de dados variáveis, incluindo diretórios e arquivos de spool, dados administrativos e de log, e arquivos temporários e transitórios. Algumas porções de /var não são compartilháveis entre sistemas diferentes, mas outras, como /var/mail, /var/cache/man, /var/cache/fonts e /var/spool/news podem ser compartilhadas.

Para entender completamente o padrão, leia o documento FHS (consulte Resources).

Aprender

• Use o Roteiro do developerWorks para LPIC-1 e localize os artigos do developerWorks que se destinam à preparação para a certificação LPIC-1, conforme os objetivos de abril de 2009.

• No site Programa LPIC, localize os objetivos detalhados, as listas de tarefas e as questões de amostra para os três níveis de certificação de administração de sistema Linux do Linux Professional Institute. Em particular, consulte os objetivos de abril de 2009 para o exame LPI 101 e o exame LPI 102. Sempre visite o site do Programa LPIC para obter os últimos objetivos.

• Estude toda a série de preparação para o exame LPI no developerWorks a fim de conhecer os fundamentos do Linux e se preparar para a certificação de administrador do sistema com base nos objetivos para o exame LPI traçados antes de abril de 2009.

• Visite a home do Filesystem Hierarchy Standard (FHS).

• Saiba mais sobre o Linux Standard Base (LSB), um projeto do Free Standards Group (FSG) para desenvolver um ambiente operacional binário padrão.

• O Linux Documentation Project apresenta uma variedade de documentos úteis, especialmente suas questões práticas. 

• Na zona Linux do developerWorks, encontre centenas de artigos e tutoriais, bem como downloads, fóruns de discussão e muitos outros recursos para desenvolvedores e administradores Linux. 

• Mantenha-se atualizado com os eventos técnicos e webcasts do developerWorks focados em uma variedade de produtos IBM e assuntos da indústria de TI. 

• Participe de uma orientação gratuita do developerWorks Live! para atualizar-se rapidamente sobre produtos e ferramentas da IBM, assim como tendências da indústria de TI. 

• Assista às demos on demand do developerWorks que abrangem da instalação do produto e demos de configuração para iniciantes à funcionalidade avançada para desenvolvedores experientes. 

• Siga o developerWorks no Twitter, ou inscreva-se em um feed dos tweets do Linux no developerWorks.

Obter produtos e tecnologias

• Avalie os produtos da IBM da forma que melhor lhe convém: Faça o download de uma versão de teste de produto, experimente um produto on-line, use um produto em um ambiente de nuvem ou passe algumas horas no SOA Sandboxaprendendo como implementar Arquitetura Orientada a Serviço de forma eficiente. 

Discutir

• Participar do fórum de discussão.

• Envolva-se na comunidade My developerWorks. Entre em contato com outros usuários do developerWorks enquanto explora os blogs, fóruns, grupos e wikis dos desenvolvedores. 

Ian Shields trabalha em vários dos projetos Linux para a zona Linux do developerWorks. Ele é um programador senior da IBM em Research Triangle Park, NC. Ele iniciou na IBM em Canberra, Austrália, como um Engenheiro de Sistemas em 1973 e, desde então, trabalhou em sistemas de comunicações e computação disseminada em Montreal, no Canadá, e em RTP na Carolina do Norte, nos Estados Unidos. Ele possui diversas patentes. Sua graduação é em matemática pura e filosofia na Australian National University. Ele possui mestrado em ciências e é doutor em ciências da computação na Universidade do Estado da Carolina do Norte.