Data da última atualização: 04/06/2000
©2000 - Daniel Sadoc Menasché; & Fernando Jorge Silveira Filho

Conceitos básicos sobre Linux

------------------------------------------------------------------------

  1. Usando o Linux
    1. O que é o Linux
    2. O que é um comando
    3. Alguns comandos disponíveis
    4. Terminais virtuais
    5. O sistema de arquivos e diretórios importantes
  2. X Window System
    1. Conceitos sobre o X
    2. Os Gerenciadores de Janelas
  3. Editores de texto
  4. Linguagens de Programação
    1. Como programar com o gcc
    2. Makefiles (arquivos make)
  5. Instalação de novos programas
    1. RPM
    2. DPKG
    3. Arquivos .tar.gz ou .tgz
  6. Roteiro

------------------------------------------------------------------------

1.1. Usando o Linux

Para aqueles que nunca usaram o Linux, iremos expor aqui os conceitos preliminares estritamente necessários para se programar usando o GTK. Portanto, esta primeira seção, onde iremos apenas apresentar alguns pontos que consideramos fundamentais, é dedicada aos iniciantes e àqueles que ainda não estão familiarizados com o sistema. Se esta não é a sua situação, vá direto para a próxima seção.

Nosso primeiro principal objetivo será motivá-lo a usar o GTK. Esperamos que qualquer um que tenha noções básicas de C sinta-se encorajado a usar o GTK após ler este tutorial, independentemente do sistema operacional que vinha usando até então. Por isso, é muito importante para nós ter acesso a possíveis dúvidas e comentários. Teremos o maior prazer em responder.

Partimos do princípio de que você tem o Linux instalado e funcionando corretamente. Caso você ainda precise passar por essa etapa, recomendamos a instalação de uma das diversas distribuições disponíveis, entre elas a da Red Hat (www.redhat.com.br), uma das mais fáceis de ser instalada e atualizada. Em seguida, leia o texto "Linux Installation and Getting Started" (http://www.infomagic.com/linux/ldp/LDP/gs/gs.html), ou "Linux Installation HOWTO" (http://www.cube.net/Linux-HOWTO/Installation-HOWTO.html) de Matt Welsh, ou ainda Linux Installation HOWTO (http://www.linuxdoc.org/HOWTO/Installation-HOWTO.html"), de Eric S. Raymond. Parte desses textos corresponde aos capítulos iniciais do livro Dominando o LINUX, de Matt Welsh e Lar Kaufman, cuja leitura é muito recomendada. Visite http://www.infomagic.com/catalog2.htm para obter mais informações sobre o livro.

O site de referência ao Linux é: http://www.linux.org/. Vale a pena visitá-lo de vez em quando!


1.1.1. O que é o Linux

O Linux é um sistema multiusuário e multitarefa, o que significa que várias pessoas podem trabalhar de uma vez, e que este é capaz de realizar diversas tarefas ao mesmo tempo. Além disso, o Linux é um sistema operacional em constante evolução. Isto implica num eterno aprendizado por parte de seus usuários.

Quando se usa um computador em que o sistema LINUX foi instalado, a primeira coisa que se deve fazer é informar o seu login, e em seguida a sua senha, o que lhe dará acesso a todos os recursos disponíveis. Em geral, apenas o usuário denominado "root" tem acesso irrestrito a todo o sistema, e é ele quem administra o restante das configurações.

Uma vez digitado o login e a senha, você terá acesso ao prompt. Esse prompt (que aqui será simbolizado por um sinal de $) é gerado por um programa chamado shell (literalmente, casca ou aparência exterior) que é responsável por lidar com os seus comandos.


1.1.2. O que é um comando

No Linux, os comandos são arquivos que possuem permissão para serem executados. A maioria dos comandos inerentes ao Linux encontra-se no diretório /bin. Assim como no DOS, existe uma lista de diretórios onde o shell pesquisa à procura de comandos. Essa lista de diretórios se chama path (ou caminho). Para ver como está o seu caminho atual, digite:

$echo $PATH

Uma observação muito importante é que, diferentemente do DOS, o Linux não pesquisa automaticamente no seu diretório atual a procura de comandos a serem executados.

O diretório atual é simbolizado por um ponto, e o diretório pai é simbolizado por dois pontos. Se você quiser executar um arquivo chamado "nomearq.exe", que se encontra no diretório atual, e informar apenas:

$ nomearq

receberá uma mensagem do tipo "File not found". Você deverá informar explicitamente ao sistema que execute o arquivo "nomearq.exe", que se encontra no diretório atual:

$./nomearq.exe

Uma alternativa seria incluir um ponto ( . ) na variável $PATH. No bash, use:

$ export PATH=$PATH:.

Esse comando irá tornar o seu caminho igual ao caminho antigo mais o diretório atual (o ponto).

No tcsh, forneça:

$ set path = ( $PATH . ) 1


1.1.3. Alguns comandos disponíveis

O formato geral de um comando é:

comando [-[opção1][opção2]...] parâmetro

onde o que está entre colchetes é opcional.

A familiarização com os comandos do Linux é obtida com a experiência. Em tempo, iremos apenas apresentar a lista de alguns comandos básicos, sua finalidade, sintaxe e parâmetros. Para obter mais informações sobre qualquer comando, basta consultar as páginas manuais, digitando no prompt "man" seguido do nome do comando. Por exemplo: $man ls.

A tabela abaixo lista alguns dos principais comandos do Linux, suas finalidades, sintaxes e parâmetros: 2

Comando

Finalidade

Sintaxe

Parâmetros

ls
list

Lista o conteúdo de um diretório.

ls -lar --color diretório

-l: lista longa
-a: lista arquivos ocultos
-r: lista recursivamente
--color: ativa cores

cd
change directory

Troca de diretório.

cd diretório

 

rm
remove

Remove arquivos e diretórios.

rm -irf arquivo

-i: apaga confirmando

-r: apaga recursivamente
-f: apaga forçadamente

cp
copy

Copia arquivos.

cp fonte destino

 

mkdir
make directory

Cria um diretório.

mkdir diretório

 

rmdir
remove directory

Apaga um diretório.

rmdir diretório

 

touch

Cria um arquivo vazio.

touch arquivo

 

more

Exibe conteúdo do arquivo.

more arquivo

 

clear

Limpa a tela.

clear

 

su

Muda de login.

su [-] login

 

find

Procura arquivos em diretórios.

find caminho expr.

--name: procura pelo nome

ps
process

Mostra os processos rodando na máquina.

ps - aux

 

grep

Procura padrões em um arquivo.

grep expr. arquivo

-a: todos os processos

-x: mostra processos que não foram iniciados no console

-u: nome do usuário e hora de início

df
disk free

Mostra espaço em disco livre.

df partição

 

du
disk usage

Mostra uso de disco.

du -s arquivo

-s: mostra apenas o total

pwd
print working directory

Mostra o nome do diretório corrente.

pwd

 

finger

Mostra informações sobre um usuário.

finger usuário

 

passwd
password

Definir senha.

passwd

 

logout

Sair do sistema.

logout

 

halt

Desliga o sistema.

halt

 

Observe que no comando ls, a opção color deve ser precedida por dois hífens. Nos comados em geral, qualquer parâmetro que possua mais de um caracter (no caso, a palavra "color" possui cinco caracteres) deve ser passado com dois hífens na frente. Se quisermos mostrar uma lista longa dos arquivos, incluindo os ocultos, com cores, devemos digitar:

$ ls -la --color

Atenção! Em um sistema monousuário, antes de desligar o computador sempre execute o comando halt e aguarde a mensagem "System halted!". Em muitos sistemas apenas o usuário root pode executar o comando halt.

Para colocar qualquer comando em segundo plano, basta proceder normalmente e digitar um & antes de pressionar enter.


1.1.4. Terminais virtuais

No prompt do shell, ao pressionar a tecla Alt à esquerda e uma das teclas de função, de F1 a F7, você poderá navegar pelos consoles virtuais. Cada um deles está associado a uma nova tela. Desse modo pode-se trabalhar com atividades diferentes em seções distintas. Observação: numa seção do X, pressione Ctrl, Alt e uma das teclas de função, de F1 a F7, para saltar para um outro console. Em geral, o sistema de janelas X é carregado no terminal virtual de número sete.

Dentro de um console virtual, um recurso muito útil para se navegar no sistema é o uso da tecla tab para completar seus comandos em geral. Experimente digitar:

$ cd /usr/sb

e tecle tab em seguida. Se você usa o shell bash, ksh, tcsh ou zsh, este irá preencher para você as informações que faltam na sua linha de comando. Caso exista mais de uma possibilidade de término de palavra, pressione tab mais uma vez e aparecerão todas as opções disponíveis. 1


1.1.5. O sistema de arquivos e diretórios importantes

Algo que você certamente mais cedo ou mais tarde irá querer fazer é acessar a unidade de disco, cd-rom ou até mesmo uma partição que contenha dados do Windows 95/98. Para isso, é necessário inicialmente "montá-la" usando o comando mount. A sua sintaxe é:

mount -f tipo dispositivo ponto_de_montagem

Um exemplo de utilização, para acessar os dados do Windows 98 contidos na partição de número um do terceiro disco rígido, ou seja, do dispositivo chamado hdc1, seria:

$ mkdir /win98

$ mount -f vfat /dev/hdc1 /win98

Feito isso, nesse exemplo os dados da nova unidade montada podem ser acessados a partir do diretório win98. Uma observação importante é que nem todos os usuários podem usar o mount em todas as situações. Consulte a página de manual do mount para maiores detalhes.

Para acessar a unidade de disco, por exemplo, você poderá recorrer aos mtools, caso estejam instalados no seu sistema. Digite man mtools na linha de comando para obter mais informações.

Os diretórios que guardam os arquivos de sistema do Linux, em sua maioria, são padronizados. Alguns diretórios importantes são:

 

 

/

/home

/bin

/usr

 

 

 

 

 

 

/usr/bin

/usr/spool

/dev

/usr/sbin

 

 

 

 

 

/sbin

/etc

 

 

 

 

 

 

 


/

O diretório "root" (raiz).


/home

Abriga os diretórios dos usuários. Por exemplo, um usuário cujo login seja "ana" provavelmente quando entrar no sistema será encaminhado direto para o diretório /home/ana, e terá acesso a todos os dados contidos no mesmo.


/bin

Guarda os programas e comandos básicos do Linux. bin é um mnemônico para "binaries" (binários), ou seja, arquivos executáveis. Na realidade todos os arquivos armazenados num computador estão em formato binário. Infelizmente, usa-se como jargão, por motivos históricos, o termo "arquivos binários" como sendo sinônimo de arquivos executáveis.


/usr

Armazena muitos outros diretórios com conteúdo orientado aos usuários.


/usr/docs

Documentos, incluindo informação útil sobre o Linux.


/usr/man

Páginas de manual, acessadas digitando man <comando>


/usr/games

Jogos!


/usr/bin

Neste diretório estão contidos programas voltados aos usuários do sistema em geral.


/usr/spool

Este diretório possui vários subdiretórios. Entre eles mail, que guarda mensagens, spool, onde são guardados arquivos a serem impressos e uucp que abriga arquivos copiados entre máquinas Linux.


/dev

No Linux, tudo é acessado por meio de arquivos! O diretório /dev armazena dispositivos. Estes, na realidade, são pontes para os verdadeiros componentes físicos da máquina. Por exemplo, se você copia para /dev/fd0, na realidade você está enviando dados para uma unidade de disco. O seu terminal é um arquivo /dev/tty. Partições do disco rígido são da forma /dev/hd0. Até a memória do sistema é um dispositivo!

Um dispositivo famoso é o /dev/null, que corresponde a uma lixeira. Toda informação desviada para /dev/null é descartada.


/usr/sbin

Aqui estão os arquivos de administração do sistema.


/sbin

Neste diretório estão contidos arquivos executados em geral automaticamente pelo sistema operacional.


/etc

Este diretório e seus subdiretórios abrigam muitos arquivos de configuração. Estes arquivos são na maioria do tipo texto, e podem ser editados para alterar parâmetros do sistema. 3

------------------------------------------------------------------------

1.2. X Window System


1.2.1. Conceitos sobre o X

O X Window System, ou Sistema de Janelas X, é basicamente um conjunto padronizado de rotinas de tratamento de tela, desenvolvido no MIT, que permite a criação de interfaces gráficas independentes do hardware. 4

Neste esquema, você pode observar que os aplicativos trocam dados com o Sistema de Janelas X, o qual passa as informações para o vídeo. Não existe um acesso direto ao monitor de vídeo por parte das aplicações, tornando-se estas mais facilmente portáveis. Isto é, o mesmo programa pode ser executado sobre qualquer hardware sem ser modificado ou recompilado.

Além disso, o X Window System é um sistema de janelas que pode executar aplicações em rede de forma transparente. Portanto, vários aplicativos, que podem estar rodando em máquinas distribuídas por toda a rede, geram simultaneamente texto e gráficos na tela de um determinado usuário. 5

No prompt de seu shell, digite startx. Se o X for inicializado, e o cursor aparecer no vídeo, você está pronto para utilizá-lo. Caso contrário, será necessário configurá-lo. Clique aqui para fazer o download de um tutorial a fim de aprender a configurar o seu Sistema de Janelas X.


1.2.2. Os Gerenciadores de Janelas

Note que, ao definirmos o Sistema de Janelas X, nos referimos a um conjunto de rotinas padronizadas para acessar o vídeo. Em outras palavras, o Sistema de Janelas X é apenas um protocolo. Em cima desse protocolo é que rodam todos os aplicativos. Inclusive os gerenciadores de janelas (ou window managers), que são responsáveis por gerar a interface externa do sistema ao usuário.

É função dos gerenciadores de janelas prover:

- barras de título, bordas e outras decorações para as janelas das aplicações

- ícones uniformes

- um meio uniforme de se mover e redimensionar as janelas

- uma interface uniforme para se mover entre as aplicações

Entre os window managers mais famosos podemos citar o fvwm, o KDE ( www.kde.org ) e o Window Maker (www.windowmaker.org) entre vários outros (este último foi desenvolvido em grande parte na Universidade Federal do Rio Grande do Sul). É o window manager que determinará a aparência do seu sistema X, portanto escolha o que mais lhe agradar.

------------------------------------------------------------------------

1.3. Editores de texto

Em praticamente todos os sistemas Linux estão instalados o vim e o Emacs. Por isso, é de grande utilidade saber utilizar bem um desses dois editores. Se você tem instalado o X, sua distribuição deve provavelmente incluir também o gvim e uma versão para o X do emacs.

Para aprender a usar o vim, visite http://www.vim.org/. O emacs também possui a sua página em http://www.emacs.org

Note que o vim e o emacs são editores de textos simples. Para formatar os textos, existem os processadores de textos, entre eles o TEX/Latex, o groff e o Textinfo. Por meio de comandos inseridos no texto o usuário pode transformar um documento simples em um documento formatado usando um desses processadores.

------------------------------------------------------------------------

1.4. Linguagens de Programação


1.4.1. Como programar com o gcc

O gcc é um compilador C/C++ poderoso. Isto se deve ao fato de que o C é a linguagem nativa do Linux.

O gcc (GNU C Compiler) funciona a partir da linha de comandos do shell. Para saber todas as opções que esse compilador oferece, consulte a página manual do mesmo. Visite a página www.gnu.org para saber mais sobre o projeto GNU.

A sintaxe básica para se chamar o gcc é:

$ gcc [opções] [arquivos]

Muitas opções do gcc consistem de mais de um caracter. Por isso, diferentemente da maioria dos outros comandos do shell, cada opção deve ser precedida pelo seu próprio hífen. Você não pode agrupar opções depois de um único hífen. Os dois comandos a seguir, por exemplo, não são idênticos:

$ gcc -p -g test.c

$ gcc -pg test.c

Se você compilar um arquivo e não especificar nenhum parâmetro na linha de comando, o gcc irá automaticamente criar um arquivo executável, e irá chamá-lo de a.out. Para testar, clique aqui para baixar o arquivo teste.c (o tradicional "Hello World!" escrito em C), copie-o para o diretório adequado e lá digite:

$ gcc teste.c

Para especificar um outro nome para o arquivo de saída, deve-se usar a opção -o (do inglês, output). Para compilar um programa chamado teste.c e gerar um executável chamado hello, digite o seguinte:

$ gcc -o hello teste.c

O processo de gerar um arquivo executável se divide em duas etapas. Primeiro é gerado o código objeto, a partir do código fonte. Esse arquivo objeto é praticamente equivalente ao código de máquina. Em seguida, o arquivo objeto é linkado ("ligado") para produzir um executável.

Essa etapa consiste em informar ao programa onde encontrar as bibliotecas de que este necessita para funcionar. Existem dois tipos de bibliotecas: as estáticas e as compartilhadas. As bibliotecas estáticas são anexadas ao arquivo a ser executado, de modo que passam a fazer parte do programa final. Isso, no entanto, pode ser pouco prático, caso muitos programas usem as mesmas sub-rotinas de bibliotecas em comum. Nesses casos, costuma-se usar as bibliotecas compartilhadas.

Quando o programa for ligado a uma biblioteca compartilhada, ao invés de ser anexado todo o código da biblioteca ao programa, será apenas fornecida uma referência para a mesma no disco, de modo que o carregador possa encontrá-la durante a execução.

Bibliotecas

Para o compilador saber onde encontrar os arquivos de inclusão e as bibliotecas, use as opções -I e -L respectivamente, seguidas pelos diretórios onde encontram-se os mesmos. Por exemplo:

$ gcc -I/usr/include -L/usr/lib -o exemplo exemplo.c -lstuff

Neste exemplo, a opção -I informa ao gcc para que acrescente o diretório /usr/include ao caminho onde serão pesquisados os arquivos de inclusão. A opção -L informa ao gcc que acrescente o diretório /usr/lib ao caminho onde serão pesquisadas as bibliotecas. Por fim, a opção -lstuff indica ao gcc que ligue a biblioteca libstuff.a ao executável. Por padrão todas as bibliotecas começam com as iniciais "lib". As bibliotecas que terminam com a extensão ".a" são estáticas, e as que terminam com extensão ".so" são compartilhadas. Por padrão, o compilador irá tentar primeiro ligar as bibliotecas compartilhadas. Para especificar que você deseja usar bibliotecas estáticas, utilize a opção -static.1

Mais opções...

É recomendável que se ative a opção -w ao se usar o gcc. Esta ativa todas as mensagens de aviso e de erro que o compilador possa gerar.

Pode-se especificar até que ponto o gcc irá processar o código fonte. A opção -c indica ao gcc que apenas gere o código objeto. A opção -S indica ao gcc que pare após gerar o código assembly.

É possível ainda otimizar o seu código fonte, usando as opções -O, que fará otimizações básicas, e -O2, que trará otimizações avançadas. Ao ativar essas opções, o processo de compilação se tornará mais lento, mas o seu executável será mais rápido.

Finalmente, para poder futuramente depurar ou analisar detalhes sobre o código, use a opção -g, se for usar o gdb (Gnu Debugger), -p se for usar o prof ou ainda -pg, se você for usar o gprof. 3

Para saber como compilar programas que fazem uso da biblioteca GTK, consulte a seção 2.2.2.


1.4.2. Makefiles (arquivos make)

Se você estiver trabalhando num projeto com diversos arquivos, o make é um programa bastante útil, que lhe poderá poupar muito tempo. Ao compilar o seu projeto usando o make, este irá consultar um registro de dependências entre os seus arquivos e atualizar apenas aqueles que foram alterados desde a última atualização.

O formato geral de uma entrada de um arquivo make é:

destino: dependências

(TAB) lista de comandos

Note que a lista de comandos deve começar com uma tabulação, e não com espaços.

Digamos, por exemplo, que você deseja construir um programa chamado felicidade, que dependa dos arquivos saude.c e amor.c. Você deverá editar um arquivo chamado makefile, ou Makefile, como preferir, contendo as seguintes três entradas:

felicidade: amor.o saude.o

gcc -o felicidade amor.o saude.o

amor.o: amor.c

gcc -c amor.c

saude.o: saude.c

gcc -c saude.c

Agora, digite na linha de comando:

$ make felicidade

O programa make irá procurar no seu diretório atual um arquivo chamado, literalmente, makefile ou Makefile. Ao encontrar o arquivo que você acabou de fornecer, ele irá interpretar, a partir da primeira linha do mesmo, que "felicidade" é construída a partir de amor.o e saude.o. Recursivamente, o make irá verificar que amor.o depende de amor.c, e que saude.o depende de saude.c. Sempre que um dos arquivos de dependência for alterado, ou não existir, a lista de comandos referentes a ele será executada. Para saber se um arquivo foi alterado, o make consultará a data e a hora associados ao mesmo pelo sistema operacional. Para saber quando determinado arquivo foi modificado pela última vez, execute o comando: ls -l. 1


1.4.3. Depuração com o gdb

O gdb (GNU Debugger) possui muitos comandos que lhe irão permitir executar diferentes operações de depuração. Clique aqui para obter algumas delas. E lembre-se! Ligue as opções de depuração quando compilar o programa, a fim de poder posteriormente depurá-lo.

------------------------------------------------------------------------

1.5. Instalação de novos programas

Instalar novos programas no seu ambiente Linux é uma tarefa simples, principalmente se você tiver a sua disposição um dos gerenciadores de pacotes como o RPM ou o DPKG.


1.5.1. RPM

Se você usa a distribuição da Red Hat ou alguma outra que dê suporte ao RPM, eis aqui algumas das funções mais comuns:

rpm <parâmetros> <nome do pacote>

-i : instalação básica

- U : atualização de um programa

-- nodeps : não procura por dependências

-- help : lista opções

- q : (do inglês, query) mostra informações sobre o pacote

- e : exclui um pacote

Para verificar se você tem instalado o pacote gtk voltado para desenvolvedores, por exemplo, digite:

$ rpm -q gtk+-devel

seguido da tecla tab e enter.

Caso não possua, baixe o arquivo clicando aqui e, no diretório adequado, digite na linha de comando:

$ rpm -ivh gtk+-devel

seguido da tecla tab e enter.


1.5.2. DPKG

Usado para manusear pacotes da Debian.

dpkg <parâmetros> <nome do pacote>

-i : instalar

-r : remover


1.5.3. Arquivos .tar.gz ou .tgz

Digitando, na linha de comando, no diretório adequado

tar -xzvg nome_do_arquivo

o arquivo será descompactado. Provavelmente você encontrará um arquivo chamado README ou INSTALL. Leia-o e siga as instruções recomendadas. Caso não exista este arquivo, tente digitar simplesmente

$ ./configure

$ make

no prompt do shell, para compilar, e depois

$ make install

para instalar (normalmente como root). 2

------------------------------------------------------------------------

1.6. Roteiro

Finalmente, apresentamos aqui um roteiro para você dar os primeiros passo com o GTK.

a. Instalar o Linux.

b. a partir do shell inicializar uma seção do X (digitando startx, kde, ou o nome de algum outro gerenciador de janelas que esteja instalado e lhe agrade).

c. instalar o GTK. Se preferir, instale o Gimp (no Red-Hat, basta executá-lo pela primeira vez, clicando no seu ícone), que automaticamente o GTK será instalado.

d. abrir uma janela do xterm (shell) ou, alternativamente, efetuar login num outro console virtual.

e. usar esse console virtual ou o xterm para inicializar um editor de textos e digitar o código fonte de seu programa.

f. compilar o programa, usando o gcc ou o make.

g. executá-lo, no sistema de janelas X, digitando o nome do programa criado, numa janela do xterm. Não se esqueça da observação importante!

------------------------------------------------------------------------

Bibliografia desta seção

  1. Matt Welsh & Lar Kauffman, Dominando o Linux, O'Reilly & Associates , Inc.
  2. Apostila de Linux Básico do Linux Club.
  3. Slackware Linux, Third Edition. SAMS Publishing.
  4. Dicionário de Informática, Editora Campus.
  5. Robert W. Scheifler & James Gettys, X Window System; este livro foi escrito pelos autores do X Window System.
  6. Revista do Linux, número 2; revista editada de dois em dois meses pela Conectiva. A partir da edição de número dois, iniciou-se uma série de artigos sobre o GTK+.