Curso Completo-Linux e avançado

Curso Completo-Linux e avançado

(Parte 7 de 7)

Considere um cache virtualmente catalogados que é escrito de volta write-back. Neste momento que a cópia da página acontece para o supisto espaço kernel, é possivel para usar space a visão da página original para estar no caches (no endereço do usuário, por exemplo, onde o erro esta ocorrendo). A cópia da página pode trazer este dado (para a página velha) dentro do caches. Será também colocado o dado (no novo suporte kernel mapeado da página) sendo copiado para dentro da cache, e para write-back escrever de volta chachas este dado vai ser sujo ou modificado no cache.

Em tal caso a memoria principal não será a cópia mais recente do dado. Os caches são estúpidos, então para a nova página que estamos dando ao usuário, sem forçar o dado cached no suposto kernel para a memória principal o processo será o conteúdo velho da página. (Por exemplo qualquer lixo que estarem lá antes da cópia ter sido feita pelo processamento COW acima).

4.7.3.1 - Exemplo concreto de flush-page

Considere um processo que divide uma página, lê somente

READ-ONLY com maior uma tarefa (ou varias) no endereço virtual Ox2000, no usar space. E para propósito espesíficos deixe nos dizer que este endereço virtual mapeia para a página física 0x14000.

Se a tarefa 2 tenha escrever para a página lê apenas no endereço 0x2000 nós alteremos um esso e (eventual fragmento do código) mente resultado no code fragment mostrando acima no do-WP-PAGE ( ).

O Kernel vai obter uma nova página para tarefa 2, deixe-nos dizer que esta e uma página física 0x2600, e deixe-nos tambem dizer que os mapeamentos do suposto Kernel para páginas físicas 0x14000 e 0x26000 podem residir em dias únicos linhas cache ao mesmo tempo buscando no esquema da linha catalogada deste cache.

O conteúdo da página e copiado do mapeamento Kernel para página física 0x14000 para uns para página física 0x26000.

Neste momento, numa arquitetura cache virtualmente catalogada write - back nos temos uma inconsistência potencial. O novo dado copiado dentro da página física 0x26000 não e necessário na memória principal neste momento, de fato isto poderá estar toda no cache apenas no suposto kernel do endereço físico.

Também, o (não modificando, por exemplo, limpo) dado para a (velha) página original esta no cache do suposto kernel para página física 0x14000, isto pode produzir uma inconsistência mais tarde, então para proteger isto e melhor eliminar as cópias cached deste dado também.

Deixe-nos dizer não escrevemos os dados de volta para a página no 0x256000 e nos apenas deixamos isto lá. Nos retornariamos para a tarefa 2 (Quem teve esta nova página agora mapeada no endereço virtual 0x2000) ele completaria sua escrita, então ele leria algumas outras porções de dados nesta nova página (por exemplo, esperando o conteúdo que existe lá antes). Neste momento seo dado e deixado no cache no suposto kernel para nova página física, o usuário obterá o que que estava na memória principal antes da cópia para sua leitura. Isto pode levar a resultados dasastrosos.

4.7.4 - Conteúdo de uma arquitetura virtual

Numa arquitetura cache virtualmente catalogada, fica o que foi necessário para fazer a memória principal consistente com a cópia cached da página passada do espaço kernel.

Nota: Isto é na verdade necessário para esta rotina invalidar linhos em um cache virtual que não escrito de volta é write - back na natureza. Para ver porque isto e realmente necessário, refaça o exemplo acima com a tarefa 1 e 2, mas agora fork ( ) ainda outra tarefa 3 antes dos erros do cow ocorreram, considere o conteúdo do caches no kernel e user space se a sequencia seguinte ocorre na exata sucessão:

1. Tarefa 1 lê uma parte da página no 0x2000 2. Tarefa 2 COW erra a página no 0x2000 3. Tarefa 2 efetiva suas escritas para a nova página no 0x2000 4. Tarefa 3 COW erra a página 0x2000

Mesmo em um cache não escrito devolta virtualmente catalogado, a tarefa 3 pode ver o dado incossistente depois do erro COW se FLUSH-PAGE-TO-RAM não invalida a página física do suposto kernel do cache.

Embora não estritamente parte da arquitetura flush, em certas arquiteturas algumas operações e controles precisam ser eferuados aqui parea as coisas darem certo proporcionalmente e para o sistema manter-se consistente.

Em particular, para caches virtualmente catalogados esta rotina deve conferir para ver que o novo mapeamento que vem sendo adicionado pelo conente erro de página não adiciona um bad alias “para o user space”.

Um “Bad Alias” e definido como dois ou mais mapeamentos (pelo menos um dos quais e escrevivel) para duas ou mais o páginas que traduzem para a exata página física, e devido ao algarismo catalogado do cache pode também residir na única e mutualmente exclusiva linhas cache.

Se um BAD ALIAS é detectado, uma implementação precisa resolver esta inconsistência de alguma maneira, uma solução e andar através de todo os mapeamentos e mudar as page-tables para fazer estas páginas como não concreáveis se o hardaware permite tal coisa.

As conferências para isto são muito simples, tudo que uma implementação precisa fazer é:

Se ((uma -Um - Flags 6 (Um - Write/Um - Shared)) confere sua potência mau supostas, então para o caso comum (mapeamento escrevíveis devidos são extremamente raros) apenas uma comparação é necessitada para sistemas COW CAHCES virtualmente catalogados.

4.7.5 - Implicações Referentes a Arquitetura 4.7.5.1 - Arquitetura baseada no Modelo SMP

Dependendo da arquitetura certos consertos podem ser necessários para permitir a arquitetura FLUSH para trabalhar num sistema SMP.

O principal assunto e se uma das operações FLUSH acima fazem que o sistema inteiro veja o FLUSH globalmente, ou o FLUSH e apenas garantido para ser visto pelo processador local.

Em um último caso um CROSS CALLING MECHANISM é necessário. Os dois correntes sistemas SMP suportados no LiNUX (intel e space) usam inter-processor interrupts para “transmitir” a operação FLUSH e faz isto correr localmente em todo processador se necessário como um exemplo, no sistema SUNHM Space todos precessadores no sistema precisam executar o pedido FLUSH para garantir a consistência através do sistema inteiro. De qualquer modo, nas máquinas SUNHD Space, TLB FLUSHES efetivamente no processador local são transmitidos sobre o BUS-SYSTEM pelo hardware e desta forma uma ligação cruzada não e necessária

4.7.5.2 - Implicações para arquitetura baseados no contexto MMU/CACHE.

A idéia inteira por trás do conceito de MMU e facilidades do contexto cache é para permitir muitos ADDRESS SPACES para dividir os recursos CACHE/MMU no CPU.

Para levar total vantagem de tal facilidade, e ainda manter a coerência descrita acima, requer-se algumas considerações extras do implementador.

As questões envolvidas variam muito de uma implementação para outro, pelo menos esta tem sido a experiência do autor. Mas em particular algumas destas questões são provavelmente para ser:

•A relação do mapeamento do espaço Kernel para os USER-SPACE, num contexto são convertidas, alguns mapeamentos do sistema kernel tem um atributo global, naquele o hardware não concerde ele mesmo com o contexto da informação quando uma tradução é feita, que tem seu atributo. Desta forma um FLUSH (em qualquer contexto) de um mapeamento de um Kernel CACHE/MMU poderia ser suficiente.

De qualquer maneira e possível um outros implementações para o Kernel para dividir o contexto chave associado com um ADDRESS SPACE particular. Pode ser necessário em tal caso andar por todos contextos que são contentemente válidos e efetuam o Flush completo em cada um para um Kernall Address Space Flush.

O custo por contexto Flush podem tornar uma questão chave, especialmente com respeito ao TLB. Por exemplo, se um Tlb Flush e necessário, em um grande Range de endereços (ou um inteiro Address Space) pode ser mais prudente distribuir e assumir um nova contexto MMU/para este processo por causa da eficiência

4.7.6 - Como tratar o que a arquitetura flush não executa com exemplos

A arquitetura Flush descrita não faz emendas para coerência de projetos DMA com dados Cached. Isto também não tem provisões para nenhuma estratégia de mapeamento necessários pelo DMA e projetos se forem necessários em um certa máquina Linux é Portad To.

Nenhuma destas questões são para a arquitetura Flush. Tais questões são negociadas mais claramente no nível do

Driver do projeto. O autor está mais convencido disto depois de sua experiência com um conjunto comum de sparc device drivers que precisaram de toda função corretamente em mais do que uma hand full de cache/mmu e bus architetures no mesmo kernel. De fato esta implementação é mais eficiente porque o motorista sabe exatamente quando o DMA precisa ver o dado consistente ou quando o DMA está indo criar uma inconsistência que deve ser resolvida. Nenhuma tentativa para atingir este nivel de eficiencia via cochetes soma ao codigo de administracao generica da memoria kernel seria complexo e muito obscura como um exemplo, considere no sparc como os DMA buffers são manuscrito. Quando um device driver deve efetuar o DMA para/de um único buffer, ou uma dispersa lista de muitos buffers, ele usa um conjunto de rotinas abstratas.

Char * (*mmu_get_scsi_one)(char de char *, unsigned linux_sbus longo de struct *sbus); sem (*mmu_sglist (*mmu_get_scsi_sgl)(struct de efeito *, int, linux_sbus de struct *sbus); sem (*mmu_release_scsi_one)(char de efeito *, unsigned linux_sbus longo de struct *sbus); sem (*mmu_sglist (*mmu_release_scsi_sgl)(struct de efeito *, int, linux_sbus de struct *sbus); sem (*mmu_map_dma_area)(unsigned de efeito addr longo, len de int);

Essencialmente o mmu_get_* rotinas são passadas por um indicador ou um conjunto de indicadores e especificações de tamanho para áres no espaço kernel para que o DMA ocorra, eles retornam para o endereço capaz do DMA (por exemplo um que pode ser carregado do controlador do DMA para o transferidor). Quando o driver é feiro como DMA e o transferidor tiver completado com o(s) endereço(s) DMA para que recursos possam ser liberados (se necessario) e cache flushes possam ser efetivados (se necessario). A rotina ter um bloqueio de memoria de DMA por um longo periodo de tempo, por exemplo, um motorista de networking usaria isto para uma transmissao de pesquisa ou receber buffers. O argumento final é uma entidade especifica Sparc que permite o codigo do nivel da maquina efetuar o mapeamento se o mapeamento do DMA são ordenados em uma base por-bus.

4.7.7 - Questões abertas na Arquitetura Cache

Há pareceres para muita estupidas arquiteturas cache lá fora que queira causar problemas quando um alias está situado dentro do cache (mesmo um protegido onde nenhuma das entradas do cache suposto são escreviveis!). Da nota está o mipsr4000 que dará uma

(Parte 7 de 7)

Comentários