Esta é uma pergunta de acompanhamento da minha pergunta anterior .
Com base na resposta, uma chamada de sistema é um exemplo de quando pulamos para a parte do kernel da memória virtual do nosso processo.
Quais são outros exemplos de um processo normal (não kernel) usando essa parte da memória virtual além das chamadas do sistema? como existe alguma chamada de função que salta diretamente para esta parte do kernel ou ..?
Quando pulamos para esta seção da memória, o processador define automaticamente o bit do modo kernel para 1 para que nosso processo acesse essa parte ou não há necessidade de definir esse bit?
Toda a execução dentro desta parte do kernel acontece sem a necessidade de mudança de contexto para um processo do kernel?
(Eu não queria fazer essas perguntas de acompanhamento nos comentários, então abri outro tópico.)
Os processos executados no modo de usuário não têm acesso ao espaço de endereço do kernel. Existem várias maneiras de o processador alternar para o modo kernel e executar o código do kernel, mas todas são configuradas pelo kernel e acontecem em contextos bem definidos: executar uma chamada de sistema, responder a uma interrupção ou lidar com uma falha. Chamadas de sistema não envolvem chamar diretamente o código do kernel; eles envolvem um mecanismo específico da arquitetura para solicitar à CPU que transfira o controle para o kernel, para executar uma chamada de sistema específica, identificada por seu número, em nome do processo de chamada. O LWN tem uma série de artigos explicando como isso funciona: Anatomia de uma chamada de sistema parte um , parte dois e conteúdo adicional .
Se um processo tentar acessar a memória no espaço de endereço do kernel, ele mudará para o modo kernel, mas como resultado de uma falha; o kernel então matará o processo com uma violação de segmentação (
SIGSEGV).No x86 de 32 bits, existe um mecanismo para alternar para o modo kernel usando chamadas far, call gates ; mas o Linux não usa isso. (E eles contam com descritores de segmentos de código especiais em vez de chamar endereços do kernel.)
Veja acima: você não pode pular para a memória do kernel. Nas circunstâncias descritas acima, ao fazer a transição para o modo kernel, a CPU verifica se a transição é permitida e, em caso afirmativo, alterna para o modo kernel usando qualquer mecanismo apropriado na arquitetura que está sendo usada. No Linux x86, isso significa alternar do anel 3 para o anel 0.
A transição para o modo kernel não envolve uma mudança de processo, então sim, tudo isso acontece sem uma troca de contexto (conforme contado pelo kernel).
1 e 2. Não, um programa de usuário não pode simplesmente usar uma instrução de salto para entrar na memória do kernel. Não é permitido fazê-lo. A CPU não define automaticamente o "bit do kernel" para permitir que esse salto seja bem-sucedido... (talvez alguma CPU tenha esse recurso, mas uma porta Linux segura desabilitaria esse recurso)
...Na verdade, já que você está acessando uma página de uma forma que não tem permissão para fazer, você entrará no kernel :-). Ele entra de forma controlada, funciona muito parecido com uma chamada de sistema, mas chamamos de "falta de página". A CPU fornecerá detalhes do acesso ao kernel. Com o tipo de acesso que você descreve, o kernel o tratará como um erro em seu programa :-). Ele enviará um sinal fatal para o seu programa (SIGSEGV).
Tecnicamente, a memória do kernel pode ser mapeada em processos, ilegível, somente leitura ou leitura-gravação, e possivelmente até executada por processos saltando para o código armazenado nessa memória. Esta pode ser uma técnica para aumentar a velocidade de algumas syscalls onde é seguro executar código para manipular a syscall no processo e não no kernel. Ele também pode incluir dados como um endereço de memória contendo um valor de clock fornecido pelo kernel para que um processo não precise interromper para que o sistema possa entrar no kernel.
Também é possível que os processos entrem em chamadas de sistema por interrupção no kernel através de INT 0x80, isso é o que muitos programadores de assembly estão familiarizados, mas certamente não é o único mecanismo que pode ser fornecido pelo kernel. Não existe uma regra rígida de que um kernel e os espaços de endereço do usuário tenham que ser completamente separados.
Independentemente de qual abordagem o Linux usa, certamente é tecnicamente viável colocar código e dados do kernel em processos. O Linux também coloca a memória do kernel em processo rotineiramente, por motivos de desempenho relacionados a trocas de contexto e ao TLB, mas como muitas áreas do kernel são sensíveis, elas geralmente não são legíveis pelo processo.