%--------------------------------------------------------------------
\chapter{Visão Geral de um Sistema Linux}
%\label{chap:overview}
\label{chap:Visão Geral de um Sistema Linux}
%--------------------------------------------------------------------

        \begin{chapterquote}
	Deus olhou para tudo o que fez,\\ 
	e viu que estava muito bom.\\
	Genesis 1:31 \\
        \end{chapterquote}

	\noindent
	Este capítulo apresenta uma visão geral do Linux.
	Primeiro, os principais serviços disponibilizados pelo 
	sistema operacional são descritos. Na seqüência, os programas
	que implementam estes serviços são descritos porém sem um detalhamento
	muito profundo. O propósito deste capítulo é visualizar o sistema
	como um todo, pois cada parte será descrita em detalhes mais adiante.


\section{Diversas partes de um sistema operacional}

	Um sistema operacional UNIX consiste de um \defin{núcleo (kernel)} e alguns
	\defin{programas do sistema}. Há ainda \defin{aplicações} que executam
	diversas tarefas. O kernel é o coração do sistema operacional\footnote{
	Na verdade ele é erroneamente considerado como o próprio sistema 
	operacional. Um sistema operacional disponibiliza muito mais 
	serviços que o kernel somente}. Ele mantém o controle dos arquivos
	em disco, inicializa programas e executa-os de forma concorrente,
	aloca memória e outros recursos para os diversos processos, recebe e 
	envia pacotes da rede, e assim por diante. O kernel faz muito 
	pouco sozinho, na verdade ele provê ferramentas com as quais os
	serviços podem ser desenvolvidos. Ele ainda evita que qualquer um possa
	acessar diretamente os componentes de hardware, forçando o uso das
	ferramentas disponíveis. Deste modo, o kernel mantém uma certa proteção
	entre os usuários.
	As ferramentas disponibilizadas pelo kernel são utilizadas através
	das \defin{chamadas ao sistema  (system calls)}. Para maiores informação 
	veja o Apêndice~\ref{chap:comandos}.
\index{kernel}
\index{sistema operacional}
\index{programas do sistema}
%\index{programas de aplicação}
\index{chamadas ao sistema}

	Os programas de sistema utilizam as ferramentas disponibilizadas 
	pelo kernel para implementar os diversos serviços necessários
	ao sistema operacional. Programas de sistema e
	todos os demais programas, são executados `sobre o kernel', o
	qual é denominado \defin{modo usuário}\footnote{\defin{user mode}
	no original}.
	A diferença entre programas de sistema e aplicações está no seu 
	objetivo: as últimas visam que coisas úteis sejam realizadas 
	(brincar, caso seja um jogo), enquanto os primeiros são
	necessários para manter o sistema operacional funcionando. 
	Um editor de textos é uma aplicação, o \cmd{telnet} é um programa de 
	sistema. A diferença é algumas vezes muito pequena, e somente é
	importante para classificadores compulsivos. 

	
\index{modo usuário}

	Um sistema operacional pode ainda conter compiladores e suas 
	bibliotecas correspondentes (GCC e C no caso do Linux), ainda 
	que nem todas as linguagens devam ser parte integrante do sistema
	operacional. Documentação e até mesmo jogos podem fazer parte. 
	Tradicionalmente o sistema operacional tem sido definido como o 
	conteúdo nos discos de instalação, o que no Linux pode variar bastante,
	já que ele pode ser encontrado em diversos sites ao redor do mundo.
	

\index{GCC}
\index{linguagens de programação}
\index{compilador C}
\index{documentação}
\index{jogos}

\section{Partes importantes do kernel}

	O kernel do Linux é formado por diferentes partes: gerenciador de 
	processos, gerenciador de memória, controle de dispositivos de 
	hardware, controle de sistemas de arquivos, gerenciador de rede e vários
	outros. A figura \ref{fig:kernel-overview} mostra alguns deles.


\index{gerenciador de processos}
\index{gerenciador de memória}
\index{controladores de dispositivo}
\index{dispositivo de controle}
\index{sistema de arquivos}
\index{gerenciador de rede}

\begin{figure}[htb]
\begin{center}
%%\includegraphics{overview/overview-kernel.ps}
\end{center}
\caption{Partes importantes do kernel do Linux.}
\label{fig:kernel-overview}
\end{figure}

	Provavelmente as partes mais importantes do kernel (nada funciona
	sem elas) são o gerenciador de memória e o gerenciador de processos.
	O gerenciador de memória é o responsável pela atribuição de áreas de 
	memória e áreas de troca (swap) para os processos, para os
	demais componentes do kernel e para o cache de disco. O gerenciador
	de processos cria processos e implementa multitarefa através da 
	troca dos processos ativos no processador.
\index{multitarefa}
\index{área de troca}
\index{cache de disco}

	No  nível mais baixo, o kernel contém controladores
	(drivers) para cada tipo de hardware suportado.  Uma vez que existem
	inúmeros hardwares, o número de controladores também é 
	muito grande. A similaridade de funcionalidades permite que se
	tenham classes de controladores para suportar funções
	similares, ou seja, cada membro de uma determinada classe de 
	hardwares tem a mesma interface com o resto do kernel, mas 
	diferem somente no que é necessário para implementar as suas 
	características específicas. Por exemplo todos os discos rígidos
	parecem iguais para o resto do kernel, isto é todos têm operações 
	como `inicialize o dispositivo' , `leia o setor N' e `grave o setor N'.

	Alguns serviços de software disponibilizados pelo kernel tem 
	propriedades similares, e podem ser também derivados em classes.
	Por exemplo, os diversos protocolos de rede foram abstraídos em uma
	interface de programação, a biblioteca BSD de socket. Outro
	exemplo é a camada do \defin{sistema virtual de arquivos}
	(VFS), a qual abstrai as operações dos diversos sistemas de 
	arquivos de suas implementações. Quando alguma entidade tenta
	utilizar um sistema de arquivos, a requisição é direcionada ao
	VFS, a qual  a reencaminha  para o controlador adequado ao sistema de 
	arquivos solicitado.

\index{sistema de arquivos virtual}
\index{BSD}
\index{socket}

\section{Principais serviços em um sistema UNIX}

	Esta seção descreve como partes importantes dos serviços UNIX 
	são implementadas. Elas são descritas mais detalhadamente nos
	próximos capítulos.


\subsection{\cmd{init}}

	O mais importante serviço isolado disponível em um
	sistema UNIX é denominado \cmd{init}. O \cmd{init} é o primeiro
	processo iniciado em todos os sistemas UNIX, após a
	carga do kernel do sistema. Quando o \cmd{init} é disparado,
	ele continua o processo de inicialização do
	sistema, executando diversas tarefas necessárias ao
	funcionamento do Linux (checando e montando
	sistemas de arquivos, iniciando servidores, etc).
	
\index{/sbin/init}
\index{montando sistemas de arquivos}
\index{processo de inicialização}

	A lista exata de tarefas que o \cmd{init} realiza depende do estado
	em que ele está. O \cmd{init} provê o conceito de modo monousuário,
	no qual ninguém, além do \cmd{superusuário (root)}, pode entrar no
	sistema, sendo utilizado somente o shell da console
	do sistema, ou o modo \defin{multiusuário}, o modo padrão de início
	do sistema. Algumas versões generalizam isso, denominando-os 
	\defin{níveis de execução}; sendo os modos mono e MULTIUSUÁRIO[C[C[C[C[C[C[C[C[C[C[C[C[C[C[D[D[D[D[D[D[D[D[D[D[D[D[D[D[Dmultiusuário
	considerados como níveis, podendo existir diversos outros, como 
	por exemplo, aquele que permita a execução do X (interface gráfica)
	na console.
\index{nível de execução}
\index{monousuário}
\index{multiusuário}
\index{X Window}

	Em uma operação normal, o \cmd{init} certifica-se que o
	\cmd{getty} está sendo executado (para permitir o acesso dos usuários) e
	adota processos órfãos (processos cujos programas
	que os iniciaram (chamados pais) morreram (não
	estão mais sendo executados)). No UNIX \emph{todos} os
	processos \emph{devem} estar em uma estrutura do tipo
	árvore, devendo todos eles terem um "pai".

	Quando um sistema é desligado, é o \cmd{init} que se encarrega de
	finalizar todos os outros processos, desmontar todos os sistemas 
	de arquivos e parar o processador junto com tudo o mais que esteja
	sendo executado.

\index{matando processos}
\index{desmontando sistemas de arquivos}
\index{parando o processador}

\subsection{Acesso a partir de terminais}

	Os accessos a partir de terminais (via linhas
	seriais) e através da console (quando não se está
	executando o X), são disponibilizados pelo \cmd{getty}. O \cmd{init} 
	inicia uma instância distinta do \cmd{getty} para cada terminal,
	nos quais o acesso é permitido. O \cmd{getty} lê
	o nome do usuário e executa o programa de acesso
	\cmd{login}, o qual por sua vez processa a validação da
	senha do usuário. Caso usuário e senha sejam
	válidos, o \cmd{login} inicia o shell do
	usuário. Quando um shell é finalizado, isto é, o usuário sai do
	sistema, ou quando o  \cmd{login} é finalizado porque
	usuário ou senha são incorretos, o \cmd{init} inicia uma nova
	instância do \cmd{getty}. O kernel não tem conhecimentos
	dos acessos, pois tudo isso é controlado pelos programas de sistema.

\index{/sbin/getty}
\index{acessando o sistema}
\index{saindo do sistema}
\index{autenticação de usuário}

\subsection{Syslog}

	O kernel e muitos programas do sistema produzem avisos,
	mensagens de erro, e outros alertas. É importante que estas 
	mensagens possam ser lidas outra hora, mesmo que isto demore 
	muito tempo deste o ocorrido. Para que isso seja possível elas 
	devem ser gravadas em um arquivo. O programa responsável por este
	arquivamento é o \cmd{syslog}.  Ele pode ser configurado para 
	gravar as mensagens em diferentes arquivos de acordo com o nível 
	de importância ou origem. As mensagens do kernel são 
	freqüentemente direcionadas para arquivos distintos, pois estas
	mensagens são normalmente mais importantes e necessitam ser lidas 
	com mais freqüência para se evitar/sanar problemas.

\index{mensagens de erro}
\index{mensagens de alerta}
\index{arquivos de log}

\subsection{Comandos periódicos: \cmd{cron} e \cmd{at}}

	Tanto administradores do sistema como usuários comuns necessitam
	executar periodicamente determinados programas.  
	O administrador do sistema quer executar um comando
	para limpar os diretórios que contenham arquivos temporários
	antigos (\fn{/tmp} e \fn{/var/tmp}), evitando assim que os discos
	rígidos fiquem cheios de arquivos sem utilizadade, uma vez que 
	nem todos os programas apagam os arquivos temporários após a sua execução.


\index{execução periódica de comandos|see{cron e at}}
\index{arquivos temporários}
\index{limpando arquivos temporários}

	O \cmd{cron} foi criado para atender a essa demanda. Cada usuário
	tem uma tabela do cron (\cmd{crontab}) à sua disposição, onde se
	inclui os comandos desejados e a freqüência com que eles
	devem ser executados. O daemon do \cmd{cron}  encarrega-se de
	executar os comandos nos dias e horários definidos.
\index{servidores!cron|ver{cron}}

	O comando \cmd{at} é similar ao \cmd{cron}, mas está limitado à uma única 
	execução: o comando é executado em um determinado horário fornecido,
	mas não repetidas vezes.
\index{daemons!at|see{at}}

\subsection{Interface Gráfica}

	O UNIX e o \linux\  não incorporam a interface do usuário
	ao kernel. Ela é implementada pelos programas a nível de usuário, 
	tanto no modo texto como no ambiente gráfico.

	Esta solução gera uma maior flexibilidade para o sistema, mas, 
	pela facilidade de implementação, pode-se ter uma multiplicidade exagerada 
	de interfaces, uma para cada programa, tornando o sistema mais
	complexo de ser utilizado.

	O ambiente gráfico usado com o \linux\ é chamado X Window (X).
	O X na verdade não implementa a interface gráfica, somente
	disponibiliza um sistema de janelas, onde outros programas podem 
	implementar um ambiente gráfico . Algumas das interfaces gráficas 
	mais populares para o \linux\ são: KDE, Gnome, After Step, Window Maker,
	fvwm e fvwm95.
\index{interface gráfica}
\index{X Window}
\index{KDE}
\index{Motif}
\index{Open Look}

\subsection{Rede}

	Rede pode ser definida como a conexão entre dois ou mais computadores,
	de forma que eles possam comunicar-se entre si. Os métodos de conexão e
	comunicação são um tanto complexos, porém os resultados são muito úteis.

	Os Sistemas UNIX têm muitas características de rede. 
	Os serviços básicos de impressão, cópias de segurança, sistemas 
	de arquivos, etc, podem ser realizados através da rede. Isso pode 
	tornar a administração do sistema mais simples, uma vez que permite a sua
	administração de forma centralizada, mantendo os benefícios do processamento
	distribuído e do uso de microcomputadores, gerando menores custos
	e melhor tolerância à falhas.
\index{processamento centralizado}
\index{processamento distribuído}
\index{tolerância a falhas}

	Ainda que este livro aborde superficialmente o
	tema, veja o Guia do Administrador de Redes para
	maiores informações, inclusive uma descrição mais
	profunda sobre o funcionamento de redes.


\subsection{Acesso via Rede}

	Os acessos via rede são um pouco diferentes dos acessos normais, onde 
	há uma linha serial distinta para cada terminal, através da qual é
	possível acessar o sistema. Nos casos de acesso via rede, para cada
	usuário que conecta-se ao sistema, há uma conexão virtual separada, 
	podendo haver\footnote{teoricamente} um número ilimitado delas
	\footnote{Bem, pelo menos um número bem grande. A banda das redes 
	ainda é um recurso escasso. Sendo assim utiliza-se limites práticos 
	para o número de conexões simultâneas que podemos ter em uma conexão 
	de rede.}. Não é mais possível executar um \cmd{getty} para cada conexão 
	virtual possível.  Existem muitas formas diferentes de conectar-se via 
	rede, sendo o \cmd{telnet} e \cmd{rlogin} os mais utilizados em redes 
	TCP/IP.

	Acessos via rede tem, ao invés de inúmeros \cmd{getty}, 
	um servidor controlando o acesso (o \cmd{telnet} e o \cmd{rlogin}
	utilizam servidores distintos), os quais monitoram
	as tentativas de conexão. Quando algum usuário tenta conectar-se,
	o servidor inicia uma nova instância de si próprio para
	controlar esta conexão enquanto o servidor original continua monitorando 
	novas tentativas. As novas instâncias funcionam de maneira similar ao
	getty.
\index{servidores!telnet|see{telnet}}
\index{servidores!rlogin|see{rlogin}}

\subsection{Sistemas de Arquivos em Rede (NFS)}
\label{sec:NFS}

	Uma das maiores facilidades disponibilizadas pelos serviços de rede
	é o compartilhamento de arquivos através de \defin{sistemas de arquivos 
	em rede}.  O mais usado é conhecido como NFS (Network File System),
	tendo sido desenvolvido pela Sun.
\index{Sun}
\index{NFS}
\index{sistema de arquivos em rede}
\index{Sistema de Arquivos em Rede|see{NFS}}

	Com um sistema de arquivos em rede, qualquer operação com arquivos
	executada por um programa em uma máquina, é enviada pela rede para 
	outro computador. Esse procedimento faz o programa "pensar" que todos 
	os arquivos encontram-se no mesmo equipamento onde ele está sendo 
	executado. Isso torna o compartilhamento de informações muito simples, 
	já que não requer nenhuma modificação nos programas utilizados.


\subsection{Correio Eletrônico}

	O correio eletrônico é normalmente o mais importante meio de comunicação
	entre os usuários. Uma mensagem eletrônica é armazenada em um arquivo, 
	formatada de maneira especial, e programas de correio específicos são
	utilizados para ler e enviar mensagens.

\index{comunicação}
\index{e-mail|see{correio eletrônico}}
\index{correio, eletrônico|see{correio eletrônico}}
\index{correio eletrônico}
\index{mensagem|see{correio eletrônico}}

	Cada usuário tem uma \defin{caixa de entrada de mensagens}
	\footnote{mailbox}
	(um arquivo com um formato especial) onde todas as
	novas mensagens são armazenadas. Quando alguém
	envia uma nova mensagem, o programa de correio
	localiza a caixa do destinatário e adiciona a nova
	mensagem ao arquivo de mensagens. Caso a caixa de
	entrada esteja em outra máquina, a mensagem é
	enviada através da rede para o equipamento que
	mantém os arquivos de correio do destinatário.
\index{mailbox}
\index{caixa de entrada de mensagens}

	O sistema de correio é constituído por uma série de
	programas. A entrega de mensagens para usuário
	remotos é realizada por um programa específico (o
	\defin{agente de transferência de mensagens} ou \defin{MTA}, como
	por exemplo o \cmd{sendmail} ou \cmd{smail}), enquanto os
	programas de usuários são também distintos (\defin{agente
	de correio de usuário} \defin{MUA}, p. ex. \cmd{pine},
	\cmd{elm} ou \cmd{kmail}. As caixas postais são
	normalmente armazenadas no diretório \fn{/var/spool/mail}.
\index{/var/spool/mail}


\subsection{Impressão}

	Somente um usuário pode utilizar uma impressora a cada vez, 
	mas seria anti-econômico não compartilhar esse recurso entre os 
	demais usuários da rede. A impressora é  gerenciada por um
	software que implementa o conceito de \defin{fila de
	impressão}: todos os trabalhos são colocados em uma
	fila e toda vez que a impressora finaliza um
	trabalho de impressão, o seguinte é iniciado
	automaticamente.  Isso evita que os usuários tenham
	que organizar esta fila ou que haja problemas no
	controle do uso da impressora\footnote{Ao invés disso, as pessoas
	fazem uma fila \emph{em frente} à impressora, esperando pelos seus
	impressos, já que eles não sabem quando a fila irá liberar seus trabalhos.
	Isto ajuda muito nas relações sociais do escritório!}.
\index{fila de impressão}
\index{compartilhando impressoras}
\index{relações sociais}

	O software de fila de impressão também grava os
	trabalhos de impressão em disco, ou seja os textos
	são mantidos em um arquivo enquanto estejam na fila
	de impressão. Isso permite que uma aplicação
	transfira rapidamente os trabalhos de impressão
	para o software gerenciador da fila, não tendo que
	esperar que o trabalho de impressão seja finalizado
	para continuar a sua execução.
\index{spooling}

\section{A estrutura do sistema de arquivos}

	O sistema de arquivos é dividido em diversas
	partes, normalmente utilizando uma estrutura em
	árvore, com um sistema de arquivos chamado raiz
	(root), simbolizado por '\fn{/}'. Debaixo deste podemos
	ter diversos outros: \fn{/bin}, \fn{/lib},
	\fn{/etc}, \fn{/dev}, etc.... Um sistema de arquivos \fn{/usr}
	pode conter programas e dados não atualizáveis, o
	\fn{/var} pode conter dados variáveis (como arquivos de
	log) e um sistema \fn{/home} pode ter arquivos
	pessoais de todos os usuários. Dependendo da
	configuração de hardware e das definições do
	administrador do sistema, a divisão pode variar
	substancialmente, sendo possível inclusive que
	todos os conteúdos estejam em um único sistema de
	arquivos.


%%	Chapter~\ref{chap:walkabout} describes the filesystem layout
	No capítulo \ref{chap:walkabout}  apresentaremos a estrutura dos 
	sistemas de arquivos em mais detalhes, sendo que o documento
	que descreve o Sistema de Arquivos Padrão do Linux (FSSTND)
	cobre o tema mais profundamente.
\index{FSSTND}
\index{Sistema de Arquivos Padrão do \linux\|sver{FSSTND}}
\index{Sistema de Arquivos Padrão|see{FSSTND}}
