curso de hacker ético Inicialização da memória

No Start Kernel (main.c) há 3 variáveis relatadas para inicialização da memória:



memory_start começa a 1 Mb atualizado pelo projeto de inicialização.
memory_end término da memória física: 8 Mb, 16 Mb, ou qualquer outro.
Low memory_start término do código Kernel e dados que é carregado inicialmente



Cada projeto init tipicamente torna memory_start e retorna um valor atualizado, se distribui espaços no memory_start (simplesmente pegando-a). Paging init ( ) inicializa a page-tables no { tt swapper - pg - dir} ( começando a 0 X 0000000) para cobrir toda a memória física do memory_start para memory_end. Na verdade o primeiro 4 Mb é feito no startup_32 (heads).memory_start é incrementado se quaisquer nova page-tables são adicionados.
A primeira página é zerada para bloquear os indicadores das referências do alçapão nulo no Kernel.
No sched_init ( ) o 1 dt e tss descritores para tarefa [0] são postos no GDT, e carregado para dentro do TR e LDTR (a única vez que isto é feito explicitamente). Um trap gate (0X80) é ordenado para system-call.( ).
A bandeira tarefa aninhada é desligada na preparação para entrada do modo usuário: O cronômetro é ligado. O task-struct para task [0] aparece por inteiro em <>
mem_map é então construído por mem_init ( ) para refletir o corrente uso das páginas físicas. Este é o estado refletido no mapa da memória física da seção anterior. Então Dinux move para dentro do modo usuário com um iret após empurrar o corrente ss, esp, etc.
Claro que o segmento usuário para task [0] são mapeados bem sobre os segmentos Kernel e deste modo a execução continua exatamente onde isto termina.
Task [0]:



pg_dir = swapper - pg - dir que sigmifica apenas endereços mapeados estão no alcance 3 Gb para 3 Gb + High memory.



LTD [1] = código usuário, base = 0 x 0000000, tamanho = 640 K
LDT [2] = dados usuários, base = 0 x 0000000, tamanho = 640 k



O primeiro exec ( ) põe a LTD entrada para task [1] para os valores usuários da base = 0x0, limite = task_size = 0 x c 0000000. Depois disso, nenhum processo vê os segmentos Kernel enquanto no modo usuário.
Processos e a Administração da Memória.
Memória relacionada trabalho feito por fork ( ):
· distribuição de memória
· 1 página para o Task-struct
· 1 página para o Kernel Stack
· 1 para o pg_dir e algumas para pg_tables (cópias - páginas - tabelas)
· Outras mudanças
· sso põe para o segmento Kernel stack (0x10) para ter certeza?
espo põe para o topo da nova distribuição Kernel - stack - page.
· c r 3 põe por copy - page - tables ( ) para indicar para nova página de diretório distribuída
· 1 dt = LDT (task_nr) cria novo 1 dt descritor
· descritores põe no gdt para novo tss e 1 dt [ ]
· Os registros restantes são herdados do parent.
Os processos resultam dividindo seus códigos e segmentos de dados (embora eles tenham tabelas descritoras locais separados, as entradas indicam para os mesmos segmentos). O stack e páginas de dados serão copiados quando o parent ou child escreve para eles ( copy-on-write).
Memória relacionada trabalho feito por exec ( ):
· distribuição de memória
· 1 página para exec header para omagic
· 1 página ou mais para stack (max_arg_pages)
· clear-página-tables ( ) usado para remover páginas velhas.
· change 1 dt ( ) põe os descritores no novo 1 dt [ ]
· 1 dt [1] = código base = 0 x 00, limite = task - size
· 1 dt [2] = data base = 0 x 00, limite = task - size
Estes segmentos são dpl = 3, p=1, s=1, g=1. Tipo = a (código or 2 dados)
· Eleva para MAX_ARG_PAGES páginas sujas de arqu e enup são distribuídos e guardado ao topo do segmento de dados para o novo usuário pilha criado.
· Ponha os indicadores de instrução do caller cip = ex.a_cutry
· Ponha o stack indicador do caller para o stack criado (esp=stack indicador). Este serão eliminados do Stack quando o caller resume.



Limites de Memória Atualizados
· cud_code = ex.a_text
· cud_data = cud_code + &x.d_data
· brK = end_data + ex.ª_bss



Interrupções e traps são sustentadas dentro do contexto da corrente tarefa. Em particular, o diretório de páginas do corrente processo é usado na tradução de endereços. Os segmentos, de qualquer modo, são segmentos Kernel para que todos os endereços lineares apontem para dentro da memória Kernel quer acessar uma variável no endereço 0 x 01. O endereço linear é 0 x 00000001 (usando segmentos Kernel) e o endereço físico é 0 x 01. O último é porque a página do processo diretório mapea esta extensão exatamente como page_pg_dir.
O espaço Kernel (0 x c 0000000 + high - memory) e mapeado pela tabela de páginas Kernel que são eles mesmos parte da memória reservada. Eles são consequentemente divididas por todos processos. Durante um fork copy-page-tables ( ) trata tabela de páginas reservadas diferentemente. Isto põe indicadores no diretório de páginas de processo para indicar para tabelas de página Kernel e na verdade não distribui novas tabelas de páginas como isto faz normalmente. Como um exemplo o Kernel - Stack - page ( que ocupa algum lugar no espaço Kernel ) não precisa de um associado page - table distribuídos no pg-dir do processo para mapeá-lo.
O interruptor de instruções põe o indicador stack e o segmento stack do privilégio valor salvo no Tss do corrente task. Note que o Kernel stack é um objeto realmente fragmentado - 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 Kernel stack não deveria crescer tão rapidamente dentro de um contexto de um processo que extende abaixo da corrente frame.
(Leia mais... 10 Comentários Pontos 0)
Curso de Linux Gratis #09 - curso de hacker ético - www.thehacker.com.br
Publicada por wilsonSegunda, junho 25 @ 00:00:00 FNT

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.