%--------------------------------------------------------------------
\chapter{Usando discos e outros dispositivos de armazenamento}
%--------------------------------------------------------------------

        \begin{chapterquote}
	Em um disco vazio pode-se pesquisar eternamente. \\
        \end{chapterquote}

% the following metas need too much work for the next version
%
%	\meta copying a directory/disk verbatim
%
%	\meta disaster recovery: program to scan for ext2 superblocks
%
%	\meta explain lost+found; how to fix a filesystem; what to do when
%	there is a bad block; identifying the file that has the bad block
%	
%	\meta chart that shows characteristics of various fs: max size,
%	max file size, usable as root, max name length, speed, support
%
%	\meta 
%	Recovering from a bad MBR or super block.
%	Manually remounting (ro->rw, rw->ro, when, why)
%	automounting
%	MD patches
%	Why does Linux read/write disk in background?
%	how to mount a dos disk so that everyone can access it?
%	supermount
%	ide disks map away bad sectors (until they're too many, then
%	use badblocks)
%	mounting: mountee root becomes mount point, e.g. permissions/ownership
%	linux has maximum of 15 partitions (not inherent in partition
%		scheme!)
%	max ext2 part size is 2TB, file 2 GB
%	ext2 fragmentation
%	list important device files for disks et al as a table

        \noindent
		Ao instalar ou atualizar o sistema, é necessário preparar os 
		discos rígidos para isso. Deve-se criar sistemas de arquivos 
		para que arquivos possam ser armazenados e reservar espaços extras
		para as diferentes partes do sistema.

		Este capítulo explica todas estas atividades iniciais.
		Normalmente, uma vez que o sistema esteja
		configurado, não é necessário executar esta
		atividade novamente, exceto ao se utilizar
		disquetes. Será necessário retornar a este capítulo
		caso um novo disco seja adicionado ao sistema ou se
		queira refinar a utilização do disco já instalado.


		As atividades básicas na administração dos discos são:

	%%
        \begin{itemize}
        \item
		Formatar o disco. Nesta atividade várias tarefas são executadas,
		como por exemplo a  checagem de setores defeituosos. (A formatação
		hoje não é mais necessária para diversos discos rígidos).

        \item
		Particionar o disco. Indicado caso estejam previstas a execução 
		de diversas tarefas independentes entre si. Uma razão para o
		particionamento é manter diferentes sistemas operacionais no mesmo
		disco. Outra razão é a manutenção de arquivos de usuários separados de
		arquivos do sistema, simplificando a geração de cópias de segurança e 
		auxiliando na proteção dos arquivos do sistema operacional.

        \item
		Gerar um sistema de arquivos (de determinado tipo) para cada 
		disco ou partição. O disco em si não tem significado para o Linux, 
		até que um sistema de arquivos seja criado; assim arquivos podem ser
		criados e acessados.

        \item
		Montar diferentes sistemas de arquivos para formar uma única 
		árvore de diretórios, automática ou manualmente montadas (note que
		sistemas de arquivos montados manualmente, necessitam ser desmontados 
		da mesma forma).

        \end{itemize}

	O capítulo~\ref{chap:mem} contém ainda informações sobre memória
	virtual e cache de disco, os quais são conhecimentos importantes
	para o correto uso do disco.

		Este capítulo explica o que você precisa saber sobre
		discos rígidos, disquetes, CD-ROM's e unidades de fita.


%%\section{Two kinds of devices}
\section{Dois tipos de dispositivos}

	O \unix, e também o \linux, reconhecem dois tipos de
	dispositivos: de acesso randômico em blocos (como
	discos rígidos) e dispositivos a caracter (como
	fitas e linhas seriais), alguns dos quais podem
	ser de acesso randômico e outros de acesso seqüencial. 
	Cada dispositivo suportado é representado no sistema de 
	arquivos como um \defin{arquivo de dispositivo} (\defin{device}). 
	Ao ler ou gravar em um arquivo de dispositivo, as informações 
	vem e vão para o dispositivo por ele representado. Desta forma
	nenhum programa especial (e nenhum método especial
	de programação, como descobrir interrupções ou
	vasculhar portas seriais) é necessário para acessar
	os dispositivos. Por exemplo para enviar um arquivo
	para uma impressora pode-se simplesmente executar:

		%
		\begin{tscreen}
\verb|$| {\sl cat nome\_do\_arquivo $>$ /dev/lp1} \\ 
\verb|$|
		\end{tscreen}
		%
	e o conteúdo do arquivo será impresso (obviamente o arquivo deve 
	estar em um formato inteligível para a impressora). 
	Note que não é exatamente uma boa idéia ter-se diversos arquivos 
	direcionados para a impressora através do \cmd{cat}. Deve-se
	utilizar o comando \cmd{lpr}, o qual assegura que somente um
	arquivo será impresso por vez, e que enviará o arquivo
	seguinte imediatamente após a conclusão da impressão do anterior. 
	Algo similar é necessário para a maioria dos dispositivos. 
	Na verdade, raramente os arquivos de dispositivos são utilizado 
	diretamente e você não precisa se preocupar com eles.

	Desde que os dispositivos são apresentados como
	arquivos no sistema de arquivos (no diretório
	\fn{/dev)}, é fácil verificar quais dispositivos existem
	utilizando-se por exemplo  o \cmd{ls} ou outro
	similar. Na saída do comando \cmd{ls -l} a primeira
	coluna indica o tipo do arquivo e suas permissões.
	Veja um exemplo ao se examinar um dispositivo serial:                              

		%
		\begin{tscreen}
\verb|$| {\sl ls -l /dev/cua0} \\
\verb|crw-rw----   1 root     uucp       5,  64 set 23 13:48 /dev/cua0| \\
\verb|$| 
		\end{tscreen}
		%
	O primeiro caracter na primeira coluna, `{\tt c}' em {\tt crw-rw----}, 
	mostra-nos o tipo do arquivo, neste caso um dispositivo de caracter. 
	Para arquivos comuns o primeiro caracter é um `{\tt -}', para
	diretórios será `{\tt d}' e para dispositivos em blocos
	será `{\tt b}'. Verifique a página de manual  do \man{ls} para maiores 
	detalhes.

	Veja que normalmente todos os arquivos de
	dispositivos existem mesmo que o dispositivo em si
	não esteja instalado. Mesmo que exista um arquivo \fn{/dev/sda}, 
	não significa que realmente haja um disco SCSI instalado. Ter-se
	todos os arquivos de dispositivos, torna os programas de instalação 
	mais simples, assim como facilita a adição de novos componentes de hardware,
	pois não há necessidade de encontrar os parâmetros corretos para 
	criar os arquivos dos novos dispositivos.


%%\section{Hard disks}
\section{Discos rígidos}

	Esta seção introduz terminologias relacionadas com discos rígidos.
	Caso estes termos e conceitos já sejam de seu conhecimento, continue
	sua leitura na próxima seção.

	A figura~\ref{fig:hd-schematic} apresenta um esquema das partes
	importantes de um disco rígido. Ele consiste em um ou mais \defin{pratos} 
	circulares\footnote{Os pratos são feitos de um material rígido como o 
	alumínio, o que dá ao disco rígido o seu nome}, cada um com uma ou ambas
	as \defin{faces} cobertas por uma substância magnética usada para a 
	gravação de dados. Para cada face, há uma \defin{cabeça de leitura e 
	gravação} que examina ou altera os dados ali gravados. Os pratos giram 
	em um eixo comum e a velocidades superiores a 5.400 rotações por 
	minuto, sendo que discos de alta performance atingem velocidades maiores. 
	As cabeças movimentam-se ao longo do raio dos pratos; este movimento 
	combinado com a rotação dos pratos permite o acesso pelas cabeças a 
	qualquer parte da superfície.

	O processador (CPU) e o disco comunicam-se através da \defin{controladora
	de discos}. Isso retira dos outros componentes do computador o trabalho
	de saber como acessar o dispositivo, uma vez que as controladoras
	para diferentes tipos de discos podem utilizar a mesma interface com 
	o restante do computador. Assim, o computador pode dizer ``ei disco, me
	dê o dado que quero'', ao invés de enviar uma série de sinais elétricos 
	para mover as cabeças para o local adequado e esperar pelo correto 
	posicionamento dos pratos e todos os demais passos necessários. 
	Na realidade a interface da controladora é bastante complexa, mas muito 
	menos do que poderia ser um acesso direto ao disco. A controladora pode
	ainda executar outras tarefas como cache e realocação de setores 
	defeituosos.

	Estas são as informações necessárias para entender o funcionamento
	do hardware. Há ainda muitos outros aspectos, como o motor que gira
	os pratos e move as cabeças, e os componentes eletrônicos que controlam 
	as partes mecânicas do disco, porém estes aspectos não são relevantes 
	para o processo de entendimento dos princípios básicos do disco.

	A superfície dos pratos é normalmente dividida em anéis concêntricos,
	chamados \defin{trilhas} e estes por sua vez estão divididos em 
	\defin{setores.} Esta divisão é utilizada para especificar as 
	localizações dentro do disco e para alocação de espaço para os
	arquivos. Para encontrar um determinado ponto em um
	disco, deve-se dizer ``face 3, trilha 5, setor 7''.
	Normalmente o número de setores é o mesmo para todas
	as trilhas, mas alguns discos rígidos possuem um número maior de
	setores nas trilhas mais externas (todos os setores tem o mesmo tamanho
	físico, assim as trilhas externas comportam mais dados).  Tipicamente 
	um setor comporta 512~bytes de dados. O disco por si só não pode 
	manipular quantidades menores de dados que um setor.


		\begin{figure}[thb]
		\begin{center}
%%		\includegraphics{disks/hd-schematic.ps}
		\end{center}
%%		\caption{A schematic picture of a hard disk.}
		\caption{Desenho esquemático de um disco rígido}
		\label{fig:hd-schematic}
		\end{figure}

	Cada face é dividida em trilhas (e setores) do mesmo modo.  Assim quando 
	uma cabeça está sobre uma trilha, as cabeças das outras faces estão na
	mesma trilha correspondente. O conjunto destas trilhas formam um 
	\defin{cilindro.} 
	O movimento das cabeças de uma trilha (ou cilindro) para outra
	utiliza um determinado intervalo de tempo. Colocando-se os dados que são 
	normalmente acessados de forma conjunta (digamos um arquivo)  em
	localizações contíguas dentro do disco, o movimento das cabeças será 
	menor, melhorando a performance do sistema. Nem sempre é possível 
	armazenar os arquivos desta forma;  arquivos que estão dispostos em 
	diversos locais do disco são chamados de \defin{fragmentados}.

	O número de faces (ou cabeças, que é o mesmo), cilindros e setores
	varia bastante. A especificação deste número é chamada \defin{geometria} 
	do disco rígido. A geometria é normalmente arquivada de forma especial,
	em uma posição da memória alimentada por pilhas, chamada \defin{CMOS RAM},
	da qual o sistema operacional pode recuperar durante a inicialização
	do sistema.

	Infelizmente a BIOS\footnote{A BIOS é um programa básico do computador, 
	armazenada em ROM. Ela cuida, entre outras coisas, do estágio inicial 
	de inicialização do sistema} tem um desenho limitado, o que torna 
	impossível especificar na CMOS RAM um número de trilhas maiores que 1.024,
	o que é muito pouco para discos maiores. A saída encontrada 
	para isso foi a controladora "mentir" sobre a geometria e \defin{converter 
	os endereços} dados pelo computador em endereços corretos. Por exemplo,
	consideremos um disco rígido que tenha 8 cabeças, 2048 trilhas e 35 
	setores por trilha\footnote{Os números são fictícios}. A controladora 
	pode informar que o disco tem 16 cabeças, 1024 trilhas e 35 setores por 
	trilha, não excedendo o limite do número de trilhas e dividindo à metade
	o número de trilhas e duplicando o de cabeças para chegar à capacidade 
	exata do disco. Na realidade a matemática pode ser um pouco mais 
	complicada, porque os números podem não ser tão exatos como no nosso 
	exemplo, porém estes detalhes não são relevantes para o entendimento do 
	princípio.  Esta conversão distorce a visão do disco pelo sistema 
	operacional, tornando impraticável o uso de todos os dados em um cilindro 
	para o incremento da performance.

	A conversão é um problema somente em discos IDE. Discos SCSI 
	tem um número seqüencial de setores (a controladora traduz o número
	seqüencial do setor em um endereço composto por cabeça, cilindro e setor), 
	e usa um método completamente diferente de comunicação entre a CPU
	e a controladora, não tendo este tipo de problema.  Note que de 
	qualquer forma o computador pode também não saber a real geometria de 
	um disco SCSI.

	O Linux com freqüência não conhecerá a real geometria de um disco, 
	seus sistemas de arquivos sequer tentarão manter os arquivos em um
	único cilindro. Ao invés disso ele tentará utilizar setores consecutivos
	para os arquivos, o que proporciona quase a mesma performance. O tema 
	complica-se com caches e acessos automáticos feitos pela controladora.

	Cada disco rígido é representado por um arquivo de
	dispositivo distinto. Eles podem (normalmente) ser
	dois ou quatro para discos IDE, e são conhecidos como 
	\fn{/dev/hda}, \fn{/dev/hdb}, \fn{/dev/hdc} e
	\fn{/dev/hdd}, respectivamente. Discos SCSI são
	conhecidos como \fn{/dev/sda}, \fn{/dev/sdb}, \fn{/dev/sdc} e
	/dev/sdd. Convenções similares para nomes existem
	para outros tipos de discos; veja~\cite{device-list} para mais
	informações. Note que os arquivos de dispositivos de
	discos rígidos dão acesso a todo o disco, sem
	preocupar-se com as partições (que serão discutidas
	adiante), e pode ser simples desorganizar as partições ou as 
	informações nelas contida caso não se tenha
	cuidado. Os arquivos de dispositivos de discos são
	normalmente utilizados somente para a obtenção de
	dados do registro mestre de inicialização (MBR).
\index{MBR}


%%\section{Floppies}
\section{Discos flexíveis}

	Um disquete consiste em uma membrana flexível
	coberta em um ou ambos os lados com uma substância
	magnética similar a de um disco rígido. O disquete
	por si só não tem uma cabeça de leitura e gravação,
	a qual está na unidade de disquetes. Um disquete
	corresponde a um prato do disco rígido, porém  é
	removível e uma unidade de disquetes pode tratar
	diferentes disquetes, enquanto um disco rígido é
	uma unidade indivisível.

	Como um disco rígido, um disquete está dividido em trilhas e setores 
	(e as trilhas de ambos os lados do disquete formam um cilindro), 
	mas em menor quantidade que em um disco rígido.

	Uma unidade de disquetes pode normalmente tratar
	diferentes tipos de disquetes; por exemplo, uma unidade de $3{1\over 2}$
	polegadas pode usar tanto discos de 720~Kb como de 1.44~Mb.
	Porém o dispositivo terá que operar de forma um
	pouco diferente e o sistema operacional deverá
	saber qual o real tamanho do disquete. Para tanto
	há diversos arquivos de dispositivos para unidades
	de disquetes, uma para cada combinação de
	dispositivo e tipo de disquete. O  \fn{/dev/fd0H1440}
	é o primeiro dispositivo de disquetes (\texttt{fd0}),
	que serve para uma unidade de $3{1\over 2}$ polegadas, de alta
	densidade (\texttt{H} - high) e com a capacidade de 1440~Kb 
	(\texttt{1440}).

	Os nomes dos arquivos de controle de unidades de
	disquetes são complexos, e no \linux\ há tipos
	especiais de dispositivos que podem detectar
	automaticamente o tipo de disco na unidade. Isso
	funciona através da leitura do primeiro
	setor de um disquete recém- inserido, usando
	diferente tipos de dispositivos, até que o dispositivo correto seja
	encontrado. Isso naturalmente requer que
	o disquete esteja formatado. Os dispositivos
	automáticos são chamados \fn{/dev/fd0}, \fn{/dev/fd1} e assim
	por diante.

	Os parâmetros que os dispositivos automáticos utilizam podem ser 
	configurados através do programa \cmd{setfdprm}. Isso pode ser útil 
	caso não se utilizem tamanhos usuais de discos, ou se, por
	exemplo, eles têm um número diferente de setores, ou se a autodetecção
	falhou por alguma razão e o dispositivo correspondente não existe.

	O \linux\ pode manusear diversos formatos de disquetes
	não padronizados. Alguns desses formatos requerem a utilização de programas
	especiais de formatação. Não comentaremos esses
	tipos, porém você pode verificar o arquivo \fn{/etc/fdprm}.
	Ele especifica os parâmetros que o comando \cmd{setfdprm} reconhece.

	O sistema operacional deve saber toda a vez que o
	disquete for substituído na unidade, para evitar, por
	exemplo, manter dados no cache de um disquete não mais disponível.
	Infelizmente a linha de sinalização utilizada para transmitir esta
	informação algumas vezes pode não estar disponível ou pior nem sempre
	haverá notificação ao se usar o dispositivo dentro do MS-DOS. Caso 
	problemas estranhos estejam ocorrendo, esta pode ser uma possível razão. 
	O único meio de corrigir este problema é substituir a unidade de disquetes.

\section{CD-ROM's}

	O leitor de CD-ROM utiliza um leitor ótico circular.
	A informação é gravada na superfície do disco\footnote{Na verdade,
	no disco metálico dentro da proteção plástica} em pequenos `orifícios'
	alinhados ao redor de uma espiral do centro para a
	borda. O dispositivo direciona um feixe de laser na
	espiral para poder ler os dados contidos no disco.
	Quando o laser atinge um dos `orifícios', o laser é
	refletido de uma determinada forma; quando ele
	atinge a superfície lisa é refletido de outra. Isso
	permite a criação de um código de bits e portanto
	de informação. O restante é simples, mecânico.
\index{CD-ROM}

	Leitores de CD-ROM são lentos, quando comparados a discos rígidos. 
	Onde um disco rígido típico tem um tempo médio de acesso de menos de 
	15~milisegundos, um CD-ROM rápido pode chegar a décimos de segundos a 
	cada leitura. A taxa atual de transferência está em torno das centenas de 
	kilobytes por segundo. A lentidão dos CD-ROM significa que eles não são 
	tão agradáveis de usar quanto os discos rígidos. Porém para instalações 
	de novos programas, os CD-ROMs são muito indicados , uma vez que a 
	velocidade
	não é essencial neste momento. Algumas distribuições do \linux\ 
	disponibilizam sistemas de arquivos prontos para execução em CD-ROMs, 
	tornando a instalação mais simples e economizando bastante
	espaço em disco.

	Há muitas formas de arrumar os dados em um CD-ROM.
	O mais popular é o especificado pelo padrão
	internacional ISO~9660. Este padrão especifica um
	sistema de arquivos mínimo, que é mais rudimentar
	do que o do MS-DOS. Por outro lado, é tão simples que
	qualquer sistema operacional poderá mapeá-lo em
	modo nativo.

	Para uso normal no \unix, o sistema de arquivos ISO~9660 não é muito 
	útil, então uma extensão chamada \texttt{Rock Ridge} foi desenvolvida. 
	A Rock Ridge permite nomes longos de arquivos, links simbólicos e uma 
	série de outras facilidades, tornando o CD-ROM similar a qualquer 
	sistema de arquivos \unix. E melhor ainda, um sistema de
	arquivos Rock Ridge é ainda um sistema de arquivos
	válido para o ISO~9660, tornando-o passível de utilização também sob
	sistemas não-\unix. O \linux\ suporta ambos os formatos: ISO~9660 e 
	Rock Ridge, sendo as extensões reconhecidas automaticamente.

	O sistema de arquivos é somente metade da questão.
	Muitos CD-ROMs contém dados que requerem programas
	especiais de acesso e muitos desse programas podem
	não ser compatíveis com o \linux (exceto,
	possivelmente, sob o dosemu, a emulação MS-DOS do \linux).

	Um leitor de CD-ROM é acessado através do arquivo de dispositivo 
	correspondente. Há muitas formas de conectar uma unidade de CD-ROM ao
	computador: via SCSI, via placa de som, ou via EIDE. Os detalhes de 
	hardware estão fora do escopo deste livro. Porém o tipo de conexão 
	definirá o arquivo de dispositivo. Veja~\cite{device-list} para maiores 
	detalhes.


%%\section{Tapes}
\section{Fitas}

	Uma unidade de fitas utiliza fitas similares\footnote{Mas completamente
	diferentes, é lógico!} aos cassetes usados para música. Uma fita é serial
	por natureza, o que significa que para obter qualquer informação ali
	armazenada, é necessário passar por todas as outras partes que estejam 
	antes do ponto desejado. Um disco pode ser acessado
	randomicamente, isto é, pode-se buscar um dado diretamente, 
	independente do ponto em que esteja no disco. O acesso serial torna 
	as fitas bastante lentas, quando comparadas com disco rígidos.

	Por outro lado, as fitas são relativamente baratas, uma vez que elas 
	não necessitem ser rápidas. Elas podem ter tamanhos extremamente longos
	e consequentemente poder reter uma grande quantidade de dados. Isso
	torna as fitas muito apropriadas para atividades como arquivamentos ou 
	para se gerar cópias de segurança, as quais não requerem grandes 
	velocidades, mas possuem o benefício de baixo custo  e alta capacidade de
	armazenamento.


%%\section{Formatting}
\section{Formatação}

	\defin{Formatar} é o processo de inicializar uma mídia
	magnética, gerando-se as marcas de trilhas e
	setores. Antes de um disco ser formatado, a sua
	superfície magnética é uma confusão de sinais
	magnéticos. Após a sua formatação, alguma ordem é
	dada a esse caos, basicamente delineando-se as
	linhas onde as trilhas estarão presentes e onde
	elas estarão divididas em setores. O detalhamento
	deste processo mostra algumas diferenças em relação
	ao princípio, porém dentro do escopo deste manual
	isto não é relevante. O que realmente importa é que
	um disco não pode ser utilizado até que seja
	formatado.

	A terminologia pode ser um pouco confusa aqui: no MS-DOS a palavra 
	formatação é utilizada com a abrangência também da criação dos 
	sistemas de arquivos (o qual será discutido a seguir). Estes
	dois processo estão geralmente combinados, especialmente em disquetes. 
	Quando uma distinção faz-se necessária, a real formatação é chamada de
	\defin{formatação de baixo nível}, enquanto que a geração de sistemas de
	arquivos é denominada de \defin{formatação de alto nível}. No \unix\ as
	duas são denominadas: formatação e criação de sistemas de arquivos, 
	e é assim que utilizaremos neste livro.


	Para discos IDE e alguns SCSI, a formatação é
	realizada na fábrica e não necessita ser repetida;
	por isso não há porque preocupar-se com o tema. Na
	verdade formatar um disco rígido pode causar
	problemas no seu funcionamento, por exemplo, por
	ser necessário formatar o disco de uma forma especial ou
	diferente para permitir a realocação automática de
	setores defeituosos.


	Discos que necessitem ser formatados freqüentemente requerem um programa 
	especial, uma vez que a interface de formatação lógica dentro do
	dispositivo varia de disco para disco. O programa de formatação é 
	normalmente fornecido com a controladora ou através de um programa DOS, 
	sendo que nenhum dos dois tende a ser de simples utilização sob o Linux.

	Durante a formatação pode-se encontrar pontos ruins
	no disco, chamados de \defin{blocos defeituosos}\footnote{\defin{bad blocks}} ou \defin{setores defeituosos}\footnote{\defin{bad sectors}}. 
	Algumas vezes isso é administrado pelo
	próprio dispositivo, mas mesmo assim, caso o seu
	número seja muito grande,  algo precisará ser feito
	para evitar o uso destas partes do disco.  A
	lógica para se fazer isso reside nos sistemas de
	arquivos; como adicionar estas informações ao sistema de arquivos
	está descrito abaixo. Alternativamente pode-se criar uma
	pequena partição que abrigue somente os setores
	defeituosos do disco, sendo essa abordagem mais
	adequada caso existam porções substanciais do disco
	com defeitos, uma vez que o sistema de arquivos pode ter problemas
	com grandes áreas de blocos defeituosos.

	Disquetes são formatados com o comando \cmd{fdformat}. O arquivo de
	dispositivos da unidade de disquetes é informado
	através de parâmetro. O seguinte comando é dado para se formatar um 
	disco de $3{1\over 2}$ polegadas e de
	alta densidade na primeira unidade de disquetes:

		%
		\begin{tscreen}
\verb|$| {\sl fdformat /dev/fd0H1440} \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|Verifying ... read: Success| \\
\verb|$ |
		\end{tscreen}
		%
	Note que caso você necessite auto-detectar o tipo
	de dispositivo (por exemplo \fn{/dev/fd0}), {\em deve-se}
	configurar os parâmetros com o comando \cmd{setfdprm} 
	primeiramente. Para conseguir o mesmo resultado do comando anterior,
	deve-se executar os seguintes passos:

		%
		\begin{tscreen}
\verb|$| {\sl setfdprm /dev/fd0 1440/1440} \\
\verb|$| {\sl fdformat /dev/fd0} \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|Verifying ... read: Success| \\
\verb|$ |
		\end{tscreen}
		%

	Normalmente é mais conveniente escolher o arquivo
	de dispositivo que se adapte com o tipo de
	disquete. Note que não é recomendado formatar disquetes com uma 
	capacidade maior de armazenamento do que aquela original de fábrica.


	O \cmd{fdformat} validará o disquete, isto é, verificará os
	blocos defeituosos, testando-os diversas vezes (pode-se ouvir isto, 
	pois o barulho da unidade cresce substancialmente). Se o disquete
	tem somente problemas superficiais (como sujeira na
	cabeça de leitura e gravação, alguns erros podem ser falsos), 
	o \cmd{fdformat} será executado normalmente,
	mas se um erro real for encontrado, o processo será
	finalizado imediatamente. O kernel apresentará
	mensagens para cada erro que seja encontrado,
	as quais serão apresentadas na console, ou, caso o
	\cmd{syslog} esteja sendo usado,  no arquivo
	\fn{/var/log/messages}. O \cmd{fdformat} não identificará nem
	apresentará a localização exata do erro, pois um
	disquete é barato o suficiente para que possa ser
	substituído imediatamente.

		%
		\begin{tscreen}
\verb|$| {\sl fdformat /dev/fd0H1440} \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|Verifying ... read: Unknown error| \\
\verb|$ |
		\end{tscreen}
		%

	O comando \cmd{badblocks} pode ser utilizado para
	pesquisar qualquer disco ou partição na detecção de
	blocos defeituosos (inclusive em um disquete). Ele
	não formata o disco, portanto pode ser utilizado
	para sistemas de arquivos já existentes. O
	exemplo a seguir verifica um disquete de $3{1\over 2}$ polegadas que
	apresentou dois blocos com defeitos:

		%
		\begin{tscreen}
\verb|$| {\sl badblocks /dev/fd0H1440 1440} \\
\verb|718| \\
\verb|719| \\
\verb|$ |
		\end{tscreen}
		%
	A saída do programa apresenta o número dos blocos
	defeituosos encontrados. Muitos sistemas de
	arquivos podem evitar tais blocos. Eles mantém uma
	lista destes, a qual é inicializada quando o
	sistema de arquivos é gerado e posteriormente
	atualizada. A pesquisa inicial por blocos
	defeituosos pode ser realizada pelo comando \cmd{mkfs}
	(que inicializa sistemas de arquivos), mas
	posteriormente deve ser realizada pelo comando
	\cmd{badblocks} e novos blocos podem ser adicionados com
	o comando \cmd{fsck}. Estes comandos serão descritos
	posteriormente.


	Muitos discos novos avisam sobre blocos defeituosos e tentam 
	consertá-los, usando em seu lugar um bloco especial, que não 
	tenha problemas e foi reservado  para estas situações. Isso é
	transparente para o sistema operacional e tal
	facilidade deve estar documentada no manual do
	disco rígido. Mesmo este tipo de disco pode falhar caso o
	número de blocos defeituosos cresça demasiadamente,
	apesar que nesta altura o disco deverá estar tão ruim que você já 
	estará pensando em substituí-lo.


%%\section{Partitions}
\section{Partições}

	Um disco rígido pode ser divido em diversas
	\defin{partições}. Cada partição funciona como se fosse um
	disco rígido em separado. A idéia é que se há
	somente um disco rígido, e você deseja ter dois sistemas operacionais 
	instalados, pode-se dividi-lo em duas partições. Cada sistema operacional
	teria a sua partição própria, sem interferir nos dados do outro sistema. 
	Desta forma eles podem coexistir pacificamente no mesmo dispositivo. Sem
	o particionamento deveriam haver dois discos, um para cada sistema.


	Disquetes não são particionados. Não há razões
	técnicas contrárias, porém pelo fato de serem tão
	pequenos, partições não têm aplicação prática nesta
	mídia. CD-ROMs também normalmente não são
	particionados, uma vez que é muito simples utilizá-
	los como um grande disco, e dificilmente haverá
	mais de um sistema operacional em um CD.


%%\subsection{The MBR, boot sectors and partition table}
\subsection{O MBR, setores de inicialização e tabela de partições}

	As informações de como um disco rígido está particionado são armazenadas 
	no seu primeiro setor (isto é, no primeiro setor, da primeira trilha da
	primeira face do primeiro disco). O primeiro setor é o \defin{master boot 
	record}\footnote{\defin{registro mestre de inicialização}} (MBR) do 
	disco. Este é o setor que a BIOS lê e inicializa, quando a máquina é 
	ligada. O master boot record contém um pequeno programa que lê a tabela 
	de partições, verifica qual partição está ativa (isto é, marcada como 
	inicializável) e lê o primeiro setor desta partição, o \defin{setor de 
	inicialização}\footnote{\defin{boot sector}} da partição (o MBR também 
	é um setor de inicialização, mas tem um nome diferente por executar 
	diferentes funções). O setor de inicialização contém outro pequeno 
	programa que lê a primeira parte do sistema operacional armazenado 
	naquela partição (assumindo que ela seja inicializável, ou seja, que possa
	iniciar o sistema operacional) e ativa o sistema operacional lá armazenado.


	O esquema de particionamento não é definido pelo
	hardware, muito menos pela BIOS. É somente uma
	convenção que diversos sistemas operacionais
	seguem. Os poucos que não a seguem são considerados
	exceções. Alguns sistemas operacionais suportam
	partições, mas ocupam uma partição do disco 
	e usam métodos internos de particionamento naquela
	partição. Esse tipo de partição pode conviver
	pacificamente com outros sistemas operacionais,
	inclusive com o \linux, e não requerem medidas
	especiais, porém um sistema operacional que não
	suporte partições não poderá coexistir no
	mesmo disco.


	Como medida preventiva é uma boa idéia anotar os dados das partições 
	em um pedaço de papel, assim, mesmo que a tabela de partições
	esteja corrompida, não se perderão todos os arquivos. (Uma tabela 
	defeituosa pode ser consertada com o \cmd{fdisk}). Informações relevante 
	são fornecidas pelo comando \cmd{fdisk -l}:

		%
	\begin{tscreen}
\verb|$| \textsl{fdisk -l /dev/hda} \\
\verb|| \\
\verb|Disk /dev/hda: 15 heads, 57 sectors, 790 cylinders| \\
\verb|Units = cylinders of 855 * 512 bytes| \\
\verb|| \\
\verb|   Device Boot  Begin   Start     End  Blocks   Id  System| \\
\verb|/dev/hda1           1       1      24   10231+  82  Linux swap| \\
\verb|/dev/hda2          25      25      48   10260   83  Linux native| \\
\verb|/dev/hda3          49      49     408  153900   83  Linux native| \\
\verb|/dev/hda4         409     409     790  163305    5  Extended| \\
\verb|/dev/hda5         409     409     744  143611+  83  Linux native| \\
\verb|/dev/hda6         745     745     790   19636+  83  Linux native| \\
\verb|$|
	\end{tscreen}

%%\subsection{Extended and logical partitions}
\subsection{Partições estendidas e lógicas}

	O esquema original para discos
	rígidos dos PCs permite somente quatro partições.
	Isso rapidamente tornou-se muito reduzido para o
	atendimento das necessidades do mundo real,
	principalmente porque as pessoas desejavam utilizar
	diversos sistemas operacionais (\linux, MS-DOS,
	OS/2, Minix, FreeBSD, NetBSD, ou Windows/NT, para
	enumerar alguns), assim como ter diversas partições em  um único sistema
	operacional pode ser uma boa idéia. Por exemplo a área de swap, por
	questões de performance, deve ter a sua própria
	partição no \linux, ao invés de utilizar a partição
	principal.


	Para solucionar estes problemas de projeto, foram
	criadas as \defin{partições estendidas}. Este truque
	permite que a \defin{partição primária} seja particionada
	em subpartições. A partição primária subdividida é
	uma partição estendida, as subpartições são chamadas
	\defin{partições lógicas}. Elas comportam-se exatamente como
	partições primárias, mas são criadas de forma
	diferente, não havendo diferença de velocidade entre elas.


	A estrutura de partições de um disco rígido pode
	aparentar algo similar à figura~\ref{fig:hard-disk-layout}. O disco é
	dividido em três partições primárias, a segunda das
	quais é dividida em duas partições lógicas. Parte
	do disco não está particionado. O disco como um
	todo e cada partição primária tem um setor de
	inicialização.


		\begin{figure}[thb]
		\begin{center}
%%		\includegraphics{disks/hd-layout.ps}
		%\include{hd-layout}
		\end{center}
		\caption{Exemplo de particionamento de disco.}
		\label{fig:hard-disk-layout}
		\end{figure}

%%\subsection{Partition types}
\subsection{Tipos de Partições}

	As tabelas de partições (uma no MBR e outras para as
	partições estendidas) contém um byte que identifica
	o tipo da partição. É uma tentativa de identificar
	o sistema operacional que utiliza aquela partição
	ou para qual a sua finalidade. O propósito é evitar que 
	sistemas operacionais utilizem inadvertidamente a mesma partição. 
	Na verdade, os sistemas operacionais não se importam com o byte de tipo de
	partição (o \linux\ na verdade nem toma conhecimento dele). Pior, alguns 
	deles o utilizam incorretamente como algumas versões do DR-DOS.

	Não há um padrão internacional para especificar o
	que cada byte significa, mas os mais comuns e
	aceitos estão descritos na tabela~\ref{tab:partition-ids}. A mesma lista
	está disponível no programa \cmd{fdisk} do Linux.

\begin{table}[ht]
\caption{Tipos de partição (extraído do programa \cmd{fdisk}).}
\begin{center}
\begin{tabular}{rl rl rl rl}
\hline
0 & Empty               & 40 & Venix 80286  & 94 & Amoeba BBT     \\
1 & DOS 12-bit FAT      & 51 & Novell?      & a5 & BSD/386        \\
2 & XENIX root          & 52 & Microport    & b7 & BSDI fs        \\
3 & XENIX usr           & 63 & GNU HURD     & b8 & BSDI swap      \\
4 & DOS 16-bit $<$32M   & 64 & Novell       & c7 & Syrinx         \\
5 & Extended            & 75 & PC/IX        & db & CP/M           \\
6 & DOS 16-bit $\ge$32M & 80 & Old MINIX    & e1 & DOS access     \\
7 & OS/2 HPFS           & 81 & Linux/MINIX  & e3 & DOS R/O        \\
8 & AIX                 & 82 & Linux swap   & f2 & DOS secondary  \\
9 & AIX bootable        & 83 & Linux native & ff & BBT            \\
a & OS/2 Boot Manag     & 93 & Amoeba       &    &                \\
\hline
\end{tabular}
\end{center}
\label{tab:partition-ids}
\end{table}

%%\subsection{Partitioning a hard disk}
\subsection{Particionando um disco rígido}

	Há muitos programas para criação e remoção de
	partições. A maioria dos sistemas operacionais tem
	o seu próprio, e pode ser uma boa idéia usá-los,
	para evitar situações não suportadas pelos outros.
	Muitos programas são chamados \cmd{fdisk}, inclusive o
	programa do \linux, ou suas variações. Detalhes
	sobre a utilização do \cmd{fdisk} são apresentadas na
	sua página de manual ou no Apêndice~\ref{chap:comandos}. O comando 
	\cmd{cfdisk} é similar ao \cmd{fdisk} porém mais agradável, por possuir
	uma interface mais amigável ao usuário. No Conectiva Linux pode ainda 
	ser encontrado o \cmd{DiskDruid}, um particionador extremamente 
	poderoso no momento da instalação do sistema.

	Ao utilizar discos IDE, a partição de inicialização
	(aquela que contém os arquivos de imagem do kernel
	do sistema) deve residir inteiramente nos primeiros
	1024 cilindros. Isso deve-se ao fato que o disco
	é usado através da BIOS na inicialização do sistema 
	(antes do sistema entrar em modo protegido) e a BIOS
	não pode gerenciar mais que 1024 cilindros. Pode-se
	ainda usar uma partição que esteja somente
	parcialmente nos  1024 cilindros iniciais, desde
	que todos os arquivos necessários à inicialização
	do sistema estejam dentro do limite da BIOS. Porém
	esta é uma prática \emph{desaconselhada} pois novas
	compilações do kernel ou fragmentações do disco
	podem colocar os arquivos fora deste limite. De
	qualquer forma há que se estar seguro de que os
	arquivos necessários à inicialização do sistema
	estejam nos primeiros 1024 cilindros.
\index{BIOS}

	Algumas versões novas de BIOS e de discos IDE conseguem efetivamente 
	gerenciar discos com mais de 1024 cilindros. Caso se tenha um sistema 
	desses disponível, este problema não existirá e os arquivos de 
	inicialização podem estar em qualquer ponto do disco.


	Cada partição deve ter um número par de setores,
	uma vez que os sistemas de arquivos do \linux\ usam
	blocos de 1~Kb de tamanho, ou seja dois setores. Um
	número ímpar resultará na não utilização do último
	setor. Isso não é necessariamente um problema,
	porém é bastante desagradável e algumas versões do
	\cmd{fdisk} podem alertar sobre o problema.


	Alterar o tamanho de uma partição normalmente requer que
	seja efetuada uma cópia de segurança de tudo que se deseja salvar e que 
	esteja presente na partição (preferencialmente do
	disco todo como medida preventiva), apagá-la, criar
	uma nova, e restaurar os arquivos na nova partição.
	Se a partição estiver crescendo, pode-se, também,  ter que
	ajustar o tamanho de partições adjacentes (assim como das cópias de 
	segurança).


	Uma vez que alterar o tamanho das partições é
	bastante trabalhoso, é preferível tê-las bem
	dimensionadas desde o início, ou ter-se um
	eficiente sistema de cópias de segurança
	implementado. Caso a instalação seja a partir de
	uma mídia que não requeira muita intervenção humana
	(CD-ROM comparado com disquetes), é
	fácil testar diferentes configurações num
	primeiro momento, já que não há dados para serem
	copiados, tornando menos trabalhoso modificar o
	tamanho das partições diversas vezes.


	Há um programa para o MS-DOS chamado \cmd{fips}, que redimensiona
	uma partição FAT/FAT32 sem que seja necessário reinstalar o sistema.
	


%%\subsection{Device files and partitions}
\subsection{Dispositivos e partições}

	Cada partição e partição estendida tem o seu
	próprio arquivo de dispositivo. A convenção da
	nomenclatura destes arquivos é formada por um
	número adicionado após o nome do disco, variando de
	1 a 4 para partições primárias (independentes de
	quantas elas sejam) e de 5 a 8 para as partições
	lógicas (independente de onde elas residam). Por
	exemplo o \fn{/dev/hda1} é o primeira partição primária
	no primeiro disco IDE e \fn{/dev/sdb7} é a terceira
	partição estendida no segundo disco SCSI. A lista de dispositivos
	em~\cite{device-list} traz mais informações.

%% incluir esta lista de dispositivos no livro ???


%%\section{Filesystems}
\section{Sistema de arquivos}
\label{sec:filesystems}

%%\subsection{What are filesystems?}
\subsection{O que é um sistema de arquivos?}

\index{sistema de arquivos}
	Um \defin{sistema de arquivos} é o método e a estrutura de
	dados que um sistema operacional utiliza para
	administrar arquivos em um disco ou partição, ou
	seja, a forma pela qual os arquivos estão
	organizados em um disco. A expressão também é
	utilizada para se referenciar a uma partição ou
	disco que seja usado para armazenar os arquivos ou
	outros tipos de sistemas de arquivos. Alguém pode
	dizer ``eu tenho dois sistemas de arquivos'',
	significando que tem duas partições nas quais
	armazena arquivos ou aquela pessoa está usando o ``sistema de arquivos 
	estendido'', exemplificando o tipo do sistema de arquivos.

	A diferença entre um disco ou partição e um sistema
	de arquivos é bastante significativa. Poucos
	programas (inclusive os programas que criam
	sistemas de arquivos) operam diretamente em setores
	não inicializados de um disco ou partição, e caso
	exista um sistema de arquivos ele será destruído ou
	danificado seriamente. A maioria dos programas trabalham em
	um sistema de arquivos e não funcionam em uma
	partição que não contenha um (ou que contenha um de
	tipo errado).

	Antes de uma partição ou disco ser usado como um
	sistema de arquivos ele necessita ser inicializado,
	e a estrutura básica de dados necessita ser gravada
	no disco. Este processo é chamado \defin{criação de um
	sistema de arquivos}.


	Muitos sistemas de arquivos do \unix\ tem uma estrutura similar, apesar 
	dos detalhes exatos variarem um pouco. Os conceitos básicos são 
	\defin{superbloco}, \defin{inode}, \defin{bloco de dados}, 
	\defin{bloco de diretórios} e \defin{bloco de indireção}. 
	O superbloco contém as informações sobre o sistema de arquivos 
	como um todo, como por exemplo seu tamanho (a informação exata depende do 
	sistema de arquivos). Um inode contém as informações sobre um determinado 
	arquivo, exceto seu nome. O nome está armazenado no diretório, junto com 
	o número do inode. Uma entrada de diretório é formada pelo nome e pelo 
	número do inode que representa o arquivo. O inode contém o número de 
	diversos blocos de dados usados para armazenar as informações do arquivo. 
	Há espaço somente para uns poucos números de blocos de dados no inode, e,  
	caso um número maior seja necessário, mais espaço para ponteiros será 
	alocado dinamicamente. Estes blocos alocados dinamicamente são blocos de 
	indireção que, como o nome indica, contém endereços para outros blocos.


%	\meta this needs rewriting.  
	Sistemas de arquivos \unix\ normalmente permitem a criação de
	\defin{espaços vazios} em um arquivo (isso é feito com o comando 
	\cmd{lseek}), 
	o que significa que o sistema de arquivos simplesmente `simula' que 
	uma determinada parte do arquivo possui somente bytes vazios, 
	mas nenhum setor de disco é reservado (o que significa que o arquivo 
	usará um pouco menos de espaço em disco). Isso ocorre freqüentemente para
	pequenos binários, bibliotecas compartilhadas, algumas bases de dados e 
	outros casos especiais. Espaços são implementados através do
	armazenamento de valores especiais como endereços de blocos de dados no 
	bloco de indireção ou no inode. Este endereço especial significa que não 
	há blocos de dados realmente alocados para aquela parte do arquivo, ou 
	seja há um `buraco' no arquivo.


	Espaços vazios são razoavelmente úteis. No sistema
	do autor, uma medição mostrou uma economia de pelo
	menos 4~Mb de espaço em disco, de um total de 200~Mb utilizado com o 
	sistema. Veja que este sistema contém relativamente poucos programas e
	não possui bases de dados. A ferramenta de medição está
	descrita no Apêndice~\ref{chap:measure-holes}.


%%\subsection{Filesystems galore}
\subsection{Diversidade de sistema de arquivos}

	O \linux\ suporta diversos tipos de sistemas de
	arquivos. Dentre esses destacamos:

		%
	\begin{dispitems}
	\item[minix]
		O mais antigo e presumivelmente o mais confiável,
		mas bastante limitado em características (algumas datas
		não aparecem , máximo de 30 caracteres para nome de
		arquivos,etc...) e restrito em armazenamento (no
		máximo 64~Mb por sistema de arquivos).
	\item[xia]
		Uma versão modificada do sistema de arquivos minix,
		o qual aumenta os limite de nomes de arquivos e de
		sistemas de arquivos, mas não introduz novas
		facilidades. Não é muito popular, mas comenta-se
		que funcione muito bem.
	\item[ext2]
		O mais poderoso e popular sistema de arquivos
		nativo do Linux. Desenhado para ser facilmente
		compatível com os avanços das novas versões, sem a
		necessidade de criar novamente os sistemas de arquivos
		já existentes.
	\item[ext]
		Uma versão antiga do \texttt{ext2} que não é mais compatível
		comn versões atuais. É raro vê-la instalada em sistemas novos e 
		mesmo os mais antigos tem sido convertidos para \texttt{ext2}.
	\end{dispitems}
		%
	Adicionalmente há o suporte a diversos outros
	sistemas de arquivos, para simplificar a troca de
	informações com outros sistemas operacionais. Estes
	sistemas de arquivos funcionam como se fossem
	nativos, exceto pela perda de algumas facilidades
	presentes no \unix, ou apresentam algumas particularidades.

		%
	\begin{dispitems}
	\item[msdos]
		Compatibilidade com MS-DOS (e OS/2 e Windows NT)
		através de sistemas de arquivos FAT/FAT32.

	\item[umsdos]
		Sistemas de arquivos msdos estendidos para suportar
		nomes longos, donos, permissões, links e
		arquivos de dispositivos do \linux. Isso permite que
		um sistema de arquivos \texttt{msdos} possa ser usado como
		se fosse um sistema \linux, removendo a necessidade
		de uma partição distinta para o Linux.

	\item[iso9660]
		O sistema de arquivos padrão do CD-ROM. A extensão
		Rock Ridge que permite nomes longos também é
		suportada automaticamente.

	\item[nfs]
		Sistemas de arquivos em redes que permitem o
		compartilhamento e o fácil acesso aos arquivos
		entre diversos computadores da rede.

	\item[hpfs]
		O sistema de arquivos do OS/2.

	\item[sysv]
		Sistema de arquivos do System V/386, Coherent e
		Xenix.             

	\end{dispitems}
		%
	A opção do sistema de arquivos a ser usado depende
	da situação. Caso a compatibilidade ou outras razões
	tornem um dos sistemas de arquivos não nativos
	necessário, então este deve ser utilizado. Caso a
	opção seja livre, então provavelmente a decisão
	mais acertada seja usar o ext2, uma vez que ele
	traz diversas facilidades sem sofrer perda de
	performance.

	Há ainda o sistema de arquivos \texttt{proc}, normalmente
	acessível através do diretório \fn{/proc}, o qual não é
	um sistema de arquivos real, apesar de parecer um.
	O sistema de arquivos \fn{proc} torna mais simples o
	acesso a determinadas estruturas do kernel, como
	por exemplo a lista de processos. Isso torna a
	estrutura de dados parecer um sistema de arquivos
	que pode ser manipulado com as ferramentas usuais.
	Por exemplo para obter uma lista de todos os
	processos pode-se usar o comando:


		%
		\begin{tscreen}
\verb|$ | {\sl ls -l /proc} \\
\verb|total 0| \\
\verb|dr-xr-xr-x   4 root     root            0 Jan 31 20:37 1| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 63| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 94| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 95| \\
\verb|dr-xr-xr-x   4 root     users           0 Jan 31 20:37 98| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 99| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 devices| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 dma| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 filesystems| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 interrupts| \\
\verb|-r--------   1 root     root      8654848 Jan 31 20:37 kcore| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 11:50 kmsg| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 ksyms| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 11:51 loadavg| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 meminfo| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 modules| \\
\verb|dr-xr-xr-x   2 root     root            0 Jan 31 20:37 net| \\
\verb|dr-xr-xr-x   4 root     root            0 Jan 31 20:37 self| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 stat| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 uptime| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 version| \\
\verb|$ |
		\end{tscreen}
		%
	(Podem haver alguns arquivos a mais que não correspondem a processos, 
	porém o exemplo acima foi resumido por questões didáticas).

	Note que apesar de ser chamado como sistema de
	arquivos, o \texttt{proc} não acessa o disco rígido. Ele
	existe somente no kernel do sistema. Toda vez que
	alguém tente acessar alguma parte do sistema de
	arquivos \texttt{proc}, o kernel torna esta parte visível em
	algum lugar. Então mesmo que pareça existir um
	arquivo com diversos megabytes denominado
	\fn{/proc/kcore}, ele não utiliza um único byte do disco
	rígido.


%%\subsection{Which filesystem should be used?}
\subsection{Qual sistema de arquivos deve ser usado?}

	Faz pouco sentido utilizar muitos sistemas de
	arquivos diferentes. Atualmente o ext2fs é o mais
	popular , e provavelmente a decisão mais acertada.
	Dependendo da necessidade de recursos adicionais na
	manutenção das estruturas, velocidade, segurança,
	estabilidade, compatibilidade e diversas outras
	razões, pode ser desejável utilizar outro tipo de
	sistema de arquivos. Isto deve ser decidido caso a caso.


%%\subsection{Creating a filesystem}\label{sec:mkfs}
\subsection{Criando um sistema de arquivos}\label{sec:mkfs}

	Sistemas de arquivos são criados, ou melhor
	inicializados, através do comando \cmd{mkfs}. Na verdade
	há um comando específico para cada tipo de sistema
	de arquivos. O \cmd{mkfs} é somente uma interface que
	executa o programa adequado ao tipo desejado. O tipo é selecionado
	através da opção \texttt{-t}.

	Os programas acionados pelo \cmd{mkfs} podem ter uma
	interface de linha de comando ligeiramente
	diferente. As opções comuns e mais importantes
	estão resumidas a seguir (veja a página de manual
	ou consulte o Apêndice~\ref{chap:comandos}).

	%
	\begin{quote}
	\begin{description}
	\item[{\tt -t} {\it tipo\_sa}] Seleciona o tipo do sistema de arquivos
	\item[{\tt -c}] Pesquisa blocos defeituosos e inicializa a lista
					 de blocos ruins  
	\item[{\tt -l} {\it nome arquivo}] Lê a lista de blocos ruins a partir 
									do arquivo informado
	\end{description}
	\end{quote}
	%

	Para criar um sistema de arquivos do tipo ext2 em
	um disquete, basta executar o comando:

		%
		\begin{tscreen}
\verb|$| {\sl fdformat -n /dev/fd0H1440 } \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|$| {\sl badblocks /dev/fd0H1440 1440 $>$ bad-blocks} \\
\verb|$| {\sl mkfs -t ext2 -l bad-blocks /dev/fd0H1440} \\
\verb|mke2fs 1.12, 9-Jul-98 for EXT2 FS 0.5b, 95/08/09|  \\
\verb|Linux ext2 filesystem format| \\
\verb|Filesystem label=| \\
\verb|360 inodes, 1440 blocks| \\
\verb|72 blocks (5.00%) reserved for the super user|  \\
\verb|First data block=1| \\
\verb|Block size=1024 (log=0)| \\
\verb|Fragment size=1024 (log=0)| \\
\verb|1 block group| \\
\verb|8192 blocks per group, 8192 fragments per group| \\
\verb|360 inodes per group| \\
\verb||\\
\verb|Writing inode tables: done| \\
\verb|Writing superblocks and filesystem accounting information: done| \\
\verb|$| 

		\end{tscreen}
		%
	Inicialmente o disquete foi formatado (a opção \texttt{-n}
	inibe a checagem de blocos defeituosos). Após o
	comando \cmd{badblocks} faz a checagem e redireciona as
	mensagens de saída para o arquivo \defin{bad\_blocks}.
	Finalmente o sistema de arquivos é criado, com a
	lista de blocos defeituosos inicializada com o que
	quer que o comando \cmd{badblocks} tenha encontrado.


	A opção {\tt -c} poderia ter sido utilizada em conjunto com o
	comando \cmd{mkfs}, ao invés do \cmd{badblocks} e de um
	arquivo em separado, conforme o exemplo a seguir:

		%
		\begin{tscreen}
\verb|$| {\sl mkfs -t ext2 -c /dev/fd0H1440} \\
\verb|mke2fs 1.12, 9-Jul-98 for EXT2 FS 0.5b, 95/08/09| \\
\verb|Linux ext2 filesystem format| \\
\verb|Filesystem label=| \\
\verb|360 inodes, 1440 blocks| \\
\verb|72 blocks (5.00%) reserved for the super user| \\
\verb|First data block=1| \\
\verb|Block size=1024 (log=0)| \\
\verb|Fragment size=1024 (log=0)| \\
\verb|1 block group| \\
\verb|8192 blocks per group, 8192 fragments per group| \\
\verb|360 inodes per group| \\
\verb|| \\
\verb|Checking for bad blocks (read-only test): done| \\
\verb|Writing inode tables: done| \\
\verb|Writing superblocks and filesystem accounting information: done| \\
\verb|$ |
		\end{tscreen}
		%
	A opção {\tt -c} é mais conveniente que o uso do comando
	\cmd{badblocks} em separado, porém este último é
	necessário para uma verificação mais precisa, após
	a criação do sistema de arquivos.

	O processo de preparar sistemas de arquivos em discos rígidos ou 
	partições é o mesmo para disquetes, exceto pelo fato da formatação não ser
	necessária.


%%\subsection{Mounting and unmounting}\label{subsec:mount}
\subsection{Montando e desmontando}\label{subsec:mount}

	Antes de um sistema de arquivos poder ser utilizado, ele necessita 
	ser \defin{montado}. O sistema operacional executa diversas verificações 
	para estar seguro de que tudo está funcionando bem. Uma
	vez que todos os arquivos no \unix\ estão em uma única
	árvore de diretórios, a operação de montagem fará
	com que o novo sistema de arquivos pareça um
	subdiretório existente em algum sistema de arquivos
	já montado.

	Por exemplo, a figura~\ref{fig:hd-mount-root} mostra três diferentes
	sistemas de arquivos, cada qual com o seus próprio
	diretório raiz. Quando os dois últimos são montados
	sob o \fn{/home} e \fn{/usr}, respectivamente, no primeiro
	sistema de arquivos, temos somente uma única árvore
	de diretórios e suas entradas, conforme a figura~\ref{fig:hd-mount-all}.

		\begin{figure}[thb]
		\begin{center}
%%		\includegraphics{disks/hd-mount-separate.ps}
		\end{center}
		\caption{Três sistemas de arquivos distintos.}
		\label{fig:hd-mount-root}
		\end{figure}

		\begin{figure}[thb]
		\begin{center}
%%		\includegraphics{disks/hd-mount-mounted.ps}
		\end{center}
		\caption{\fn{/home} e \fn{/usr} foram montados.}
		\label{fig:hd-mount-all}
		\end{figure}

	As montagens podem ser executadas, por exemplo, da
	seguinte forma:

		%
		\begin{tscreen}
\verb|$ | {\sl mount /dev/hda2 /home} \\
\verb|$ | {\sl mount /dev/hda3 /usr} \\
\verb|$ |
		\end{tscreen}
		%
	O \cmd{mount} tem dois argumentos. O primeiro é o
	arquivo de dispositivo correspondente ao disco ou
	partição que contenha o sistema de arquivos. O
	segundo é o diretório sob o qual ele será montado.
	Após este comando o conteúdo dos dois sistemas de
	arquivos parecerão simplesmente dois diretórios:
	\fn{/home} e \fn{/usr} respectivamente. Pode-se então dizer
	que ``\fn{/dev/hda2} \defin{está montado no} \fn{/home}'' e similarmente
	para o  \fn{/usr}. Para examinar estes sistemas de arquivos, pode-se 
	acessar estes diretórios exatamente da mesma forma que qualquer
	outro. É importante ressaltar a diferença entre o dispositivo
	\fn{/dev/hda2} e o diretório montado \fn{/home}.
	Enquanto o primeiro dá acesso ao dados brutos do
	disco, o segundo permite o acesso aos arquivos
	contidos no mesmo disco. O diretório montado é
	chamado \defin{ponto de montagem}.


	O Linux suporta diversos tipos de sistemas de
	arquivos. O \cmd{mount} tenta verificar qual o tipo de
	sistema de arquivos está sendo montado. Pode-se
	utilizar opcionalmente a opção {\tt -t \sl tipo}
	para especificar o tipo diretamente. Isso pode ser útil quando
	a verificação automática não funcione corretamente.
	Por exemplo para montar um disquete MS-DOS, pode-se
	usar o seguinte comando:



		%
		\begin{tscreen}
\verb|$ | {\sl mount -t msdos /dev/fd0 /floppy} \\
\verb|$ |
		\end{tscreen}
		%
	O diretório montado não necessita estar vazio, na
	verdade ele somente deve existir. Apesar disso, todos os arquivos
	abaixo deste diretório estarão inacessíveis enquanto o sistema
	de arquivos é montado (qualquer arquivo que já
	tenha sido aberto estará disponível. Arquivos que
	contém links com outros diretórios
	também podem ser acessados através daqueles nomes).
	Nenhum dano será causado ao sistema de arquivos e
	isso pode, por vezes, ser bastante útil. Por
	exemplo caso se deseje ter o \fn{/tmp} e \fn{/var/tmp} como
	sinônimos, faz-se uma ligação simbólica do \fn{/var/tmp}
	para \fn{/tmp}. Quando o sistema é inicializado, antes
	que o sistema de arquivos \fn{/usr} seja montado, o
	diretório /var/tmp residente no diretório raiz é
	usado em seu lugar. Quando o \fn{/usr} é montado, ele
	tornará o diretório \fn{/var/tmp} no raiz indisponível.
	Caso este diretório não existisse no raiz seria
	impossível usar arquivos temporários antes de
	montar o \fn{/var}.


	Caso não se pretenda gravar absolutamente nada no
	sistema de arquivos,pode-se usar o parâmetro {\tt -r}
	para montar o sistema de arquivos permitindo
	somente operações de leitura. Isso fará com que o
	kernel do sistema bloqueie qualquer tentativa de
	gravação naquele sistema de arquivos. Montagens de
	leitura somente são necessárias para mídias não
	graváveis como por exemplo CD-ROMs.

	O leitor mais atento perceberá um pequeno problema logístico. Como o 
	primeiro sistema de arquivos (chamado \defin{raiz}, por conter o diretório 
	raiz (/)) é montado, uma vez que obviamente ele não pode ser
	montado a partir de outros sistemas de arquivos?  Isso é feito de 
	maneira automática.\footnote{Para mais informações, veja os fontes do 
	kernel ou o Kernel Hackers'Guide} 
	O sistema de arquivos raiz é montado automaticamente durante a 
	inicialização do sistema operacional e pode-se estar certo de 
	que ele sempre estará disponível, pois de outra forma o sistema não 
	poderá ser inicializado. O nome do sistema de arquivos que é montado 
	como / é compilado junto com o kernel do sistema, configurado no 
	LILO ou através do comando \cmd{rdev}.

	O sistema de arquivos raiz normalmente é montado
	com permissões somente de leitura. Os scripts de
	inicialização executarão o comando \cmd{fsck} para
	verificar sua integridade e se por ventura há algum
	problema. Caso tudo corra bem, ele será montado
	novamente, agora com permissões de gravação. O
	programa \cmd{fsck} não deve ser executado em sistemas de
	arquivos montados, pois quaisquer alterações no
	sistema durante a sua execução {\em causará}
	problemas. Uma vez que o sistema de arquivos raiz é
	montado inicialmente no modo somente de leitura, o \cmd{fsck}
	pode ser executado e regularizar qualquer
	anormalidade encontrada, pois, após a
	remontagem com permissões de gravação, os eventuais
	ajustes serão efetuados automaticamente.


%%  ??? 
%%	by each administrator if need be.  When the chapter on booting
%%	is finished, you may read all about it there.

	Em muitos sistemas, há outros sistemas de arquivos
	que devem ser montados automaticamente durante a
	sua inicialização. Estes sistemas de arquivos estão
	especificados no arquivo \fn{/etc/fstab} (veja a
	página de manual do \man{fstab} ou Apêndice~\ref{chap:comandos})
	Os detalhes exatos de como cada sistema de arquivos será montado 
	depende de muitos fatores e pode ser efetuado de acordo com a
	necessidade de cada administrador.

	Quando um sistema de arquivos não necessita mais
	estar montado, ele pode ser desmontado através do
	comando \cmd{umount}\footnote{O comando deveria ser \cmd{unmount}, mas o 
	{\tt n} desapareceu misteriosamente na década de 70 e não foi encontrado
	desde então. Por favor, devolva-o para a Bell Labs, NJ, se encontrá-lo.}. 
	Este comando necessita um argumento: ou o arquivo de dispositivo ou o
	ponto de montagem. Por exemplo para desmontar os
	diretórios do exemplo anterior deve-se executar:

		%
		\begin{tscreen}
\verb|$ | {\sl umount /dev/hda2 } \\
\verb|$ | {\sl umount /usr} \\
\verb|$ |
		\end{tscreen}
		%
	Para maiores informações sobre este comando,
	leia a página de manual. É fundamental que um disquete sempre seja 
	desmontado.
	{\em Não se deve simplesmente retirar o disquete da
	unidade}! Dados podem estar em memória e ainda
	não terem sido gravados. Isso ocorre após o sistema
	executar um \cmd{sync}\footnote{o \cmd{umount} encarrega-se de executá-lo}
	Retirá-lo antes pode danificar o conteúdo do disquete. Caso se esteja
	somente lendo do disquete, pode não ser tão
	crítico, mas caso se esteja gravando algum conteúdo
	o resultado pode ser catastrófico.

	Montar e desmontar sistemas de arquivos requer
	privilégios de superusuário, isto é, somente o
	usuário \fn{root} pode fazê-lo. A razão para isso é que
	se qualquer usuário pudesse montar um disquete como
	um sistema de arquivos, seria fácil criar um Cavalo de Tróia disfarçado
	como \fn{/bin/sh}, ou outro programa qualquer. Ocasionalmente os usuários
	precisam utilizar disquetes. Seguem algumas formas de resolver isto:

		%
	\begin{itemize}
	\item 
		Dar aos usuários a senha do \fn{superusuário}. Esta é
		obviamente a pior solução, mas é a mais simples.
		Deve funcionar bem caso não haja outras
		necessidades de segurança no equipamento, no
		caso de máquinas fora da rede ou sistemas de uso
		pessoal.
	\item 
		Usar um programa como o \cmd{sudo} que permite aos
		usuários utilizar o comando \cmd{mount}. Ainda não é
		uma solução segura, mas não dá privilégios diretos de
		superusuário a todos os usuários\footnote{São necessários
		diversos segundos até que o usuário ache um jeito de burlar a 
		segurança do sistema}.   
	\item 
		Indicar o uso das ferramentas \cmd{mtools}, um pacote
		de manipulação de sistemas de arquivos DOS, sem
		ter que montá-los. Isso funciona bem  para
		arquivos MS-DOS, mas ainda não é a solução
		ideal.  
	\item 
		Listar as unidades de disco flexível e os pontos de
		montagem permitidos no arquivo \fn{/etc/fstab}, juntamente com
		as opções corretas. 
	\end{itemize}
		%
	Esta última alternativa pode ser implementada adicionando-se uma linha
	similar à seguinte no \fn{/etc/fstab}:  
		%
		\begin{tscreen}
/dev/fd0            /floppy      msdos   user,noauto      0     0
		\end{tscreen}
		%
	As colunas são: dispositivo a ser montado, diretório de 
	montagem, tipo do sistema de arquivos, opções, frequência da realização de
	cópias de segurança (usado pelo \cmd{dump}), e número de passagem do 
	\cmd{fsck} (especifica a ordem em que o sistema de arquivos deve ser 
	verificados após a inicialização. 0 significa sem checagem).

	A opção \texttt{noauto} inibe a montagem automática na
	inicialização do sistema (ou seja inibe a ação do
	comando \cmd{mount -a} no arquivo fstab). A opção \texttt{user}
	permite que qualquer usuário possa montar o sistema
	de arquivos e, por razões de segurança, desabilita
	a execução de programas (em modo normal ou através
	de setuid) e a interpretação de dispositivos a partir do sistema de arquivos
	montado. Após isso, qualquer usuário pode montar um disquete com um
	sistema de arquivos DOS utilizando o comando:

		%
		\begin{tscreen}
\verb|$ | {\sl mount /floppy} \\
\verb|$ |
		\end{tscreen}
		%
	O disquete pode (e deve) ser desmontado com o comando 
	\cmd{umount}.

	Caso queira ter acesso a diferentes tipos de disquetes, é necessário
	ter diversos pontos de montagem. Os parâmetros podem ser diferentes para
	cada um. Para dar acesso a disquetes DOS e ext2, pode-se 
	configurar o \fn{/etc/fstab} da seguinte maneira:

		%
		\begin{quote}
		\small
		\begin{verbatim}
/dev/fd0    /dosfloppy    msdos   user,noauto  0  0
/dev/fd0    /ext2floppy   ext2    user,noauto  0  0
		\end{verbatim}
		\end{quote}
		%
	Para sistemas de arquivos DOS (não somente disquetes), provavelmente 
	queira-se restringir o acesso usando opções de sistemas de arquivos como
	\texttt{uid}, \texttt{gid} e \cmd{umask} descritos na página de manual 
	do comando \cmd{mount}. Caso estas precauções não sejam tomadas,
	qualquer usuário poderá no mínimo ler todos os arquivos DOS daquele 
	sistema de arquivos, o que não parece ser uma boa idéia.

	
%%\subsection{Checking filesystem integrity with \cmd{fsck}}
\subsection{Verificando a integridade de um sistema de arquivos com \cmd{fsck}}

	Sistemas de arquivos são criaturas complexas, e tendem, com o tempo ou
	o mau uso, a ter erros. A validação e correção de erros de um sistema 
	de arquivos podem ser realizadas através do comando \cmd{fsck}. Ele pode ser
	configurado para resolver alguns tipos de problemas que encontre e para 
	alertar o usuário sobre erros incorrigíveis. Felizmente os programas que
	implementam os sistemas de arquivos são muito testados e é raro 
	ter-se problemas desta natureza. Os erros comuns são ocorrências causadas 
	por falhas de energia, falhas de hardware ou erros de operação.

	Muitos sistemas estão configurados para executar o \cmd{fsck} 
	automaticamente no momento de sua inicialização, assim vários erros podem 
	ser encontrados e corrigidos desta forma, antes da utilização do sistema. 
	O uso de sistemas de arquivos corrompidos tende a piorar o problema: se
	as estruturas de dados contém erros, utilizar o sistema de arquivos pode 
	provocar uma perda ainda maior. O \cmd{fsck} pode demorar ao executar
	em grandes sistemas de arquivos e pelo fato de que problemas raramente 
	ocorrem quando se desliga a máquina apropriadamente, alguns truques são 
	usadas para evitar a checagem nestes casos. O primeiro é baseado na 
	existência do arquivo \fn{/fastboot}; caso ele exista, nenhuma 
	checagem é realizada. O segundo consiste em utilizar o \cmd{e2fsck} 
	(a versão do \cmd{fsck} para sistemas de arquivos do tipo ext2). 
	Os sistemas de arquivos ext2 têm uma marca especial no superbloco, a qual 
	informa se o sistema foi desligado de maneira apropriada. Caso positivo, 
	o programa não checará todo o sistema de arquivos. O uso do \fn{/fastboot}
	depende dos scripts de inicialização do sistema. O \cmd{e2fsck} não irá 
	validar o sistema de arquivos, desde que o sistema tenha sido desligado 
	corretamente. Para forçar sua validação, utilize a opção {\tt -f} do
	\cmd{e2fsck}. Veja a página de manual do \cmd{e2fsck} ou o 
	Apêndice~\ref{chap:comandos}.

	A checagem automática funciona somente para os sistemas de arquivos que 
	são montados automaticamente na inicialização do sistema. Para os demais, 
	o programa \cmd{fsck} deve ser executado manualmente.


	Caso o \cmd{fsck} encontre problemas irreparáveis, será
	necessário um conhecimento profundo de como os
	sistemas de arquivos funcionam e em especial do
	tipo de sistema corrompido. Outra alternativa muito saudável é ter 
	cópias de segurança do sistema! A segunda opção é mais simples de ser
	posta em prática, já a primeira pode depender de
	pesquisas em grupos de notícias, listas de
	discussão e serviços de suporte, caso você não tenha o conhecimento 
	necessário. Eu gostaria de falar mais a você sobre este assunto, mas meus
	conhecimentos neste tópico não são muito profundos. O programa \cmd{debugfs}
	de Theodore T'so pode ajudar nesta tarefa.

	O \cmd{fsck} deve ser executado somente em sistemas de arquivos 
	desmontados e nunca naqueles que já estejam montados (exceto o sistema 
	de arquivos raiz, montado com permissões somente de leitura,
	durante a inicialização do sistema). Isso deve-se ao fato do \cmd{fsck} 
	acessar diretamente os dados do sistema, podendo inclusive modificá-los 
	sem que o sistema operacional perceba. Você terá sérios problemas, caso
	o sistema operacional fique confuso.


%%\subsection{Checking for disk errors with \cmd{badblocks}}
\subsection{Checando erros de disco com \cmd{badblocks}}

	É aconselhável checar periodicamente o disco rígido. Isto poder ser feito 
	através da execução do comando \cmd{badblocks}. Ele gera uma lista com os
	números dos blocos defeituosos encontrados. Esta lista pode servir de 
	entrada para o comando \cmd{fsck}.  O \cmd{fsck} grava nas estruturas de 
	dados do sistema de arquivos os blocos que tenham problemas, assim, o 
	sistema não utilizará estas áreas para armazenar dados. O seguinte exemplo 
	mostra como isso pode ser feito:
		%
		\begin{tscreen}
\verb|$| {\sl badblocks /dev/fd0H1440 1440 $>$ bad-blocks } \\
\verb|$| {\sl fsck -t ext2 -l bad-blocks /dev/fd0H1440} \\
\verb|Parallelizing fsck version 1.12 (9-Jul-98)| \\
\verb|e2fsck 1.12, 9-Jul-98 para o sistema de arquivos EXT2 0.5b, 95/08/09| \\
\verb|Pass 1: Checking inodes, blocos, and sizes| \\
\verb|Pass 2: Checking diretório structure| \\
\verb|Pass 3: Checking diretório connectivity| \\
\verb|Pass 4: Checking reference counts| \\
\verb|Pass 5: Checking group summary information| \\
\verb|| \\
\verb|/dev/fd0H1440: ***** SISTEMA DE ARQUIVOS FOI MODIFICADO *****| \\
\verb|/dev/fd0H1440: 11/360 arquivos (0.0% não-contíguos), 63/1440 blocos| \\
\verb|$ |
		\end{tscreen}
		%
	Caso o \cmd{badblocks} ache um bloco defeituoso que já foi utilizado
	pelo sistema, o \cmd{e2fsck} tentará mover o bloco para outro local. Caso
	o problema seja realmente grave  e não somente um erro superficial, o 
	arquivo poderá estar definitivamente corrompido.


%%\subsection{Fighting fragmentation}
\subsection{Evitando fragmentação}

	Quando um arquivo é gravado em disco, ele nem
	sempre pode ser gravado em blocos consecutivos. Um
	arquivo que não esteja armazenado em blocos
	consecutivos estará \defin{fragmentado}. O tempo de leitura é maior
	para arquivos fragmentados, uma vez que as cabeças do disco rígido terão 
	que se movimentar mais. É desejável evitar a fragmentação, apesar de não 
	ser exatamente um problema quando se utiliza um bom buffer de dados de 
	leitura do tipo read-ahead.

	Os sistemas de arquivos ext2 tentam manter a
	fragmentação no mínimo, mantendo todos os blocos de
	um arquivo juntos, mesmo que eles não possam ser
	armazenados em setores consecutivos. O  ext2
	sempre aloca o bloco livre mais próximo dos demais blocos do arquivo. 
	É raro o ext2 preocupar-se com fragmentação. Há um programa para 
	desfragmentação de sistemas de arquivo do tipo ext2. 
	Veja~\cite{ext2-defrag} na bibliografia.
	%% ??? verificar a url da bibliografia

	Para sistemas DOS há diversos programas de desfragmentação que movem os 
	blocos dentro do sistema de arquivos, diminuindo o nível de fragmentação. 
	Para outros sistemas de arquivos, a desfragmentação pode ser realizada 
	através da realização de cópias de segurança do sistema de arquivos, 
	recriação do sistema e restauração dos arquivos. Realizar uma cópia de 
	segurança do sistema de arquivos antes de desfragmentá-lo é uma boa medida,
	uma vez que muitas coisas podem ocorrer durante esse processo.


%%\subsection{Other tools for all filesystems}
\subsection{Outras ferramentas para todos os sistemas de arquivos}

	Algumas ferramentas são ainda muito úteis no
	gerenciamento de sistemas de arquivos.  O comando
	\cmd{df} apresenta o espaço livre em disco para um ou
	mais sistemas de arquivos. O comando \cmd{du}  mostra o espaço
	ocupado por um diretório e todos os seus arquivos,
	e pode ser usado para encontrar os grandes usuários
	de espaço em disco.


	O \cmd{sync} força a gravação de todos os blocos ainda não gravados e que 
	estejam em memória (cache, veja a seção~\ref{sec:buffer-cache}).
	É raro executá-lo manualmente, pois o servidor \cmd{update} faz isso 
	automaticamente. O \cmd{sync} pode ser útil em catástrofes, no caso do 
	\cmd{update} ou o \cmd{bdflush} morrerem, ou quando é preciso encerrar 
	o sistema rapidamente.

%%\subsection{Other tools for the ext2 filesystem}
\subsection{ Outras ferramentas para sistemas de arquivos ext2}

	Em adição à ferramente usada para a criação de sistemas de arquivos
	\cmd{mke2fs} e ao verificador \cmd{e2fsck} acessados
	diretamente ou através de uma interface, o sistema
	de arquivos ext2 tem algumas ferramentas que podem
	ser de grande utilidade.


	O \cmd{tune2fs} ajusta os parâmetros do sistema de
	arquivos. Alguns parâmetros interessantes são:

		%
	\begin{itemize}
	\item 
		Um contador do número de vezes que o sistema de
		arquivos foi montado. O \cmd{e2fsck} força uma checagem
		toda vez que o sistema seja montado n vezes,
		mesmo que o indicador de normalidade esteja
		assinalado. Para um sistema que é usado em
		desenvolvimento ou testes, pode ser uma boa idéia reduzir
		este número.       

	\item 
		Tempo máximo entre as checagens. O \cmd{e2fsck} pode ainda forçar
		o tempo máximo entre checagens, mesmo que o indicador
		de normalidade esteja assinalado e o sistema de arquivos não seja
		montado frequentemente. Esta opção pode ser desabilitada, a critério do
		administrador.   

	\item 
		 Número de blocos reservado para o \texttt{superusuário}. O ext2
		 reserva alguns blocos para o \texttt{root}, pois, mesmo que o 
		 sistema de arquivos esteja cheio, o root ainda pode administrar
		 o filesystems sem apagar nenhum dado. O espaço reservado padrão é
		 de 5\%, o qual na maioria dos discos, não representa perda 
		 considerável de dados. Note que disquetes não necessitam de 
		 blocos reservados.

	\end{itemize}
		%
	Veja a página de manual do \man{tune2fs}.

	O comando \cmd{dumpe2fs} apresenta algumas informações sobre um
	sistema de arquivos ext2, a maioria extraída a
	partir do superbloco. A figura~\ref{fig:dumpe2fs-output} apresenta 
	um exemplo. Algumas informações são extremamente técnicas e exigem um 
	certo conhecimento de como o sistema de arquivos
	funciona, mas muitas das informações são do alcance da maioria dos 
	administradores.     

\begin{figure}[t]
\begin{center}
\small
\begin{verbatim}
dumpe2fs 1.12, 9-Jul-98 for EXT2 FS 0.5b, 95/08/09  
Filesystem volume name:   <none>
Last mounted on:          <not available>
Filesystem UUID:          ce3ad49a-1ce7-11d2-8afa-000021a28984
Filesystem magic number:  0xEF53
Filesystem revision #:    0 (original)
Filesystem features:      (none)
Filesystem state:         not clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              78312
Block count:              313236
Reserved block count:     15661
Free blocks:              85681
Free inodes:              78270
First block:              1
Block size:               1024
Fragment size:            1024
Blocks per group:         8192
Fragments per group:      8192
Inodes per group:         2008
Inode blocks per group:   251
Last mount time:          Sun Sep 27 11:26:23 1998
Last write time:          Tue Sep 29 00:11:23 1998
Mount count:              1
Maximum mount count:      20
Last checked:             Sun Sep 27 11:25:52 1998
Check interval:           15552000 (6 months)
Next check after:         Fri Mar 26 11:25:52 1999
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)


Group 0: (Blocks 1 -- 8192)
  Block bitmap at 4 (+3), Inode bitmap at 5 (+4)
  Inode table at 6 (+5)
  7923 free blocks, 1997 free inodes, 2 directories
  Free blocks: 270-8192
  Free inodes: 12-2008
\end{verbatim}
\end{center}
\caption{Exemplo da saída do programa \cmd{dumpe2fs}}
\label{fig:dumpe2fs-output}
\end{figure}

	O \cmd{debugfs} é um programa destinado à validação de um
	sistema de arquivos. Ele permite o acesso direto às
	estruturas  de dados armazenadas em disco e pode
	ser usado para reparar problemas em discos, que
	talvez nem mesmo o \cmd{fsck} possa corrigir
	automaticamente. Também é conhecido por seu uso na recuperação de
	arquivos apagados. O \cmd{debugfs} exige um alto nível de
	conhecimento das tarefas que estão sendo
	executadas; uma falha no entendimento pode destruir
	todos os dados do seu disco!

	Os comandos \cmd{dump} e \cmd{restore} podem ser
	usados para geração de cópias de segurança de um
	sistema de arquivos ext2. Eles são versões
	específicas para o ext2 de tradicionais ferramentas
	do \unix. Veja o capítulo~\ref{chap:backups} para maiores informações
	sobre cópias de segurança.    

%%\section{Disks without filesystems}
\section{Discos sem sistemas de arquivos}

	Nem todos os discos ou partições são usadas como
	sistemas de arquivos. Uma partição swap,
	por exemplo, não conterá um sistema de arquivos.
	Muitos disquetes são usados como uma emulação de um
	dispositivo de fita, podendo o comando \cmd{tar} ou outro qualquer
	gravar os dados diretamente no disco, sem um sistema de arquivos. Os
	disquetes de inicialização do Linux não contém um sistema de arquivos, 
	somente a imagem do kernel do sistema.                   

	A não utilização de um sistema de arquivos libera um maior espaço do 
	disco para outras tarefas, uma vez que o sistema de arquivos
	utiliza estruturas internas para garantir a integridade dos dados.
	Isso também torna o disco mais compatível com
	outros sistemas: por exemplo o formato de arquivos gerado pelo
	\cmd{tar} é o mesmo em todos os sistemas, enquanto que os
	sistemas de arquivos são diferentes na maioria. Um
	administrador rapidamente acostuma-se ao uso de
	discos sem sistemas de arquivos, caso necessário.
	Disquetes inicializáveis do Linux também não têm
	sistemas de arquivos, apesar de ser possível. 

	Uma razão para usar discos de forma direta é a de
	fazer imagens deles. Por exemplo, se um disco tem
	parte do sistema de arquivos danificada, é uma boa
	idéia fazer-se uma cópia antes de tentar consertá-lo, 
	podendo o trabalho ser reiniciado caso as
	tentativas tenham danificado os dados restantes.
	Uma forma de fazer-se isso é através do comando \cmd{dd}:       

		%
		\begin{tscreen}
\verb|$| {\sl dd if=/dev/fd0H1440 of=floppy-image} \\
\verb|2880+0 records in| \\
\verb|2880+0 records out| \\
\verb|$| {\sl dd if=floppy-image of=/dev/fd0H1440 } \\
\verb|2880+0 records in| \\
\verb|2880+0 records out| \\
\verb|$|
		\end{tscreen}
		%
	O primeiro \cmd{dd} gera uma imagem exata do disquete
	para o arquivo \fn{floppy-image}, o segundo grava a
	imagem para o disquete. (o usuário presumivelmente
	substituiu o disquete antes do segundo comando. De
	outra forma o procedimento torna-se inútil).                          

%%\section{Allocating disk space}
\section{Alocando espaço em disco}

%%\subsection{Partitioning schemes}
\subsection{Esquemas de particionamento}

	Não é fácil particionar um disco da melhor maneira possível. Pior, não há
	uma forma `certa' de fazê-lo, devido ao número de fatores envolvidos. 

	O modo tradicional sugere um pequeno sistema de arquivos raiz,
	que contém os diretórios \fn{/bin}, \fn{/etc}, \fn{/dev}, \fn{/lib}, 
	\fn{/tmp} e outros necessários para o sistema ser inicializado e para 
	que ele permaneça ativo. Desta forma o sistema de arquivos raiz 
	(na sua própria partição ou no seu próprio disco) contém todo o necessário 
	para manter o sistema ativo. A razão para isso é que se o sistema de 
	arquivos raiz é pequeno e pouco usado, a chance dele ter problemas é muito
	pequena e caso aconteçam problemas com o sistema de arquivos, eles são 
	sanados mais rapidamente. Após, criam-se partições separadas para a árvore 
	de 
	diretórios sob o \fn{/usr}, para os diretórios pessoais (normalmente sob 
	o \fn{/home}) e para a área de swap. Separando-se a área de diretórios 
	pessoais em sua própria partição torna as cópias de segurança mais simples, 
	uma vez que não é necessário copiar os programas (que estão normalmente no
	\fn{/usr}). Em um ambiente de rede é possível ainda compartilhar o 
	\fn{/usr} entre diversas máquinas (usando NFS por exemplo), reduzindo-se 
	assim o espaço total de disco requerido entre todas as máquinas, gerando 
	economia de dezenas ou centenas de megabytes, dependendo do número de 
	máquinas.

	O problema de ter-se muitas partições é que elas dividem o espaço livre 
	total do disco em partes menores.
	Hoje, que discos e sistemas operacionais são mais confiáveis, muitos 
	preferem ter somente uma partição com todos os arquivos. Por outro lado,
	é mais fácil fazer cópias de segurança (e restaurações) de partições 
	pequenas.

	
%	\meta more reasons for many partitions: users/temp files/spools
%	can't fill up all disks, readonly partitions less likely to corrupt, 
%	fsck is faster, limits losses a filesystem goes really wrong,
%	logging must not be disturbed, boots from >1023 cylinders do not
%	work on all BIOS's, /usr/local won't be disturbed by an upgrade,
%	easy to divide backup on many tapes, spare (scratch) partition for
%	experimentation (e.g., a new Linux distribution), scratch can
%	also be used to backup root during upgrades

	Para um disco pequeno (assumindo que você não usa os fontes do kernel), 
	a melhor solução é provavelmente ter somente uma partição.
	Para discos grandes, é preferível ter-se poucas partições grandes, para 
	os casos em que algo de anormal ocorra. Note que `pequenas' ou `grandes' 
	são usadas aqui em um sentido relativo, já que dependem das necessidades 
	e dos equipamentos disponíveis.  

	Caso haja vários discos disponíveis é aconselhável ter-se o sistema de
	arquivos raiz (inclusive o \fn{/usr}) em um disco e os diretórios pessoais 
	em outro.     

	É interessante ainda estar preparado para experimentar diferentes tipos
	de particionamento. Pode ser bastante trabalhoso instalar um sistema desde
	seu início diversas vezes, mas desta maneira você acabará sabendo que está
	fazendo a coisa certa.

%%\subsection{Space requirements}
\subsection{Requisitos de espaço}

	A distribuição Linux que você instalar trará algumas indicações do espaço
	necessário para sua instalação. Programas instalados em separado
	provavelmente façam a mesma coisa. Isso ajudará no planejamento da
	utilização do espaço em disco, porém deve-se estar preparado para o
	futuro, reservando-se algum espaço extra para as demandas que
	surgirão.        

	A quantidade de espaço necessária para os usuários depende das
	tarefas que eles executarão. Algumas pessoas fazem somente edição de
	textos e necessitam de alguns megabytes, outros podem fazer processamento
	de imagens e utilizarem gigabytes.    

	Por oportuno ao comparar tamanhos de arquivos em kilobytes e megabytes e 
	espaço em disco dado em megabytes, é importante saber que estas 
	unidades podem ser diferentes. Alguns fabricantes de discos deixam a 
	entender que um kilobyte é igual a 1.000 bytes e um megabyte igual a 
	1.000 kilobytes, enquanto o resto do mundo usa 1.024 em ambos os fatores. 
	Em assim sendo um disco de aparentemente 345~Mb, tem na verdade 330~Mb 
	disponíveis.            

	A alocação de espaço em disco para a área de swap (troca) é discutida na
	seção~\ref{sec:swap-alloc}.

%%\subsection{Examples of hard disk allocation}
\subsection{Exemplos de alocação de espaço em disco}

	Eu estou acostumado a um disco rígido de 109~Mb, porém tenho agora um
	disco de 330~Mb, e apresentarei como este disco está particionado
	\footnote{atualmente os discos rígidos são muito maiores, mas as 
	{\em proporções} entre os espaços permanecem as mesmas}.


	Particionei o disco de 109~Mb de diversas formas à medida que minhas
	necessidades e o sistema operacional que eu usava foram mudando. 
	Apresentarei dois cenários básicos. Primeiro, executando o MS-DOS em 
	conjunto com o \linux. Para isso precisei de  20~Mb para conter, no mínimo,
	o MS-DOS, um compilador C, um editor, alguns utilitários, um programa em 
	desenvolvimento, e algum espaço em disco livre para não me sentir 
	claustrofóbico. Para o \linux\ foi reservado um espaço de 10~Mb para a área
	de troca e os 79~Mb restantes, foram alocados em uma única partição com
	todos os arquivos do \linux. Foi experimentado o particionamento em raiz,
	\fn{/usr} e \fn{/home}, mas como havia pouco espaço disponível em disco, 
	uma única partição tornou-se a opção mais interessante.   


	Quando o DOS não era mais necessário, o disco foi reparticionado, e foi 
	criada uma área de {\em swap} de 12~Mb, e novamente o espaço restante foi 
	alocado em uma única partição.


	O disco de 330~Mb foi particionado em diversas partições:
		%
		\begin{quote}
		\begin{tabular}{r l}
	  	  5 MB & sistema de arquivos raiz \\
	 	 10 MB & partição de swap \\
		180 MB & sistema de arquivos \fn{/usr} \\
		120 MB & sistema de arquivos \fn{/home} \\
	 	 15 MB & partição de testes
		\end{tabular}
		\end{quote}
		%
	A partição de testes está designada para atividades que requerem uma
	partição própria, como por exemplo, testar diferentes distribuições do 
	\linux\ ou comparar a velocidade de diferentes sistemas de arquivos. 
	Quando não preciso de nada especial, ela é utilizada como {\em swap}
	(eu gosto de ter {\em muitas} janelas abertas).           

%%\subsection{Adding more disk space for Linux}
\subsection{Adicionando mais espaço em disco ao Linux}

	Adicionar mais espaço ao \linux\ é simples, ao menos após o hardware ter
	sido adequadamente instalado (a instalação do hardware esta além do
	escopo deste livro). Basta formatar, criar as partições e os sistemas de
	arquivos conforme descrito anteriormente, e adicionar as linhas
	adequadas ao \fn{/etc/fstab} para a montagem automática dos novos sistemas
	de arquivos.

%%\subsection{Tips for saving disk space}
\subsection{Dicas para economizar espaço}

	A melhor dica para economizar espaço em disco é
	evitar a instalação de programas desnecessários.
	Muitas distribuições do \linux\ tem opções de instalação
	parcial do sistema. Verifique os pacotes disponíveis, e analise as suas
	necessidades. Você irá perceber que não necessita de muitos
	deles (talvez a maioria). Isso ajudará a salvar
	muito espaço em disco, já que muitos programas são
	grandes. Mesmo que você necessite de um
	determinado programa, talvez somente alguns
	componentes já sejam suficientes. Por exemplo,
	alguma documentação on-line pode ser desnecessária,
	assim como alguns dos arquivos Elisp para o GNU Emacs, alguns fontes do 
	X11, ou bibliotecas de programação.          

	Caso não seja possível desinstalar algum pacote,
	você pode pensar em compacta-los. Programas de
	compactação como \cmd{gzip} ou \cmd{zip} irão compactar (e
	descompactar) arquivos em grupo ou individuais. O programa
	\cmd{gzexe} irá compactar e descompactar
	programas automaticamente para o usuário (programas
	sem uso são compactados, e descompactados quando
	utilizados). O programa experimental \cmd{DouBle} irá
	compactar todos os arquivos do sistema de arquivos,
	automaticamente e de forma transparente para os
	usuários e programas que os utilizem (princípio
	similar ao  produto Stacker para MS-DOS, por
	exemplo).  
