Pour autant que je sache, Pas.
intercept all memory related actions
? Il ne semble pas impossible, mais je dois être très très lente.
Par exemple, supposons que ce code:
int f(int *a1, int *b1, int *c1, int *d1)
{
const int n=100000;
for(int j=0;j<n;j++){
a1[j] += b1[j];
c1[j] += d1[j];
}
}
(From here >o<)
Cette simple boucle est compilé en suivant par gcc -std=c99 -O3
avec gcc 4.8.3:
push %edi ; 1
xor %eax,%eax
push %esi ; 2
push %ebx ; 3
mov 0x10(%esp),%ecx ; 4
mov 0x14(%esp),%esi ; 5
mov 0x18(%esp),%edx ; 6
mov 0x1c(%esp),%ebx ; 7
mov (%esi,%eax,4),%edi ; 8
add %edi,(%ecx,%eax,4) ; 9
mov (%ebx,%eax,4),%edi ; 10
add %edi,(%edx,%eax,4) ; 11
add $0x1,%eax
cmp $0x186a0,%eax
jne 15 <_f+0x15> ; 12
pop %ebx ; 13
pop %esi ; 14
pop %edi ; 15
ret ; 16
Même ce vraiment très simple La fonction a codes machine qui accèdent à la mémoire. Probablement le code de simulation d'OS a des centaines de codes machine, alors nous pouvons deviner que la vitesse des codes d'accès mémoire ralentira des centaines de fois au moins.
De plus, c'est quand vous pouvez regarder seulement codes d'accès-mémoire. Probablement votre processeur n'a pas cette fonctionnalité, vous devez utiliser le débogage pas à pas, comme le drapeau de trappe de x86, et vérifier chaque commande à chaque fois.
choses va plus mal - Il ne suffit pas de vérifier les codes. Vous pouvez également vouloir que IP (Instruction Pointer) suive également la règle de mémoire virtuelle de votre système d'exploitation, vous devez donc vérifier si l'adresse IP est au-dessus de la limite de la page après l'exécution de chaque code. Vous devez également très attentivement traiter avec les codes qui peuvent changer IP, tels que jmp, call, ret, ...
Je ne pense pas qu'il peut être mis en œuvre efficacement. Il ne peut pas être implémenté efficacement. La vitesse est l'une des parties les plus importantes du système d'exploitation. Si le système d'exploitation devient un peu lent, tout le système est affecté. Dans ce cas, ce n'est pas un peu - votre ordinateur est lent beaucoup et. De plus, l'implémentation est très difficile comme je l'ai dit plus haut - je préfèrerais écrire un émulateur d'un processeur qui a de la mémoire virtuelle supportée par le matériel que ce travail fou!
pour la plupart des processeurs, le mmu est ce qui dit à l'os sur les accès mémoire. s'il ne supporte pas la mémoire virtuelle, vous ne pourrez probablement pas l'implémenter dans un logiciel sans recompiler tout le code avec un compilateur spécial. ce serait aussi très lent. (comme 2 - 10x plus lent) – programmerjake
Comme @programmerjake dit, ce serait horriblement lent. En effet, votre «gestionnaire de mémoire de logiciel» ferait du processeur un interprète. Le matériel MMU permet au processeur d'exécuter du code exécutable nativement jusqu'à ce qu'une interruption de panne de page soit générée par le matériel et traitée. –
@programmerjake J'essaie de comprendre si c'est possible, je sais bien que ça pourrait ralentir les choses. Pourquoi pensez-vous que je devrais tout recompiler?Par exemple, je pourrais écrire quelque chose comme un émulateur qui traduira le binaire en temps réel, n'est-ce pas? (Encore une fois, je ne suis pas préoccupé par la vitesse) – Darius