Baixe Curso básico de Linux e outras Notas de estudo em PDF para Informática, somente na Docsity!
Índice
1- Introdução................................................................... ....................................
2- Histórico do Linux........................................................................... ................
3- Gerência de Processos.................................................................... .................
Considerações Iniciais.................................................................. ...........
Inicialização (“boot” do sistema).................................................
Gerência do Processo pelo kernel............................................................
Criando e Destruindo um Processo.........................................................
Executando Processos.............................................................. ..............
4- Gerência de Memória...................................................................... .................
Gerenciamento de Memória do Linux.....................................................
Memória Física.................................................................... ...................
Distribuição da Memória do Processo Usuário........................................
Inicialização da Memória................................................................ ........
Adquirindo e Liberando Memória...........................................................
Paginação (Paging)................................................................ .................
Gerenciamento de Memória Cache..........................................................
Arquitetura de Memória Cache do Linux (Linux Flush Architecture) ................................................ ..............................
Implementação de Memória Cache..............................................
Arquitetura Baseada no SMP.......................................................
4.7.3.1- Arquitetura Baseada no contexto MMU/CACHE......
Conteúdo de uma Arquitetura Virtual..........................................
Índice
Implicações Referentes a Arquitetura..........................................
4.7.5.1- Arquitetura baseado no contexto SMP......................
4.7.5.2- Arquitetura baseado no contexto MMU/CACHE.......
Como tratar o que a Arquitetura flush não executa com exemplos....................................................... ..............................
Questões Abertas na Arquitetura Cache.......................................
5- Sistema de Arquivos do Linux (File System)....................................................
Conceitos Fundamentais........................................................ .................
Arquivos........................................................ .............................
Diretórios...................................................... ..............................
Conta............................................................ ..............................
Tipo de Arquivos........................................................ .................
Acesso a Arquivos........................................................ ...............
Atributos dos Arquivos........................................................ ........
Operações sobre Arquivos............................................................... .......
Arquivos Compartilhados.....................................................
Subdiretório / sbin.................................................. ....
Arquivos e/ou Comandos disponíveis em / sbin................................... ...........
Arquivos e/ou Comandos opcionais em / sbin................................... ...........
Subdiretório / tmp.................................................. ....
A hierárquia / usr.................................................... ...
Subdiretório /usr (permanente)...........
Subdiretório /usr/ x386........................
Subdiretório /usr/ bin...........................
Subdiretório /usr/ dict..........................
Subdiretório /usr/ etc...........................
Subdiretório /usr/ include.....................
Subdiretório /usr/ lib............................
Índice
Subdiretório /usr/ local........................
Subdiretório /usr/ man.........................
Subdiretório /usr/ bin...........................
Subdiretório /usr/ share.......................
Subdiretório /usr/ src...........................
A hierárquia / var.................................................... ...
Subdiretório /var/ adm.........................
Subdiretório /var/ catman.....................
Subdiretório /var/ lib............................
Subdiretório /var/ local........................
Subdiretório /var/ ock.........................
Subdiretório /var/ og............................
Subdiretório /var/ name.......................
Subdiretório /var/ nis...........................
Subdiretório /var/ preview...................
Subdiretório /var/ run..........................
Subdiretório /var/ spool.......................
Subdiretório /var/ tmp..........................
Alguns Dilemas sobre o Sistema de Arquivos...............................
Descrição sucinta do conteúdo dos manuais.................................
6- Pontos Positivos e Negativos.................................................................... .......
7- Conclusão.................................................................... ....................................
Índice
9- Apêndices................................................................... .....................................
A- Comandos Básicos do Sistema Unix........................................................
B- Perguntas mais Frequentes (FAQs) colocadas na Linux-BR.....................
C- Copyrights Linux e Esquema de numeração versão Linux.......................
D- Contrato de Licença................................................................. ...............
1 - Introdução
O Linux é um clone UNIX de distribuição livre para PCs baseados em processadores 386/486/Pentium. O Linux é uma implementação independente da especificação POSIX, com a qual todas as versões do UNIX padrão (true UNIX) estão convencionadas. O Linux foi primeiramente desenvolvido para PCs baseados em 386/486/Pentium, mas atualmente também roda em computadores Alpha da DEC, Sparcs da SUN, máquinas M (semelhantes a Atari e Amiga), MIPS e PowerPCs. O Linux foi escrito inteiramente do nada, não há código proprietário em seu interior. O Linux está disponível na forma de código objeto, bem como em código fonte. O Linux pode ser livremente distribuído nos termos da GNU General Public License (veja apêndice). O Linux possui todos as características que você pode esperar de um UNIX moderno, incluindo:
Multitarefa real Memória virtual Biblioteca compartilhada "Demand loading" Gerenciamento de memória próprio Executáveis "copy-on-write" compartilhados Rede TCP/IP (incluindo SLIP/PPP/ISDN) X Windows
A maioria dos programas rodando em Linux são freeware genéricos para UNIX, muitos provenientes do projeto GNU. Muitas pessoas tem executado benchmarks em sistemas Linux rodando em 80486, e tem achado o Linux comparável com workstations médias da Sun e da Digital. O Linux está disponível através da Internet por meio de centenas de sites FTP. O Linux está sendo usado hoje em dia por centenas e centenas de pessoas pelo mundo. Está sendo usado para desenvolvimento de softwares, networking (intra-office e Internet), e como plataforma de usuário final. O Linux tem se tornado uma alternativa efetiva de custo em relação aos caros sistemas UNIX existentes. Um exemplo de pacote de distrribuição do Linux mais populares é distribuido pela InfoMagic (http://www.infomagic.com, e-mail [email protected]), a versão LINUX Developer’s Resource CD-ROM, de dezembro de 1996, contém 6 CD-ROMs, seu conteúdo sucinto é :
Versão Red Hat 4.0 (instalando kernel 2.0.18)
Versão Slackware 3.1 (Slackware 96 - instalando kernel 2.0) Versão Debian GNU/Linux 1. X-Windows - Xfree86 version 3. Arquivos Linux de tsx-11.mit.edu e sunsite.unc.edu Arquivos GNU de prep.ai.mit.edu Documnetação completa on-line & HOWTO’s (Guia de Instalação e Guia do Administrador da Rede, em inglês) Softwares demostração comerciais como : BRU, dbMan, StarOffice, Cockpit, Flagship, Smartware, GP Modula-2, Pathfinder, Scriptum, etc.
ftp://ftp.cs.Helsinki.FI/pub/Software/Linux/Kernel/v2.0/
ftp://ftp.cs.Helsinki.FI/pub/Software/Linux/Kernel/v2.1/
- Data: Thu Mar 2 07:47:10 UTC
- Release v1.
- 1.2.
- Data: Wed Aug 2 12:54:12 UTC
- Release v1.
- pre2.0.
- Data: Thu Jun 6 19:30:56 UTC
- Release v2.
- 2.0.
- Data: Tue Jan 14 12:33:26 UTC
- Release v2. linux-2.0.28.tar.gz
- 2.1.
- Data: Sun Jan 26 14:12:18 UTC
3 - Gerência de Processos
3.1 - Considerações Iniciais
Para explicarmos como o Linux gerência processos, faremos considerações iniciais sobre o código fonte do kernel do Linux (onde encontramos a implementação da Gerência de Processos) e a inicialização “boot” do sistema. Neste tópico tentaremos explicar, de uma maneira ordenada o código fonte do Linux, tentando conseguir um bom entendimento sobre como o código fonte está situado e como as características mais relevantes do UNIX foram implementadas. O objetivo é ajuda- lo a se familiarizar com o projeto geral do Linux. Então, vamos começar por onde o Linux começa: seu sistema de boot. Um bom entendimento da linguagem C é necessário para entender este material, assim como familiaridade com conceitos de UNIX e arquitetura dos PCs. Porém, nenhum código C aparecerá neste material, mas referencias de onde podem ser encontrados. Qualquer referencia "pathname" à arquivos tem como ponto de partida a arvore principal de fontes, usualmente /usr/src/linux. A maioria das informações reportadas aqui tem como referencia o código fonte do Linux versão 1.0. Referencias a versões posteriores conterão o símbolo novo. Caso o símbolo não estiver presente, significa que não houveram modificações após as versões 1.0.9-1.1.76. mais Ocasionalmente um parágrafo como este ocorrerá no texto. Indicando onde poderam ser obtidas mais informações sobre o assunto corrente (geralmente o código fonte).
3.1.1 - Inicialização ("boot" do sistema)
Quando o PC é ligado, o processador 80x86 encontra-se em modo real e executa o código contido no endereço 0xFFFF0, que corresponde a um endereço ROM-BIOS. O BIOS do PC realiza alguns testes no sistema e inicializa o vetor de interrupções no endereço físico 0. Depois disto ele carrega o primeiro setor do device bootavel em 0x7C00, e passa a execução para este endereço. O device é, usualmente, o disquete ou o disco rígido. A descrição anterior é um tanto simplificada, mas é tudo que se necessita para entender o trabalho inicial do kernel. A primeiríssima parte do kernel Linux está escrito em linguagem assembly 8086 (boot/bootsect.S). Quando é executado, ele se move para o endereço absoluto 0x90000, carrega os próximos 2 kBytes de código do device de boot até o endereço 0x90200, e o resto do kernel para o endereço 0x10000. A mensagem "Loading..." é apresentada durante o carregamento do
chamado idle task (tarefa preguiçosa), se mantém rodando em um loop infinito. O processo de inicialização tenta executar /etc/init, ou /bin/ init, ou /sbin/init. Se nenhum deles tem sucesso, o código se desvia para "/bin/ sh /etc/rc" e cria um root shell no primeiro terminal (console). Este código é remanescente do Linux 0.01, quando o S.O. era feito para um kernel stand-alone, e não havia processo de login. Depois de exec() o programa de inicialização de um dos lugares padrão (deve haver um deles), o kernel não tem controle direto sobre o fluxo do programa. Sua função, de agora em diante, é prover processos através de chamadas ao sistema (system calls), assim como prover eventos para serviços assíncronos (como uma interrupção do hardware). A multitarefa está inicializada, e inicializará o gerenciamento de acesso a multiusuários, através do fork() e processos de login. Estando o kernel carregado e provendo serviço, vamos prosseguir dando uma olhada nesses serviços ("system calls").
3.2 - Gerência de processo pelo kernel
Do ponto de vista do kernel, um processo é uma entrada na tabela de processos. Nada mais. A tabela de processos, então, é uma das mais importantes estruturas de dados no sistema, conjuntamente com a tabela de gerenciamento de memória e o buffer cache. O item individual na tabela de processos é a estrutura task_struct, definida em include/ linux/sched.h. Com a task_struct, tanto informações de baixo quanto de alto nível, são mantidas – variando da cópia de alguns registradores de hardware até o inode do diretório de trabalho para o processo. A tabela de processos é tanto um array quanto uma lista duplamente ligada, como uma árvore. A implementação física é um array estático de ponteiros, cujo tamanho é NR_TASKS, uma constante definida em include/linux/tasks.h, e cada estrutura reside em uma pagina de memória reservada. A estrutura da lista está entre os ponteiros next_task e prev_task, a estrutura em arvore é um tanto complexa, e não será descrita aqui. Voce pode desejar mudar NR_TASKS do seu valor default (que é 128), mas esteja certo de que há dependências, e será necessário recompilar todos os arquivos fonte envolvidos. Depois do boot, o kernel está sempre trabalhando em um dos processos, e a variável global "current", um ponteiro para um item da task_struct, é usado para guardar o processo que está rodando. A variável "current" só é mudada pelo scheduler, em kernel/sched.c. Quando, porém, todos os processos necessitarem estar looked, a macro for_each_task é usada. Isto é consideravelmente mais rápido que uma procura seqüencial no array.
Um processo está sempre rodando em ou em "modo usuário" ou em "modo kernel". O corpo principal de um programa de usuário é executado em modo usuário e chamadas a sistema são executados em modo kernel. A pilha usada pelos processos netes dois modos de execução são diferentes – um seguimento de pilha convencional é usado para o modo usuário, enquanto uma pilha de tamanho fixo (uma página, cujo processo é dono) é usada no modo kernel. A página de pilha para o modo kernel nunca é swapped out, porque ela pode estar disponível sempre que um system call é introduzido. Chamadas a sistema (System calls), no kernel do Linux, são como funções da linguagem C, seu nome "oficial" esta prefixado por "sys_". Uma chamada a sistema de nome, por exemplo, burnout invoca a função de kernel sys_burnout().
mais O mecanismo de chamadas a sistema (System calls) está descrito no capítulo 3 do Linux Kernel Hackers' Guide (http:// www.redhat.com:8080/HyperNews/get/khg.html). Uma olhada em for_each_task e SET_LINKS, em include/linux/sched.h pode ajudar a entender a lista e a estrutura de árvore da tabela de processos.
e o outro para carregar a "library" associada, cada formato binário deve conter, portanto, o executável e sua "library". O sistema UNIX prove, ao programador, seis formas para a função exec(). Quase todos podem ser implementados como uma "library" de funções, e o kernel do Linux implementa sys_execve() independentemente das providas pelo UNIX. Ele executa uma única tarefa: carregar o cabeçalho do executável, e tenta executa-lo. Se os dois primeiros bytes são "#!", então a primeira linha é ignorada e um interpretador é invocado, caso contrário o formato binário, registrado, é executado seqüencialmente. O formato nativo do Linux é suportado diretamente por fs/ exec.c, e as funções relevantes são load_aout_binary e load_aout_library. Assim como para os binários a função de carregamento "a.out" é invocada, e a função mmap() (memory map
- memória virtual ) aloca espaço em disco (no caso da memória real estar cheia) para o processo, ou invoca read_exec(), caso haja espaço em memória. "The former way uses the Linux demand loading mechanism to fault-in program pages when they're accessed, while the latter way is used when memory mapping is not supported by the host filesystem (for example the "msdos" filesystem)".
novo A partir da versão 1.1 do kernel, o Linux embutiu um sistema de arquivos (filesystem) revisado do msdos, que suporta mmap() (memory map - memória virtual). Além disso a estrutura linux_binfmt é uma "lista ligada" e não um array, para permitir carregar um novo formato binário como um módulo do kernel. Finalmente a estrutura, por si mesma, foi estendida para acessar rotinas com o formato relativo à core-dump.
4 - Gerência de Memória
4.1 - Gerenciamento de Memória do Linux (LMM)
A execução do LMM (Linux Memory Manager) exige uma estratégia de paginação com uma copy-on-write confiando nas 386 páginas auxiliares. Um processo alcança suas tabelas de páginas de seu parent (durante um fork ) com as entradas marcadas como read-only ou trocado. Então, se o processo tenta escrever para este espaço de memória e a página é uma copy on write page, isto é copiado e a página marcada read-write. Um exec ( ) resulta na leitura de uma página ou mais do executável. O processo então erra em qualquer outra página que precisar. Cada processo tem uma tabela de página que significa que pode acessar 1 Kb de tabela de página indicando para 1 Kb de 4 Kb, páginas que é 4 Gb de mémoria. Um diretório de página do processo é iniciado durante um Fork por copy-page-tables. O processo inativo tem seu diretório de página inicializado durante a sequência de inicialização. Cada processo usuário tem uma tabela descritória local que contém um código de segmento e um segmento de dados. Estes segmentos usuários extendem de 0 para 3 Gb (0 X c 0000000). Nos espaços usuários, endereços lineares e endereços lógicos são idênticos. No 80386, endereços lineares vão de 0 Gb para 4 Gb. Um endereço linear indica uma posição particular de memória dentro deste espaço. Um endereço linear não é um endereço físico --- isto é um endereço virtual. Um endereço lógico consiste de um seletor e um offset. O seletor indica para um segmento e o offset diz que distância na seção o endereço é localizado. O código Kernel e o segmento de dados são seções privilegiados definidos na tabela descritora global e extende de 3Gb para 4Gb. O Swapper - page - dir é organizado para que estes endereços lógicos e físicos sejam idênticos no espaço Kernel. O espaço 3Gb acima aparece no process page directory como indicadores para tabelas de páginas Kernel. Este espaço é invisível para o processo no user mode, mas o modo privilegiado é acionado, por exemplo, para sustentar um sistema de ligação. O modo surpevisor é inserido dentro do contexto do processo atual então a tradução do endereço ocorre com respeito ao diretório de página do processo, mas usando segmentos Kernel. Isto é idêntico no mapeamento produzido com o uso de swapper - pg - dir e segmentos Kernel como ambos diretórios de páginas usa a mesma tabela de página neste espaço. Apenas task [0] (A tarefa inativa, ás vezes chamada de "tarefa trocadora" por razões históricas, mesmo assim isto não tem relação com trocas nos implementos Linux) usa o swapper - pg - dir diretamente.
Uma visão de memória do user process. O código de segmento e dados do segmento extendem todo o caminho de 0 X 00 para 3 Gb. Correntemente o page fault handler do wp_page confere para assegurar que um processo não escreve para seu código de espaço. De qualquer modo, pegando o sinal segu, é possível escrever para o code space, causando ocorrência de um copy - on - write. O Handler do_no_page assegura que qualquer página nova que o processo adquira pertença ao executável, uma biblioteca dividida, ao stack, ou dentro do valor do brK. Um usuário de processo pode reordenar seu valor brK chamando sbrK ( ). Isto é o que malloc ( ) faz quando precisa. O texto e a porção de dados são distribuídos em páginas separadas ao menos que alguém escolha o N opção composta. A biblioteca dividida carrega endereços são correntemente tornadas da imagem dividida por ele mesmo. O endereço é entre 1.5 Gb e 3 Gb, exceto em casos especiais.
4.3 - Distribuição da memória do processo usuário
O Stack, shlibs e os dados são muito afastados um do outro para serem spanned por uma tabela de página. Todas KPT são divididas por todos processo e deste modo eles não estão na lista. Apenas páginas sujas são trocadas. Páginas limpas são roubadas e deste modo o processo pode tê-los de volta para o executável se for desejado. A maioria das vezes apenas as páginas limpas são divididas. Uma página suja termina dividida sobre um fork até que parent ou child escolham para escrever isto de novo. Administração dos dados da memória na tabela do processo. Aqui está um sumário de algum dos dados mantidos na tabela do processo que é usado para administração da memória. Limites do processo da memória. Ulong - start_code - and_code - and_data - brk, atart - stock
Erro de contagem de página.
Tabela do descritor local.
Sturct desc - sturct ldt {32} é a mesa descritora local para tarefa.
Números de páginas residentes.
Swappable - trocáveis
Se então as páginas do processo não serão trocados.
Kernel Stack page
Indicador para a página distribuída no fork.
Saved - Kernel - Stack
V86 modo material (stuff)
stract tss
pilha de segmentos (stack segments)
indicador da pilha Kernel
Kernel stack pointer
segmento da pilha Kernel
Kernel stack segment (0X10)
ssi = esp 2 = ss2 = 0
Níveis de previlégio não usados.
Segmentos seletores. Ds=es=fs=gs=ss=ok17,cs—
Todos indicam para segmentos no corrente 1 dt [ ] c r 3 : indicam para o page directory para este processo 1 dt - LDT (n) seletores para tarefas correntes do LDT
