Você está na página 1de 7

Gerenciamento de Memória Linux

Anike Schnorr Moraes, Dárlia Nunes


Universidade Católica de Pelotas
any@atlas.ucpel.tche.br, darlia@atlas.ucpel.tche.br

Estes segmentos usuários extendem de 0 para 3


Resumo 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
O Gerenciamento de memória é uma das partes Gb para 4 Gb. Um endereço linear indica uma
mais importantes de um sistema operacional. É posição particular de memória dentro deste
tarefa dele prover mecanismos que irão permitir espaço. Um endereço linear não é um endereço
que a memória do sistema possa ser utilizada da físico --- isto é um endereço virtual. Um endereço
melhor maneira possível.aaaaaaaaaaaaaaaaaaa. lógico consiste de um seletor e um offset. O
Desde o surgimento da computação sempre houve seletor indica para um segmento e o offset diz que
a necessidade de se ter mais memória do que distância na seção o endereço é localizado.O
realmente existia no sistema e para isso foram código Kernel e o segmento de dados são seções
desenvolvidas técnicas para se conseguir, por privilegiados definidos na tabela descritora global
exemplo, rodar um programa maior que o espaço e extende de 3Gb para 4Gb. O Swapper - page -
de memória física existente no sistema. Essa dir é organizado para que estes endereços lógicos
técnica é conhecida como Memória Virtual, e é e físicos sejam idênticos no espaço Kernel.O
utilizada hoje no Linux e também na maioria dos espaço 3Gb acima aparece no process page
sistemas operacionais. 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
1 . Introdução de ligação. O modo surpevisor é inserido dentro
do contexto do processo atual então a tradução do
A execução do LMM (Linux Memory Manager) endereço ocorre com respeito ao diretório de
exige uma estratégia de paginação com uma copy- página do processo, mas usando segmentos
on-write confiando nas 386 páginas auxiliares. Kernel. Isto é idêntico no mapeamento produzido
Um processo alcança suas tabelas de páginas de com o uso de swapper - pg - dir e segmentos
seu parent (durante um fork ) com as entradas Kernel como ambos diretórios de páginas usa a
marcadas como read-only ou trocado. Então, se o mesma tabela de página neste espaço. Apenas task
processo tenta escrever para este espaço de [0] (A tarefa inativa, ás vezes chamada de "tarefa
memória e a página é uma copy on write page, trocadora" por razões históricas, mesmo assim isto
isto é copiado e a página marcada read-write. Um não tem relação com trocas nos implementos
exec ( ) resulta na leitura de uma página ou mais Linux) usa o swapper - pg - dir diretamente.
do executável. O processo então erra em qualquer
outra página que precisar.Cada processo tem uma · O segmento base do processo usuário = o X 00,
tabela de página que significa que pode acessar 1 page - dir particular, para o processo.· O processo
Kb de tabela de página indicando para 1 Kb de 4 usuário faz um sistema de ligação : segment base
Kb, páginas que é 4 Gb de mémoria. Um diretório = 0 X c 0000000 page - dir = mesmo usuário page
de página do processo é iniciado durante um Fork dir.· swapper - pg - dir contém um mapeamento
por copy-page-tables. O processo inativo tem seu para todas as páginas físicas de 0 X 0000000 para
diretório de página inicializado durante a 0 X c 0000000 + and_mem, então as primeiras
sequência de inicialização . Cada processo usuário 768 entradas em swapper - pg - dir são 0's, e então
tem uma tabela descritória local que contém um há 4 ou mais que indicam na tabela de páginas
código de segmento e um segmento de dados. Kernel.· O user page directories têm as mesmas
entradas como swapper - pg - dir dos 768 acima. ao stack, ou dentro do valor do brK.Um usuário de
As primeiras 768 entradas mapeam o espaço processo pode reordenar seu valor brK chamando
usuário.A vantagem é que sempre que o endereço sbrK ( ). Isto é o que malloc ( ) faz quando
linear é acima de 0 X c 0000000 tudo usa a precisa. O texto e a porção de dados são
mesma tabela de páginas Kernel (Kernel page distribuídos em páginas separadas ao menos que
Tables).O monte usuário permanece no topo do alguém escolha o N opção composta. A biblioteca
segmento de dados do usuário e desce. O Kernel dividida carrega endereços são correntemente
Stack não é uma bonita estrutura ou segmento de tornadas da imagem dividida por ele mesmo.O
dados que eu possa apontar com um "aqui é um endereço é entre 1.5 Gb e 3 Gb, exceto em casos
Kernel Stack". Um Kernel Stack_frame (uma especiais
página) é associada com cada novo processo
criado e é usado sempre que o Kernel opera dentro 3. Distribuição da memória do processo
do contexto deste processo. Coisas ruins usuário.
aconteceriam se Kernel Stack descesse abaixo de
seu corrente stack frame. [ Onde o Kernel Stack é O Stack, shlibs e os dados são muito afastados um
guardado? Eu sei que há um para cada processo, do outro para serem spanned por uma tabela de
mas onde isto é armazenado quando isto não está página. Todas KPT são divididas por todos
sendo usado? Páginas usuários podem ser processo e deste modo eles não estão na lista.
roubados ou trocados - Um user page é um que é Apenas páginas sujas são trocadas. Páginas limpas
mapeado abaixo de 3 Gb em uma tabela de são roubadas e deste modo o processo pode tê-los
páginas usuários. Esta região não contém page de volta para o executável se for desejado. A
directories ou page tables. Apenas páginas sujas maioria das vezes apenas as páginas limpas são
são trocadas.Menores alterações são necessárias divididas. Uma página suja termina dividida sobre
em alguns lugares ( testes para limites de memória um fork até que parent ou child escolha para
vem para a mente) para prover suporte para escrever isto de novo.
definidos segmentos programados. [ Há agora
uma modificação - |c| + O sistema de ligação 4. Administração dos dados da memória
usado por dosane, Wine, Twin, and Wabi para na tabela do processo.
criar segmentos arbitrários. ]
Aqui está um sumário de algum dos dados
2. Memória Física mantidos na tabela do processo que é usado para
administração da memória.Limites do processo da
Aqui está um mapa de memória física antes que memória.Ulong - start_code - and_code -
qualquer processo de usuário for executado. A and_data - brk, atart - stock Erro de contagem de
coluna da esquerda mostra o endereço de partida página. Níveis de previlégios não usados.
do item e os números em negrito são Segmentos seletores. Ds=es=fs=gs=ss=ok17,cs—
aproximados.A coluna do meio mostra os nomes Todos indicam para segmentos no corrente 1 dt [ ]
dos itens. A grande coluna da direita mostra a c r 3 : indicam para o page directory para este
rotina relevante ou o nome variável ou processo1 dt - LDT (n) seletores para tarefas
explicações para ingresso. Projeto - Inits que correntes do LDT
adquirem memória são (principais.c) profil -
buffer, com, init, psaux, init, rd, , init, scsi.dev - 5.Inicialização da memória
init.Note que toda memória não marcada como
livre é reservada (mem-init). Páginas reservadas No Start Kernel (main.c) há 3 variáveis relatadas
pertencem ao Kernel e nunca estão livres ou para inicialização da memória: memory_start
trocadas.Uma visão de memória do user process.O começa a 1 Mb atualizado pelo projeto de
código de segmento e dados do segmento inicialização. memory_end término da memória
extendem todo o caminho de 0 X 00 para 3 Gb. física: 8 Mb, 16 Mb, ou qualquer outro.Low
Correntemente o page fault handler do wp_page memory_start término do código Kernel e dados
confere para assegurar que um processo não que é carregado inicialmenteCada projeto init
escreve para seu código de espaço.De qualquer tipicamente torna memory_start e retorna um
modo, pegando o sinal segu, é possível escrever valor atualizado, se distribui espaços no
para o code space, causando ocorrência de um memory_start (simplesmente pegando-a). Paging
copy - on - write. O Handler do_no_page assegura init ( ) inicializa a page-tables no { \ tt swapper -
que qualquer página nova que o processo adquira pg - dir} ( começando a 0 X 0000000) para cobrir
pertença ao executável, uma biblioteca dividida, toda a memória física do memory_start para
memory_end. Na verdade o primeiro 4 Mb é feito stack e páginas de dados serão copiados quando o
no startup_32 (heads).memory_start é parent ou child escreve para eles ( copy-on-write).
incrementado se quaisquer nova page-tables são
adicionados.A primeira página é zerada para 6.2 Memória relacionada trabalho feito
bloquear os indicadores das referências do alçapão por exec ( ):
nulo no Kernel.No sched_init ( ) o 1 dt e tss
descritores para tarefa [0] são postos no GDT, e Distribuição de memória,· 1 página para exec
carregado para dentro do TR e LDTR (a única vez header para omagic,· 1 página ou mais para stack
que isto é feito explicitamente). Um trap gate (max_arg_pages),· clear-página-tables ( ) usado
(0X80) é ordenado para system-call.( ).A bandeira para remover páginas velhas,· change 1 dt ( ) põe
tarefa aninhada é desligada na preparação para os descritores no novo 1 dt [ ],· 1 dt [1] = código
entrada do modo usuário: O cronômetro é ligado. base = 0 x 00, limite = task – size,· 1 dt [2] = data
O task-struct para task [0] aparece por inteiro em base = 0 x 00, limite = task – size.Estes segmentos
< linux / sched.h >mem_map é então construído são dpl = 3, p=1, s=1, g=1. Tipo = a (código or 2
por mem_init ( ) para refletir o corrente uso das dados),· Eleva para MAX_ARG_PAGES páginas
páginas físicas. Este é o estado refletido no mapa sujas de arqu e enup são distribuídos e guardado
da memória física da seção anterior. Então Dinux ao topo do segmento de dados para o novo usuário
move para dentro do modo usuário com um iret pilha criado,· Ponha os indicadores de instrução
após empurrar o corrente ss, esp, etc.Claro que o do caller cip = ex.a_cutry,· Ponha o stack
segmento usuário para task [0] são mapeados bem indicador do caller para o stack criado (esp=stack
sobre os segmentos Kernel e deste modo a indicador). Estes serão eliminados do Stack
execução continua exatamente onde isto quando o caller resume.
termina.Task [0]:pg_dir = swapper - pg - dir que
sigmifica apenas endereços mapeados estão no 7. Limites de Memória Atualizados
alcance 3 Gb para 3 Gb + High memory.
Interrupções e traps são sustentadas dentro do
LTD [1] = código usuário, base = 0 x 0000000, contexto da corrente tarefa. Em particular, o
tamanho = 640 K, LDT [2] = dados usuários, base diretório de páginas do corrente processo é usado
= 0 x 0000000, tamanho = 640 k .O primeiro exec na tradução de endereços. Os segmentos, de
( ) põe a LTD entrada para task [1] para os valores qualquer modo, são segmentos Kernel para que
usuários da base = 0x0, limite = task_size = 0 x c todos os endereços lineares apontem para dentro
0000000. Depois disso, nenhum processo vê os da memória Kernel quer acessar uma variável no
segmentos Kernel enquanto no modo usuário. endereço 0 x 01. O endereço linear é 0 x
00000001 (usando segmentos Kernel) e o
6.Processos e a Administração da endereço físico é 0 x 01. O último é porque a
Memória. página do processo diretório mapea esta extensão
exatamente como page_pg_dir.O espaço Kernel (0
6.1 Memória relacionada trabalho feito x c 0000000 + high - memory) e mapeado pela
por fork ( ). tabela de páginas Kernel que são eles mesmos
parte da memória reservada. Eles são
Distribuição de memória, · 1 página para o Task- consequentemente divididas por todos processos.
struct, · 1 página para o Kernel Stack, · 1 para o Durante um fork copy-page-tables ( ) trata tabela
pg_dir e algumas para pg_tables (cópias - páginas de páginas reservadas diferentemente. Isto põe
- tabelas), · Outras mudanças,· sso põe para o indicadores no diretório de páginas de processo
segmento Kernel stack (0x10) para ter certeza?· para indicar para tabelas de página Kernel e na
espo põe para o topo da nova distribuição Kernel - verdade não distribui novas tabelas de páginas
stack - page.· c r 3 põe por copy - page - tables ( ) como isto faz normalmente. Como um exemplo o
para indicar para nova página de diretório Kernel - Stack - page ( que ocupa algum lugar no
distribuída· 1 dt = LDT (task_nr) cria novo 1 dt espaço Kernel ) não precisa de um associado page
descritor,· descritores põe no gdt para novo tss e 1 - table distribuídos no pg-dir do processo para
dt [ ],· Os registros restantes são herdados do mapeá-lo.O interruptor de instruções põe o
parent.Os processos resultam dividindo seus indicador stack e o segmento stack do privilégio
códigos e segmentos de dados (embora eles valor salvo no Tss do corrente task. Note que o
tenham tabelas descritoras locais separados, as Kernel stack é um objeto realmente fragmentado -
entradas indicam para os mesmos segmentos). O Isto não é um objeto único, mas sim um grupo de
stack frames. Cada um distribuído quando um
processo é criado e deixado quando ele sai. O Linux suporta múltiplos swap files ou projetos que
Kernel stack não deveria crescer tão rapidamente podem ser ligados ou desligados pelas ligações de
dentro de um contexto de um processo que swapoff system. Cada swap file ou projeto é
extende abaixo da corrente frame. descrito por uma strut-swap-info.O campo das
bandeiras (SWP-USED ou SWP-WRITE ok) é
8. Adquirindo e liberando memórias usado para controlar acesso para o swap files.
Quando SWP- WRITE ok é desligado, o espaço
Quando qualquer rotina Kernel precisa de não vai ser distribuído neste arquivo. Isto é usado
memória isto acaba chamando get-free-page ( ). por Swapoff quando isto tenta de não usar um
Este está num nível mais baixo do que Kmallor ( ) arquivo. Quando swapoff adiciona um arquivo de
(de fato Kmalloc ( ) get-free-page ( ) quando isto troca nova isto aplica SWP-USED. Um variável
precisa mais memória).Get-free-page ( ) toma um imóvel no Swap files armazena o número dos
parâmetro, a prioridade.Possíveis valores são arquivos ativos correntemente ativos. Os campos
gfp_buffer_gfp, Kernel, gfp,nfs e gfp atomic. Isto lowest - bit e hihgest - bit limitam a região livre na
tira uma página do the free-page-list, atualizados pasta de troca e são usadas para adiantar a procura
mem_map, zeram a página e retorna o endereço por espaço de troca livre.O programa do usuário
físico da página (note que Kmalloc) retorna um m | < swap inicializa um swap device ou file. A
endereço físico. A lógica do mm depende do mapa primeira página contém uma assinatura (swap-
da identidade entre o endereço lógico e físico.Isto space) nos últimos 10 bytes, e contém um mapa
é por ele mesmo bastante simples. O problema é de bit. Inicialmente 1's no bitmap significam
claro, é que o free-page-list pode estar vazio. Se páginas ruins A'1' no bitmap significa que a
você não requisitar uma operação atômica, nesta página correspondente é livre. Esta página nunca é
etapa, você entra dentro do domínio de uma page distribuída deste modo a inicialização precisa ser
stealing e que nós discutiremos em um momento. feita somente uma vez.The Syscall Swapor ( ) é
Como um último recurso ( e para requisitos chamado pelo user program swapon tipicamente
atômicos) uma página é separada do secundary- de / etc / rc. Algumas páginas da memória são
page-list (como você pode ter achado, quando distribuídas por swap-map e swap-lockmap, swap-
páginas são libertadas, o secundary-page-list map contém um byte para cada página no
enche primeiro a manipulação atual da page-list e swapfile. Isto é inicializado do bitmap para conter
mem-map ocorre neste misterioso macro chamado 0 para páginas disponíveis e 128 para páginas que
remove-from-mem-queve ( ) que você não pode ser usadas. Isto é para manter uma conta
provavelmente nunca quer investigar. O suficiente das petições da troca em cada página no swap file.
para dizer que interrupções são incapacitados. [Eu Swap-lockmap contém um bit para cada página
penso que isto deveria ser explicado aqui. Isto não que é usada para assegurar exclusão mútua
é tão difícil.Agora de volta ao "Roubando quando lendo ou escrevendo swap-files.Quando
páginas" get-free-page ( ) chame try-to-fre-page ( uma página da memória está para ser trocada, um
) que chame repetidamente shrink_buffers ( ) e índice para posição da troca é obtido com uma
swap-out ( ) nesta ordem até conseguir liberar chamada para get-swap-page ( ). Este índice é
uma página. A prioridade é aumentada em cada deste modo guardado em bits 1-31 da page table
iteration sucessiva para que estas duas rotinas entry para que a página trocada possa ser
processem suas page-sterling-loops mais localizada pela page fault handles, do-no-page ( )
frequentemente.. quando necessário.Os 7 bits mais altos do índice
dão o swap file ( ou projeto) e os 24 bits mais
9. Paginando (Paging) baixos dão o número da página neste projeto. Isto
faz até 128 swap files, cada um com espaço para
Paginando é a troca numa base da página melhor mais ou menos 64 Gb, mas o espaço em cima
do que os processos inteiros. Nós vamos usar devido o swap map seria grande. Ao invés o
trocando aqui para referir à "paginando" , uma vez tamanho do swap file é limitado para 16 Mb,
que apenas Linux página, e não trocar, e pessoas porque o swap map então toma 1 página. A
são mais acostumadas à palavra "Swap" / "trocar" função swap-duplicate ( ) é usado por copy-page-
do que "page" / "paginar". Kernel pages nunca são tables ( ) para deixar o processo da child herdar
trocadas páginas limpas também não são escritas páginas trocadas durante um fork. Isto somente
para trocar. Elas são liberadas e recarregadas incrementa a conta mantendo no Swap-map para
quando é requerida. O trocador mantém um único aquela página. Cada processo vai trocar numa
bit de informação de envelhecimento nas Páginas cópia da página separa quando acessá-la. Swap-
acessadas bit da page table cutries . free diminui a conta mantendo no swap-map.
Quando a conta abaixa para 0 a página pode ser subjacente, o fio controle de usuário vai ser o
redistribuída por get-swap-page ( ). Isto é dado correto antes que é permitido continuar a
chamado cada vez que uma página trocada é lida execução, indiferente da cache architecture e/ou a
na memória ( swap-inc ) ou quando uma página semântica.Em geral, quando o estado do espaço de
está para ser descartada ( free-one-table ( ), etc ). endereço é mudado somente (em código genérico
da administração da memória kernelnome de
10.Gerenciamento de Memória Cache generic kernel management cade) o fluch
architecture hook apropriado vai ser chamado
Arquitetura de Memória Cache do Linux (Linux descrevendo que o estado muda totalmente.Sobre
Flush Architecture) O TBL é mais uma entidade o que o flush architecture não importa: que o
virtual do que um modelo estrito quanto a Linux mapeamento do DMA "DMA/driver coerência.
flush architecture e concernida. As características Isto inclui DMA mappings (no sentido do MMU
únicas são isto mantém em ordem o mapeamento mappings) e o cache/DMA dado consistência.
do processo kernel de algum modo, queira Estes tipos des assuntos não devem esta no flush
software ou hardware.Código específico de architecture, veja embaixo como eles devem ser
arquitetura pode precisar ser modificado quando o manuseados. Split Instrution/data cache
kernel tiver mudado um processo/mapeamento consistência com respeito as modificações feito
kernel.O shell (um lugar seguro p/ guardar para processo de instrução de espaço realizado
dinheiro ou coisas) esta entidade é essencialmente pelo código de sinal de despacho signal dispatch
"memory state"/"estado da memoria" como o cade.
flush architecture o vê. Em geral isto tem as
propiedades seguintes:· Isto sempre vai segurar 10.1 Implementação da Memória Cache
cópias de dados que podem ser visto como
atualizado pelo processo local;· O funcionamento Uma implementação deve, eliminar todos os
próprio pode ser relacionado ao TLB e o entradas do cache que são válidas neste momento
mapeamento do processo/Kernel page de algum quando flush-cache-all é invocado isto refere-se
jeito, isto é para dizer que eles podem depender ao virtual cache architecture, se a cache is write-
um do outro;· Isto pode, numa configuração back, essa rotina vai submeter o dado da cache
cached virtual, causar problemas "aliasing" se para memoria antes do que invalidar cada
uma página física é mapeada no mesmo tempo da ingresso. Para caches físicos, não é necessário
que duas páginas virtuais e por causa dos bits de realizar uma ação já que mapeamento físico não
um endereço usado para catalogar a linha cache, a tem ponto de apoio no address space translations.
mesma porção do dedo pode acabar residindo no Para flush-tlb-all todos TLB mappings para o
cache duas vezes, deixando resultados kernel address space devem ser feito consitente
incompatíveis;· Projetos e DMA podem ou não ter com os OS page tables de qualquer maneira. Norte
capacidade para ver a cópia de um dedo mais que com um arquitetura que possua a nação· Para
atualizado que resida no cache do processo local;· flush-tlb-mm, o tlb/mmu hardware é para estar
Corretamente, é suposto que a coerência num localizado num estado onde isto vai ver (agora
ambiente multiprocessador é mantida pelo corrente) kernal page table entradas para o espaço
subsistema cache/memória. Isto que dizer que, de endereço pelo mm-
quando um processador requerer um dado no strust.flush_cache_range(struct mm_struct *mm,
memory bus de maneira e um outro processador unsigned long start,unsigned long end);
tem uma cópia mais atualizada, de qualquer jeito o
requesitor vai obter uma cópia atualizada que flush_tlb_range(struct mm_struct *mm, unsigned
pertença um outro processador;(NOTA: SMP long start,unsigned long end);uma chance para
arquiteturas sem hardware cache conferece uma particular range do user address no adelrass
mechanísms são realmente possíveis, o arquitetura space descrito pelo mm-struct passada esta
current flush não sustenta isto corretamente, se em ocorrendo. As duas notas acima para FLUSH -
algum ponto o Zinux apontar em algum sistema mm( ) relecianando a mm-struct passada aplicam-
onda isto é uma questão debatida, eu vou se aqui também.· Para Flush-cache-range num
adicionar os ganchos necessários mas não vai ser virtualmente cached system, todas entradess cache
bonito); que são nolidas pena a range partem para o fim no
address space descrito pelo mm-struect são para
Se o memory managemat kernel code faz uma ser invalidadas.· Para Flush-tlb-range, qualquer
modificação para a user process page modificando ação necessária para causar o MMUITLB
o dado via kernel space alias da página física hardware não conter traduções estragados são para
ser realizados. Isso significa que quaiquer do espaço Kernel para os USER-SPACE, num
traduções estão no Kernel page tables no range contexto são convertidas, alguns mapeamentos do
start para acabar no address space descrito pelo sistema kernel tem um atributo global, naquele o
mm-struet são para que a administração da hardware não concerde ele mesmo com o contexto
memoria hardware sera deste ponto avançado, por da informação quando uma tradução é feita, que
qualquer significado.void flush_cache_page(struct tem seu atributo. Desta forma um FLUSH (em
vm_area_struct *vma, unsigned long qualquer contexto) de um mapeamento de um
address);void flush_tlb_page(struct Kernel CACHE/MMU poderia ser suficiente. De
vm_area_struct *vma, unsigned long qualquer maneira e possível uns outros
address);Uma chance para uma única página no implementações para o Kernel para dividir o
address dentro do usar space para o address space contexto chave associado com um ADDRESS
descrito pelo um area-struet passado esta SPACE particular. Pode ser necessário em tal caso
ocorrendo. Uma efetivação, se necessária, pode andar por todos contextos que são contentemente
obter na mm-struet associado para este address válidos e efetuam o Flush completo em cada um
space via uma um - Flags. Este caminho em uma para um Kernall Address Space Flush. O custo
efetivação onde a instrução e dara space não são por contexto Flush podem tornar uma questão
unificados, alguem pode conferir para ver se um- chave, especialmente com respeito ao TLB. Por
exee esta posto no uma-sum-flags para exemplo, se um Tlb Flush e necessário, em um
possivelmente avistar flushing o instruction space. grande Range de endereços (ou um inteiro
Address Space) pode ser mais prudente distribuir
11. Implicações Referentes a Arquitetura e assumir um nova contexto MMU/para este
processo por causa da eficiência. Como tratar o
Arquitetura baseada no Modelo SMP : que a arquitetura flush não executa com exemplos
Dependendo da arquitetura certos consertos
podem ser necessários para permitir a arquitetura A arquitetura Flush descrita não faz emendas para
FLUSH para trabalhar num sistema SMP. O coerência de projetos DMA com dados Cached.
principal assunto e se uma das operações FLUSH Isto também não tem provisões para nenhuma
acima fazem que o sistema inteiro veja o FLUSH estratégia de mapeamento necessários pelo DMA
globalmente, ou o FLUSH e apenas garantido para e projetos se forem necessários em um certa
ser visto pelo processador local. Em um último máquina Linux é Portad To. Nenhuma destas
caso um CROSS CALLING MECHANISM é questões são para a arquitetura Flush. Tais
necessário. Os dois correntes sistemas SMP questões são negociadas mais claramente no nível
suportados no LiNUX (intel e space) usam inter- do Driver do projeto. O autor está mais
processor interrupts para "transmitir" a operação convencido disto depois de sua experiência com
FLUSH e faz isto correr localmente em todo um conjunto comum de sparc device drivers que
processador se necessário como um exemplo, no precisaram de toda função corretamente em mais
sistema SUNHM Space todos precessadores no do que uma hand full de cache/mmu e bus
sistema precisam executar o pedido FLUSH para architetures no mesmo kernel. De fato esta
garantir a consistência através do sistema inteiro. implementação é mais eficiente porque o
De qualquer modo, nas máquinas SUNHD Space, motorista sabe exatamente quando o DMA precisa
TLB FLUSHES efetivamente no processador ver o dado consistente ou quando o DMA está
local são transmitidos sobre o BUS-SYSTEM indo criar uma inconsistência que deve ser
pelo hardware e desta forma uma ligação cruzada resolvida. Nenhuma tentativa para atingir este
não e necessária Implicações para arquitetura nivel de eficiencia via cochetes soma ao codigo de
baseados no contexto MMU/CACHEA idéia administracao generica da memoria kernel seria
inteira por trás do conceito de MMU e facilidades complexo e muito obscura como um exemplo,
do contexto cache é para permitir muitos considere no sparc como os DMA buffers são
ADDRESS SPACES para dividir os recursos manuscrito. Quando um device driver deve efetuar
CACHE/MMU no CPU. Para levar total vantagem o DMA para/de um único buffer, ou uma dispersa
de tal facilidade, e ainda manter a coerência lista de muitos buffers, ele usa um conjunto de
descrita acima, requer-se algumas considerações rotinas abstratas. Essencialmente o mmu_get_*
extras do implementador. As questões envolvidas rotinas são passadas por um indicador ou um
variam muito de uma implementação para outro, conjunto de indicadores e especificações de
pelo menos esta tem sido a experiência do autor. tamanho para áres no espaço kernel para que o
Mas em particular algumas destas questões são DMA ocorra, eles retornam para o endereço capaz
provavelmente para ser a relação do mapeamento do DMA ( por exemplo um que pode ser
carregado do controlador do DMA para o ponteiros para outro tipo de estrutura, que
transferidor). Quando o driver é feiro como DMA descreve regiões de memória virtual, chamadas
e o transferidor tiver completado com o(s) vm_area_struct, cuja definição está no arquivo
endereço(s) DMA para que recursos possam ser include/linux/mm.h.Cada estrutura
liberados (se necessario) e cache flushes possam vm_area_struct define o início e o fim de uma
ser efetivados (se necessario). A rotina ter um área de memória virtual, os direitos de acesso que
bloqueio de memoria de DMA por um longo o processo detém para esta região de memória, e
periodo de tempo, por exemplo, um motorista de um conjunto de operações disponíveis para esta
networking usaria isto para uma transmissao de região. Este é exatamente o ponto interessante da
pesquisa ou receber buffers. O argumento final é gerência de memória.Mais importante que tudo,
uma entidade especifica Sparc que permite o cada uma destas duas estruturas possui um
codigo do nivel da maquina efetuar o mapeamento ponteiro para um conjunto de gerência destas
se o mapeamento do DMA são ordenados em uma áreas de memória. O segmento de código deve ser
base por-bus. gerenciado diferentemente do segmento de dados,
já que seus conteúdos têm comportamento
11.1 Questões abertas na Arquitetura diferente.Por exemplo, quando há a necessidade
Cache de se liberar uma página de memória de algum
processo, caso seja uma página de uma área de
Há pareceres para muitas estupidas arquiteturas código esta pode ser simplesmente descartada,
cache lá fora que queira causar problemas quando sem a necessidade de se escrevê-la em uma área
um alias está situado dentro do cache. Da nota de swap em disco, pois as regiões de código são
está o mipsr4000 que dará uma exceção quando imutáveis, e portanto podem ser simplesmente
tal situação ocorre, elas podem ocorrer quando o lidas de novo do arquivo que contém a imagem do
processamento cow está acontecendo na corrente processo.Já a gerencia da área de dados, neste
implementação. No mais chips que fazem algo caso, seria um pouco mais complexa, visto que
estupido como isto, um exception handler pode uma página de dados pode se modificar. Neste
flush as entradas no cache que está sendo exemplo seria necessário verificar se a página foi
reclamado e tudo está em ordem. O autor esta ou não modificada, gravando-a em disco se foi, e
mais concernido sobre o custo dessas exceções descartando-a se não, pois sempre se pode ler
durante o processamento cow e seus efeitos que páginas não modificadas diretamente da imagem
ocorrerão na performance cow, que em disco.Este "polimorfismo" existente na
essencialmente está para flush um user space page gerência de memória está centrado no ponteiro,
e se não o fazendo então causaria os problemas chamado vm_ops, que cada estrutura
acima descritos. Tem sido tardiamente aquecida a vm_area_struct possui para um conjunto de
conversa sobre muito inteligentes networking operações. Neste caso, obviamente o conjunto de
hardware. Pode ser necessario estender a operações utilizado em um segmento de códigos é
arquitetura flush para prover as interfaces e diferente do conjunto utilizado em um segmento
facilidades necessarias para estas mudanças para o de dados, mas o Kernel do Linux não precisa se
codigo networking. É claro que, a arquitetura preocupar em saber que tipo de segmento ele está
flush é sempre sujeita a aperfeiçoamentos e processando, visto que ele simplesmente chama a
mudanças para buscar novas questões ou novos função de swapout desta região.
hardwares que apresentam um problema que
estava até este ponto desconhecido.

12.Conclusão 13. Referências

Toda a gerência de memória feita pelo Linux para


[1] www.sites.uol.com.br
cada processo se baseia em uma estrutura
específica, chamada mm_struct, definida no [2] www.cpusystems.cjb.net
arquivo include/linux/sched.h. cada processo em
um sistema Linux possui uma destas estruturas [3] www.trablinux.hpg.ig.com.br
para controle de suas áreas de memória.Esta
estrutura, além de informações sobre o programa [4] www.viciadosemlinux.com.br
que está sendo executado, os endereços iniciais e
finais em sua memória virtual dos seus vários
segmentos e algumas contagens, possui alguns

Você também pode gostar