Discussion :

[voyager57]

Bonjour, je me présente : je suis romain, actuellement étudiant en informatique et dans le cadre d'un projet je dois réaliser un petit noyau d'un système d'exploitation. Dans ces système d'exploitation je dois gérer la gestion des processus. C'est l'étape où je suis actuellement.

J'arrive à créer un processus à partir du code d'une fonction, quand celle-ci est void et sans argument, mais maintenant je veux des arguments en plus, mais je ne sais pas comment trouver ces derniers ( surtout qu'il faut instancier la fonction non ?) et comment les envoyer au processus ?

pour info voici ma structure de processus :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
enum etat {ACTIF,ACTIVABLE,DORT,BLQ_SEM,BLQ_ES,BLQ_FILS,ZOMBIE,MORT};
typedef enum etat etat;
 
struct struct_proc{
	char nom[T_NOM_PROC];
	int pid;
	int tab_zone_sauv[TAILLE_TAB];
	int tab_pile_exec[TAILLE_PILE];
	unsigned int reveil; //date du reveil du pocessus
	etat e;
	int priority;
};

typedef struct struct_proc struct_proc;


et voici ma fonction qui va créer un processus ( l'instancier ) :

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
 
//int start(void (*pt_func)(void*), unsigned long ssize, int prio, const char *name, void *arg){
int start(void (*pt_func)(void*), int prio, const char *name, void *arg){
	//on a l'adresse de la fonction, on veut juste créer le processus :
	//On cherche un pid libre :
	pid_libre=rechercher_pid_libre();
	if(pid_libre == -1){
		//printf("erreur, pas de pid libre");
		return -1;
	}
	else if(strlen(name) > T_NOM_PROC){
		//erreur, le nom donné au processus est trop long
		//printf("erreur, nom de processus trop long");
		return -1;
	}
	else{
		strcpy(tab_proc[pid_libre].nom,name);
		tab_proc[pid_libre].pid = pid_libre;
		tab_proc[pid_libre].priority = prio;
		//doit être ACTIF si prio > prio du père ...
		tab_proc[pid_libre].e = ACTIVABLE;
		tab_proc[pid_libre].tab_zone_sauv[0] = (int)(tab_proc[pid_libre].tab_pile_exec+TAILLE_PILE-2);
		tab_proc[pid_libre].tab_pile_exec[TAILLE_PILE-3] = (int)arg;//ici j'ai un doute je ne sais pas où les mettre dans la pile
		tab_proc[pid_libre].tab_pile_exec[TAILLE_PILE-2] = (int)(pt_func);	
		tab_proc[pid_libre].tab_pile_exec[TAILLE_PILE-1] = (int)(&(fin));
	}	
	return 0;
	//tout s'est bien passé
}

et celle qui instancie, suivi des fonctions que j'utilise en exemple :

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
 
void init_proc(void){
//fonction de test qui nous permet de faire 6 autre processus sur proc1->3 
	tab_fonction[1]=(int)&proc1;
	tab_fonction[2]=(int)&proc2;
	tab_fonction[3]=(int)&proc3;
 
	char nom_processus[60];
	char nom_fonction[60];
 
	for(int k=1;k<3;k++){
		sprintf(nom_processus,"processus_%d",k);
		sprintf(nom_fonction,"fonction%d",k%3+1);
		if(start((void*)tab_fonction[k%3+1],1,nom_processus,NULL) == -1)
			printf("erreur d'allocation du proc, pid non libre ou nom trop long");
		else 
			printf("proc de pid %d cree avec la fonction %s\n",tab_proc[pid_libre].pid,nom_fonction);
	}
	start((void*)tab_fonction[3],1,"test3",(void*)12);
	//tab_proc[4].e = DORT;
	//tab_proc[4].reveil = 9;
}
 
 
 
 
 
void fin(void){
  printf("\n\tfin du proc de pid %d\n",mon_pid());
  tab_proc[mon_pid()].e = MORT;
  tab_proc[mon_pid()].pid = -1;
  nbr_proc--;
  ordonnance();
}
 
void idle(void)
{		
  for (;;) {
    sti();
    hlt();
    cli();
  }
}
 
void proc1(void) {
  for(int k=0;k<5;k++){
    printf("A\t"); /* l'autre processus doit afficher des 'B' */
    sti(); /* demasquage des interruptions */
    /* une ou plusieurs it du timer peuvent survenir pendant cette boucle d'attente */
    sleep(3);
    cli(); /* masquage des interruptions */ 
  }
}
 
void proc2(void) {
  unsigned long i;
  for(int k=0;k<5;k++){
    printf("B\t"); /* l'autre processus doit afficher des 'B' */
    sti(); /* demasquage des interruptions */
    /* une ou plusieurs it du timer peuvent survenir pendant cette boucle d'attente */
    for (i = 0; i < 5000000; i++); 
    cli(); /* masquage des interruptions */	
  }
}
 
void proc3(int c) {
  unsigned long i;
  for(int k=0;k<5;k++){
    printf("%d\t",c); /* l'autre processus doit afficher des 'B' */
    sti(); /* demasquage des interruptions */
    /* une ou plusieurs it du timer peuvent survenir pendant cette boucle d'attente */
    for (i = 0; i < 5000000; i++); 
    cli(); /* masquage des interruptions */	
  }
}

Si quelqu'un a une idée, ou si il peut me rediriger vers des tuto de création de noyau niveau processus ... je lui serait reconnaissant car même sue google j'en pas trouvé beaucoup, ça touche pas assez de monde pour être référencé ça

[Metalman]

Pour le moment... ce qui m'étonne... c'est la présence de printf/snprintf dans un noyau... mais bon... pourquoi pas ! xD

Dans la fonction qui va créer le processus... je vois un argument :

void *arg)

(le dernier apparemment)
Ne serait-ce pas lui qui contient une file d'argument ? (probablement terminée par NULL ?)
Car sinon je peux juste te dire que les x86 empilent le contexte courant, puis les arguments, et la fonction appelée dépile ce qui lui est nécessaire... mais ça c'est juste pour "une fonction".
Et juste en réfléchissant tard le soir, argc/argv pourraient être une bonne piste pour passer des arguments à un processus

Tu devrais lire les A. Tanenbaum pour la théorie, et un peu de doc Intel pour la pratique sur les x86 et x64.
Doc Intel
Il y a les 3 volumes les plus intéressants là dedans (séparés en 7 bouquins il me semble)

[voyager57]

Pour le moment... ce qui m'étonne... c'est la présence de printf/snprintf dans un noyau... mais bon... pourquoi pas ! xD

Ben en fait, on a recodé toute la fonction dans un autre fichier que j'ai appelé printf.c et printf.h avec ses dérivées ça a pris pas mal de temps XD mais j'en avais pas mal besoin aussi sinon c'est lourd ... je peux te montrer le code si tu veux.

Dans la fonction qui va créer le processus... je vois un argument : (le dernier apparemment)
Ne serait-ce pas lui qui contient une file d'argument ? (probablement terminée par NULL ?)
Car sinon je peux juste te dire que les x86 empilent le contexte courant, puis les arguments, et la fonction appelée dépile ce qui lui est nécessaire... mais ça c'est juste pour "une fonction".
Et juste en réfléchissant tard le soir, argc/argv pourraient être une bonne piste pour passer des arguments à un processus

Ouai, en fait hier dans la soirée j'ai un peu avancé ^^, et en effet tu as raison pour l'empilement ! je en savais pas trop où mettre les arguments mais après avoir essayé plein d'endroit ça marche lorsque je les mets après la fonction fin (celle qui termine le processus) donc c'est en premier le code de la fonction, suivi du code de la terminaison puis des arguments, bon pour le moment ça ne marche qu'avec un seul, maintenant je dois passer une liste je suppose comme tu m'as dit, mais une liste d'élément de taille variable ( int -> char -> long -> int* etc... ) j'ai pas encore réussi je vais m'attaquer à ça.

et pour le Tanenbaum, ce beau livre de 1052 pages repose bien à porté de main =D je le consulte assez souvent, mais j'ai celui qui parle des systèmes d'exploitation en général, j'ai vu qu'il y en avait un qui parlait de l'implémentation des OS avec le code de MINIX, dès que la bibliothèque ouvre demain je fonce le chercher mais je pense que j'aurais toujours des questions !



Tu devrais lire les A. Tanenbaum pour la théorie, et un peu de doc Intel pour la pratique sur les x86 et x64.
Doc Intel
Il y a les 3 volumes les plus intéressants là dedans (séparés en 7 bouquins il me semble)

[Metalman]

Bon bah si tu les as recodé, pas de problème.
C'est juste qu'utiliser les même noms que les fonctions en userland... c'est assez déconseillé il me semble (mieux vaudrait un k_printf, k_snprintf...), mais comme ça restera "probablement" un exercice laisse comme ça (sinon tu vas perdre du temps de travail + debug pour pas grand chose).

Après....
Avec tout ce que tu dis, si je ne me trompe pas, on a donc tout en bas de la pile le code, puis l'@ retour, puis les arguments...
Et je crois que c'est ça en effet. :o
Alors comme tu parles de charger un processus, et pas simplement une fonction...
Je ne vais pas trop m'avancer plus.

Les bouquins devraient t'aider amplement plus que moi !
Bon courage pour la suite !