Discussion :

[mmats]

Bonjour,

Je suis étudiant en 3ème année en Informatique de gestion et je dois, dans le cadre d'un projet en Système d'exploitation, réaliser un mini OS.
La table des interruptions, la segmentation, la pagination ont déjà été mis en place dans un précédent projet.
Le but du projet actuel est de réaliser les routines déclenchées lors de l'appel à INT 0x80 en mode protégé (On ne doit gérer que le read et write).
J'ai codé le write et il fonctionne correctement, par contre, pour ce qui est du read, j'ai pas mal de difficultés depuis quelques semaines expliquant mon message.

Ce qui est déjà en place :

• Lorsque l'on appuie sur une touche, une interruption est déclenchée et le scancode lu est converti en caractère et enfin affiché à l'écran
• Lorsque l'on appelle un appel système read dans le code, l'interruption 0x80 dirige vers la routine devant être réalisée

Ce qui doit être fait :

• Lors de l'appui sur une touche, le caractère doit, en plus d'être affiché, être mis dans un buffer (de 100 caractères par exemple) qui sera utilisé comme un tableau circulaire
• L'appel système read doit simplement copier le nombre de caractères demandés (argument dans EDX) depuis le buffer rempli par le clavier vers la zone donnée (argument dans ECX)

L'appel système doit être bloquant, c'est-à-dire que si l'appel read n'a pas pu lire le nombre demandé de caractères (buffer clavier pas (assez) rempli, il doit attendre que l'utilisateur remplisse le buffer clavier en tappant au clavier.
C'est la partie pour laquelle j'ai le plus de mal, je ne vois pas trop comment faire...

Les fichiers :

kern.asm : Le kernel
keyb.asm : Routines appelée lors de l'interruption clavier
screen.asm : Permet la gestion de l'écran (Scrolling, affichage, etc...)
syscalls.asm : Gère les appels systèmes INT 0x80

Votre aide serait précieuse !

Merci d'avance !

Mats

[edfed]

int 80h est une fonction, contenant des instructions executées comme toutes les instructions, à la suite les unes de autres, avec possibilité de tests et branchements.

sachant celà, il n'est pas compliqué d'imaginer une sequence permettant de bloquer tant que tout n'est pas entré.

par exemple, une boucle avec test d'egalité, si egal à nombre de char attendus, alors on sort.
en assembleur, ça pourrait se traduire ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
;fonction à indexer dans la table d'interruptions IDT.
int80:
 ;routine systeme int80h, doit contenir tout un paquet de code permettant
 ;de choisir la sous fonction indiquée par eax
.invalid_command_error_code='ERR.'
.null_code=0
.read_code=1
.printchar_code=2
.fairececi_code=3
.fairecela_code=4
.malloc_code=5
 ;eax=numero d'appel systeme
 ;ebx,ecx, edx, esi, edi et ebp en fonction du type d'appel
      cmp eax,.null_code
      je .null
      cmp eax,.read_code
      je .read
      cmp eax,.printchar_code
      je .printchar
      cmp eax,.faire_ceci_code
      je .faire_ceci
      cmp eax,.faire_cela_code
      je .faire_cela
      cmp eax,.malloc_code
      je .malloc
 
      mov eax,.invalid_command_error_code ;la sous fonction n'est pas supportée
 
.end: ;ici,est le point de sortie, quelle que soit la sous fonction
      iret ; et on quitte
.null:
.nullreturn_code=80000000h
      mov eax,.nullreturn_code  ;return 
      iret
 
 
.read:      ;fonction read N chars
.read_OK_code=;read_code
.read_KO_code=-.read_code
 ;edx=nombre de chars à entrer
 ;return 
 ;eax=error code? allez, soyons fous
 ;ebx=buffer où ont été envoyés nos chars
 ;
      mov eax,.malloc_code
      int 80h
      or ebx,ebx ;si adresse buffer = 0
      je .error_malloc
      xor eax,eax
      mov edi,ebx ;pointer vers la zone fraichement allouée
      mov ecx,edx ;nous avons besoin de compter pour cette operation
@@:
      call keyb.getchar
      stosb ;enregistrer le char dans notre memoire allouée
      loop @b ;
 
      mov eax,.read_OK_code
      jmp .end ;on quitte
 
.error_malloc:    ;soit on à plus de mémoire, soit il y a un bug, ici, c'est voulu, 
                      ;il n'y à meme pas de fonction
      mov eax,'merr'
      jmp .end
 
.malloc: ;allocate memory
;return ebx=memory adress
;ici le code pour allouer de la mémoire
      xor ebx,ebx ;ici, je veux tester .error_malloc, pour voir si ça genère une erreur
      jmp .end
 
.printchar:
;ici, le code pour afficher un char
      jmp .end
 
.faire_ceci:
;ici le code pour faire_ceci
      jmp .end
 
.faire_cela:
;ici le code pour faire cela
      jmp .end

bien entendu, il faut completer avec des bouts de code correspondants à ce qui est et sera ecrit dans ce code.

l'idée est de creer une fonction int80: , qui commencerais par un switch case vers les sous fonctions supportées.
en fin de switch case, la fonction n'est pas supportée, on retourne l'erreur correspondante.

voilà, j'espere que ça t'aide un peu. sinon, tu peux visiter des sites comme osdev, osdever, et autres communautés specialisées sur les OS, mais bien souvent, ils sont uniquement en anglais, ce qui n'est pas un problème pour un programmeur normallement.