Probléme d'execution de mon Kernel perso

**gege2061** · 18/07/2006, 12h07

Bonjour,

Envoyé par bouazza92

Code :

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

void ecrire( char* chaine )

La chaine n'est pas modifiée (et tu lui passe un argument qui n'est pas forcement modifiable), autant utiliser :

Code :

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

void ecrire (const char * chaine )

Envoyé par bouazza92

Code :

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

1
2
3
4
5
6
 
	{
		screen[pos++] = chaine[i++];
		screen[pos++] = ATTR;
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
 
	{
		screen[pos] = chaine[i];
                pos++;
                i++;
		screen[pos] = ATTR;
                pos++;
	}
}

Est plus clair et au moins tu es sûr du résultat !

Envoyé par bouazza92

Code :

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

1
2
3
4
int kernel_main(void) {
	ecrire("Le kernel parle !");
	while(1);
}

Même si ta fonction ne se termine jamais il doit quand même apparaître un return (int) pour être conforme au prototype.

**bouazza92** · 18/07/2006, 12h26

Envoyé par gege2061

Bonjour,

La chaine n'est pas modifiée (et tu lui passe un argument qui n'est pas forcement modifiable), autant utiliser :

Code :

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

void ecrire (const char * chaine )

Code :

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

1
2
3
4
5
6
7
8
9
 
	{
		screen[pos] = chaine[i];
                pos++;
                i++;
		screen[pos] = ATTR;
                pos++;
	}
}

Est plus clair et au moins tu es sûr du résultat !

Même si ta fonction ne se termine jamais il doit quand même apparaître un return (int) pour être conforme au prototype.

Chose faite .
Mais rien n'a changé ... , ça affiche toujours un S et un blanc en haut à gauche et redémarre .
Je crois avoir trouvé la cause du redémarrage ( mais pas encore le S et le blanc ... ) , en effet , je crois qu'en déclarant une seule fonction dans le code ( kernel_main ) , ça ne redémarre plus , mais si on déclare deux ou plus , ça redemarre sans cesse !
En effet , cette idée m'est venue lors de la comparaison de ces deux petits programmes :

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
 
 
void ecrire ()
{
  	unsigned char *fb;
 
	fb = (unsigned char *)0xB8000 ;
	fb[0] = 'H';
	fb[1] = 0x07;
	fb[2] = 'E';
	fb[3] = 0x07;
	fb[4] = 'L';
	fb[5] = 0x07;
	fb[6] = 'L';
	fb[7] = 0x07;
	fb[8] = 'O';
	fb[9] = 0x07;
}
 
int kernel_main(void) {
	ecrire();
	while(1);
	return(0);
}

et

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
 
 
int kernel_main(void) {
	unsigned char *fb;
 
	fb = (unsigned char *)0xB8000 ;
	fb[0] = 'H';
	fb[1] = 0x07;
	fb[2] = 'E';
	fb[3] = 0x07;
	fb[4] = 'L';
	fb[5] = 0x07;
	fb[6] = 'L';
	fb[7] = 0x07;
	fb[8] = 'O';
	fb[9] = 0x07;
	while(1);
	return(0);
}

Le premier code redémarre sans fin alors qu'il affiche bien HELLO à l'écran de BOCHS , et le deuxiéme l'affiche bien mais ne redémarre pas !
Peut quelqu'un qui a déja eu une experience en développement OS me dire comment faire pour que, avec même plusieurs fonctions déclarées dans le même code , ça ne redémarre pas ?
Et pourriez vous me dire la raison de l'affichage de de "S " ( S et un espace ) en haut à gauche ?

Merci beaucoup d'avance pour toute réponse .

Je crois que c'est un probléme trop compliqué à résoudre... si c'est le cas je vais poser la question sur des forums de développement d'os ( en anglais ) .

PS : j'ai ajouté return(0) mais en programmation OS , le kernel ne se termine jamais ( ainsi que le MBR ) , donc inutile de faire un return !

**gege2061** · 18/07/2006, 13h00

Envoyé par bouazza92

Je crois avoir trouvé la cause du redémarrage ( mais pas encore le S et le blanc ... ) , en effet , je crois qu'en déclarant une seule fonction dans le code ( kernel_main ) , ça ne redémarre plus , mais si on déclare deux ou plus , ça redemarre sans cesse !

ça s'appel un comportement indéfini, il doit y avoir une erreur quelque part (à part l'adresse de la mémoire vidéo, je ne vois pas d'erreur possible

).

Envoyé par bouazza92

PS : j'ai ajouté return(0) mais en programmation OS , le kernel ne se termine jamais ( ainsi que le MBR ) , donc inutile de faire un return !

Oui c'est bien ce que j'ai dit mais normalement ton compilateur devrait te sortir une erreur si le prototype de la fonction n'est pas respecté.

**Mayti4** · 18/07/2006, 13h05

tmp.o, c'est ton bootstrap ?

Essaies ceci pour le linker:

Code :

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

1
2
 
ld -T link.ld -o kernel.bin tmp.o kernel.o

Le fichier link.ld:

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
OUTPUT_FORMAT("binary")
ENTRY(tmp)
SECTIONS
{
    .text 0x20000 :	
    {
	code = .; _code = .; __code = .;
	*(.text)
    }
    .data :
    {
	data = .; _data = .; __data = .;
	*(.data)
    }
    .bss :
    {
	bss = .; _bss = .; __bss = .;
	*(.bss)
	*(COMMON) /* GNU C "common" variables */
    }
    end = .; _end = .; __end = .;
}

**bouazza92** · 18/07/2006, 13h19

tmp.o est l'executable PE produit par ld , puis , j'extrait uniquement le code binaire avec objcopy .

Et puis , ça posera une erreur si je fais 0x20000 ? car dans un tutoriel de création d'os , il y est écrit de linker avec -Ttext 1000

Mais c'est quoi un bootstrap ?

**bouazza92** · 18/07/2006, 13h32

Ta technique de linkage peut bien marcher sous Linux , mais pas sous Windows , car ça me donne le message PE Operations on non PE file !
J'utilise la technique décrite sur ce site http://www.hexanium.com/hexatronic/o..._c_compile.htm

Bon laissons le mauvais affichage des caractéres à coté , et dites moi s'il vous plait pourquoi ça redémarre sans cesse si deux ou plus de fonctions sont déclarées ? ça n'a aucun rapport avec l'adresse de la mémoire vidéo à mon avis .
Et puis , je mets 1000 car le kernel est initialisé ( par mon secteur de boot ) à l'adresse 0x1000 et ld suppose par défaut le code commence à l'adresse 0 !

Merci d'avance .

**Médinoc** · 18/07/2006, 13h35

C'est peut-être une c*nnerie, mais as-tu essayé ceci:

Code C :

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
void ecrire(void);
 
int kernel_main(void)
{
	ecrire();
	while(1);
	return(0);
}
 
 
void ecrire(void)
{
  	unsigned char *fb;
 
	fb = (unsigned char *)0xB8000 ;
	fb[0] = 'H';
	fb[1] = 0x07;
	fb[2] = 'E';
	fb[3] = 0x07;
	fb[4] = 'L';
	fb[5] = 0x07;
	fb[6] = 'L';
	fb[7] = 0x07;
	fb[8] = 'O';
	fb[9] = 0x07;
}

**Mayti4** · 18/07/2006, 13h37

Envoyé par bouazza92

tmp.o est l'executable PE produit par ld , puis , j'extrait uniquement le code binaire avec objcopy.

Tu peux créer un fichier binaire directement.

Mais c'est quoi un bootstrap ?

Ton programme qui lance le kernel, tu utilises quoi ?

Et puis , ça posera une erreur si je fais 0x20000 ? car dans un tutoriel de création d'os , il y est écrit de linker avec -Ttext 1000

Penses pas non, tu peux mettre 1000.

**bouazza92** · 18/07/2006, 13h41

Envoyé par Médinoc

C'est peut-être une c*nnerie, mais as-tu essayé ceci:

Code C :

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
void ecrire(void);
 
int kernel_main(void)
{
	ecrire();
	while(1);
	return(0);
}
 
 
void ecrire(void)
{
  	unsigned char *fb;
 
	fb = (unsigned char *)0xB8000 ;
	fb[0] = 'H';
	fb[1] = 0x07;
	fb[2] = 'E';
	fb[3] = 0x07;
	fb[4] = 'L';
	fb[5] = 0x07;
	fb[6] = 'L';
	fb[7] = 0x07;
	fb[8] = 'O';
	fb[9] = 0x07;
}

ça marche bien , merci !!!
une explication s'il vous plait ?

Merci beaucoup beaucoup d'avance !

**Médinoc** · 18/07/2006, 13h47

L'explication, c'est que le compilateur/linker/etc. est un peu bête, et qu'il exige que le point d'entrée soit au début du code.

Résultat, il FAUT que le code commence par kernel_main, sinon il n'aime pas.

Je ne sais même pas si ça peut ou non marcher (ni même si c'est déterministe) si tu essaies de la compilation séparée...

**bouazza92** · 18/07/2006, 13h48

Envoyé par Mayti4

Tu peux créer un fichier binaire directement.

Ton programme qui lance le kernel, tu utilises quoi ?

Penses pas non, tu peux mettre 1000.

T'as visité le lien sur mon post ? je veux dire celui pour compiler une binaire plate sous windows .
tmp.o n'est pas le bootloader !
bon mon secteur de boot est en ASM ( impossible d'écrire autrement ) , voilà son code :

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
%define	BASE	0x100	; 0x0100:0x0 = 0x1000
%define KSIZE	1 
 
[BITS 16]
[ORG 0x0]
 
jmp start
%include "text.asm"
start:
	mov [bootdrv],dl	; recuparation de l'unite de boot
 
; initialisation des segments en 0x07C0
	mov ax,0x07C0
	mov ds,ax
	mov es,ax
	mov ax,0x8000	; stack en 0xFFFF
	mov ss,ax
	mov sp, 0xf000
 
; affiche un message
	mov si,msgDebut
	call afficher
 
; charger le noyau
	xor ax,ax
	int 0x13
 
	push es
	mov ax,BASE
	mov es,ax
	mov bx,0
	mov ah,2
	mov al,KSIZE
	mov ch,0
	mov cl,2
	mov dh,0
	mov dl,[bootdrv]
	int 0x13
	pop es
 
; initialisation du pointeur sur la GDT
	mov ax,gdtend	; calcule la limite de GDT
	mov bx,gdt
	sub ax,bx
	mov word [gdtptr],ax
 
	xor eax,eax		; calcule l'adresse lineaire de GDT
	xor ebx,ebx
	mov ax,ds
	mov ecx,eax
	shl ecx,4
	mov bx,gdt
	add ecx,ebx
	mov dword [gdtptr+2],ecx
 
; passage en modep
	cli
	lgdt [gdtptr]	; charge la gdt
	mov eax,cr0
	or ax,1
	mov cr0,eax		; PE mis a 1 (CR0)
 
	jmp next
next:
	mov ax,0x10		; segment de donne
	mov ds,ax
	mov fs,ax
	mov gs,ax
	mov es,ax
	mov ss,ax
	mov esp,0x9F000	
 
	jmp dword 0x8:0x1000    ; reinitialise le segment de code
 
;--------------------------------------------------------------------
bootdrv: db 0
msgDebut	db	"Chargement du Kernel ...",10,0
 
;--------------------------------------------------------------------
gdt:
	db 0,0,0,0,0,0,0,0
gdt_cs:
	db 0xFF,0xFF,0x0,0x0,0x0,10011011b,11011111b,0x0
gdt_ds:
	db 0xFF,0xFF,0x0,0x0,0x0,10010011b,11011111b,0x0
gdtend:
 
;--------------------------------------------------------------------
gdtptr:
	dw	0	; limite
	dd	0	; base
 
 
;------------------------------------------------------------------------------------------------------------------------------------------------
;; Rempli l'espace restant avec des NOP ( NO Operation ) pour que le binaire fait 512 octets ( taille d'un secteur )
times 510-($-$$) db 144
dw 0xAA55

Le secteur de boot fait 512 octets , et le kernel devra faire une cinquantaine d'octets , donc je suppose qu'il peut bien être placé dans le deuxiéme secteur de la disquette , et mon bootloader charge ce secteur dans l'adresse mémoire 0x1000 , puis il passe en mode protégé car mon kernel est en 32 bits , et fais un jmp vers 0x8:0x1000 où est chargé le secteur contenant le kernel .
Aprés avoir produit la binaire avec NASM , vous devez faire quelque chose comme :

Code :

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

1
2
 
 cat bootsect kernel.bin /dev/zero | dd of=floppy bs=512 count=2880

bootsect étant le binaire produit par nasm et kernel.bin le binaire produit par objcopy .
Vous allez avoir l'image disquette floppy que vous allez utiliser avec l'émulateur PC BOCHS .

Bon , merci beaucoup beaucoup beaucoup pour toute participation sur ce topic !

**bouazza92** · 18/07/2006, 13h54

Envoyé par Médinoc

L'explication, c'est que le compilateur/linker/etc. est un peu bête, et qu'il exige que le point d'entrée soit au début du code.

Résultat, il FAUT que le code commence par kernel_main, sinon il n'aime pas.

Je ne sais même pas si ça peut ou non marcher (ni même si c'est déterministe) si tu essaies de la compilation séparée...

Euh je prévois bien la compilation séparée NASM+C ( pour faire quelques opérations sans risque avec NASM car le C me fait ramer avec les pointeurs) , C+C ...
Quand l'erreur va se produire , je vais penser à ce que tu m'as dit , désassembler le binaire pour voir par quoi ça débutte ( main ou autre code ... ) .

Merci beaucoup pour vos réponses plus qu'intéressantes car même si certains de vous n'ont pas donné des réponses qui peuvent corriger mon probléme , j'ai au moins appris qu'il faut faire toujours des returns , '\0' pour augmenter la compatibilité avec certains compilateurs ( gcc ne produisait aucune erreur si je ne fait pas de return

) .

**bouazza92** · 18/07/2006, 14h01

Bon il ne reste plus qu'à corriger le probleme de chars .
voilà mon code C :

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
void ecrire(const char*);
 
int kernel_main(void)
{
	ecrire("Bonjour tout le monde !");
	while(1);
	return(0);
}
 
 
void ecrire(const char* msg)
{
	unsigned char *fb;
	int i=0, pos=0;
	fb = (unsigned char *)0xB8000 ;
	while(msg[i]!='\0'){
		fb[pos++]=msg[i++];
		fb[pos++]=0x07;
	}
}

**millie** · 18/07/2006, 16h53

désassembler le binaire pour voir par quoi ça débutte

T'as essayé de compiler avec l'option -S pour avoir directement le code assembleur avant la compilation en binaire.

**bouazza92** · 19/07/2006, 13h33

Salut ,

merci pour ta réponse , je vais y penser quand ça recommence à redémarrer ( plus pratique que de désassembler le programme ! ) .

Mais peut quelqu'un m'aider à résoudre le probléme avec les chars ?

Merci d'avance .

PS : désolé pour le retard , je ne prend le pc que de 7h à 12h

**Médinoc** · 19/07/2006, 13h51

Tu peux nous rappeler ce que c'est, "le problème avec les chars", s'il te plait ?
Même en repassant la discussion je n'arrive pas à voir de quel problème tu parles...

**bouazza92** · 19/07/2006, 13h56

Salut ,

merci pour votre réponse , en effet , je veux dire qu'au lieu d'afficher "Bonjour tout le monde !" ( sans les guillemets ), ça affiche un S suivi d'un espace vide , c'est à dire "S " ( sans les guillemets ) .

Merci d'avance .

**Médinoc** · 19/07/2006, 14h04

Ah, je croyais que c'était résolu.
Tu es sûr que l'écran texte se trouve bien à cette adresse en mode 32bits ?
Je me souviens que c'était le cas en 16bits (B800:0000), mais je n'ai jamais programmé à bas niveau en 32bits...

Et comme dit plus haut, fais gaffe à tes '++'...

**bouazza92** · 19/07/2006, 14h11

Envoyé par Médinoc

Ah, je croyais que c'était résolu.
Tu es sûr que l'écran texte se trouve bien à cette adresse en mode 32bits ?
Je me souviens que c'était le cas en 16bits (B800:0000), mais je n'ai jamais programmé à bas niveau en 32bits...

Et comme dit plus haut, fais gaffe à tes '++'...

Et beh en mode 32 bits , rien ne change que le fait qu'il y a de nouveaux registres 32 bits et que les interruptions soient inutilisables .
Même si c'était le cas , comment m'expliquerais-tu l'écriture de HELLO à l'écran avec mon précedent exemple ?

Et puis , logiquement , les ++ ne feront pas d'erreur , car par exemple i++ incrémente i de 1 mais retourne la valeur de i avant l'incrémentation !
Ce sont les ++ avant une variable qui vont causer l'erreur ( comme ++i ) !

Comment faites vous pour accéder sans probléme aux caractéres d'un char dont sa taille peut varier ( donc vous ferez une boucle du genre while(*i!='\0') ) dans une boucle ?

Merci d'avance .

**fearyourself** · 19/07/2006, 14h16

Comme test, je ferais plutôt :

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
void ecrire(const char*);
 
int kernel_main(void)
{
	ecrire("HELLO");
	while(1);
	return(0);
}
 
 
void ecrire(const char* msg)
{
	unsigned char *fb;
	int i=0, pos=0;
	fb = (unsigned char *)0xB8000 ;
	while(msg[i]!='\0'){
                fb[pos]=msg[i];
                pos++;
                i++;
		fb[pos]=0x07;
                pos++;
	}
}

Jc

Probléme d'execution de mon Kernel perso

C

Discussions similaires

Partager

Partager