Simuler un noyau en mode user

Bonjour à tous !

Je suis en train de me creuser la tête, et à force de creuser, je me dis que je ne vois plus que mon petit doigt, et que je dois certainement passer à côté de ma solution.
Mon problème :

Je souhaite "simuler" le comportement d'un noyau en mode user (je suis sous Linux, mais ce qui m'importe est vraiment lié au C). En gros, j'ai une application, qui va créer des threads, et ceux-ci doivent être connus par le "noyau" en question. Il va donc stocker les différents paramètres liés aux threads dans une liste chaînée, etc.

Mon soucis tient à la communication entre les threads et ce noyau : je veux avoir une API qui soit visible par les threads, celle-ci ayant un comportement propre (boucle en permanence, etc.).

Un schéma, si j'y arrive :

Code:

---

1 2 3

T1 ---> appel_fonction() ------> "noyau" ---> appels systèmes T2 ---> appel_fonction() __| T3 <--- retour ------------|

---

Je voudrais donc simuler le comportement des appels systèmes faits par une application vers le noyau mais en mode user...

J'espère que c'est suffisament clair ? Là où je coince, c'est API, librairie, etc. Je ne vois pas comment m'en sortir.

Merci d'avance !

tu ne parlerai pas plutôt d'un ordonnanceur (scheduler) ?

En fait, oui, ce que je décris est le scheduler. Mais mon problème est plus large que cela.
Le problème des librairies, c'est que c'est une copie par processus.
Donc, je peux pas avoir plusieurs processus qui dialoguent à travers une seule instance de la librairie...
Et là, je coince, car avoir de la mémoire partagée et des mutex pour gérer les structures communes, ça m'embête...

je ne comprend pas ta question, de quelles lib tu parle ?
ou qu'entend tu par librairie ?
la communication entre threads peut se faire de plusieurs façons (message box, sémaphores, mutex, évènements...)

Je pensais que mon premier post précisait justement mon problème...

je comprend ce que tu souhaite faire, mais je ne comprend pas quel est ton problème...
qu'entend tu par:

Citation:

---

Envoyé par progfou

Là où je coince, c'est API, librairie, etc. Je ne vois pas comment m'en sortir.

---

Je ne sais pas comment le faire. Offrir une API pour les processus ou threads qui vont en avoir besoin... Une librairie est chargée par chaque processus, et donc, c'est une copie de ce "noyau", pas un processus ayant sa vie...

Finalement, ma seule question est : comment je peux faire ça ?

oui, pour simuler un noyau, effectivement il te faudra mettre en place une api disponible pour les processus (et certainement pas une lib)
apres si tu compte ne t'occuper que des appels systèmes (pas des histoires de scheduler, user space/kernel space etc...)
tu peut t'inspirer de ce qui se fait sous linux par exemple...
pour rappel:

un appel système va placer son numéro dans un registre (AX), le numero du majeur (driver correspondant) , le mineur (instance), puis lever une interruption pour signaler au noyau qu'un appel system est demandé.
le noyau regarde alors le registre, et execute la fonction demandée...

tu pourra t'en inspirer en utilisant une variable globale a la place du registre AX
et les signaux a la place de l'interruption.

j'espère que ça t'aide... mais je t'avoue ne pas comprendre exactement ton problème...

Citation:

---

Envoyé par kamouminator

oui, pour simuler un noyau, effectivement il te faudra mettre en place une api disponible pour les processus (et certainement pas une lib)

---

C'est cela que je ne comprends pas... Comment on fait ?

bah tu crée un fichier .c et un .h et tu y defni et déclare tes fonctions...c'est tout !

ou alors j'ai toujours pas compris ton problème !
...qu'on soit bien d'accord, ce que tu souhaite c'est bien faire une simulation d'OS dans un même binaire ou ton noyau sera représenté par un thread et tes processus par d'autre threads ?

Non, je le redis, je l'ai sans doute mal expliqué :
J'ai plusieurs processus (et threads) différents, qui doivent tous communiquer et être géré par un autre qui offre à ceux-ci une API.

On n'est donc pas sur un système avec un seul processus, sinon c'est simple.
Je ne vois pas la différence entre une API et des librairies.
Je parle au niveau implémentation.

ok je comprend mieux, il te faudra donc utiliser les IPC pour faire communiquer tes processus entre eux
les tubes només, DBus (linux), memoire partagée, COM/DCOM (windows)...

concernent la différence API/librairie, je dirais qu'une API fourni un ensemble de fonction a l'utilisateur pour utiliser un certain "composant"

une lib, c'est juste un ensemble de fonction précompilées

on pourrait aussi dire qu'une API permet de spécifier à une application comment utiliser la lib...

coté implémentation il n'y a pas vraiment de différence, c'est a la compilation que tu va dire si tes fonctions doivent etre compilées en lib ou directement liées a ton/tes binaires.
dans ton cas, tu pourrait créer une lib permettant la communication entre tes processus.
chaque binaire sera lié a cette lib pour pouvoir appeler les fonction d'IPC que tu aura mis en place.

OK, j'avais donc bien compris et c'est ce que je projetais de faire.
Merci !