IFT2245 - Systèmes d exploitation - TP n 1-20%

IFT2245 - Systèmes d exploitation - TP n 1-20% DIRO - Université de Montréal Nicolas Rous et Dorian Gomez Disponible : 14/02/2013 - Remise : 28/03/2013 au début de la démo LISEZ TOUT LE DOCUMENT AVANT DE COMMENCER LE TRAVAIL. 1 Introduction Dans ce TP, vous devrez implémenter en langage C un module de kernel qui offre une partie des services qu un système d exploitation de base pourrait offrir. Ce module devra organiser une liste de tâches, les traiter par ordre de priorité et sauvegarder un fichier de log. Le module devra réussir à traiter l ensemble des commande le plus rapidement possible. Prêts? C est parti! 2 Mise en place Pour ce tp, il faudra utiliser une machine virtuelle afin de ne pas crasher votre propre système. De plus, pour ceux qui souhaitent travailler sur une machine de l université vous ne pourriez pas bénéficier des droits administrateurs nécessaires au chargement d un module de kernel Virtualbox fonctionne très bien autant sous Windows que sous linux, notamment pour la restauration du système d exploitation client à son état précédent. Toutefois faites bien attention à sauvegarder votre travail régulièrement sur une autre partition que celle de votre VM, ou par copie ssh (scp), car il se peut que dans une tentative désespérée de compiler et charger votre module vous ne fassiez planter définitivement le système d exploitation client (pas votre propre machine, je vous rassure), et perdiez vos fichiers. Voici Les instructions d installation : 2.1 Sur votre ordinateur personnel Suivez les instructions à l adresse : http://people.westminstercollege.edu/faculty/ggagne/osc/vm/index.html Téléchargez le disque dur debian en local (prévoir 8Go d espace libre). Téléchargez et installez la machine virtuelle debian fournie sur le site. 2.2 Sur un poste de l université VirtualBox, ainsi qu une image de disque virtuel TinyCore et un script de préparation sont installés sur les postes du troisième (3181 et 3189). Etape 1: Exécuter la commande prepvbox sur le poste ou l on veut utiliser virtualbox. Etape 2: Démarrer virtualbox pour réaliser la configuration initiale de virtualbox : Lors de l introduction de VirtualBox dans l onglet File, choisir Preferences. Dans la rubrique Général, modifier la boite Default Machine Folder par /Vbox/ usager. Dans la rubrique Update, décocher Check for updates. Etape 3: Ajout de la machine virtuelle. Dans l onglet Machine, choisir +add. Chercher dans le répertoire /Vbox/<usager>/Tiny/...nom image.vbox le fichier de disuqe à utiliser. 1

Etape 4: Démarrer la machine avec la fleche verte (Start). L étape 1 permet de réinitialiser la machine virtuelle (attention, cela écrase votre disque, pensez à sauvegarder votre travail avant par copie scp). L étape 4 permet de lancer la machine virtuelle. A l interieur de la machine virtuelle, on peut se connecter à frontal.iro.umontreal.ca (ssh ou scp) pour importer/exporter des données. 2.3 Liens utiles Ressources Site du livre : http://www.os-book.com/ Quelques liens utiles : Machine Virtuelle http://people.westminstercollege.edu/faculty/ggagne/osc/vm/index.html Exemples de base http://people.westminstercollege.edu/faculty/ggagne/osc/index.html Linux Kernel Programming Guide http://linux.die.net/lkmpg 3 Travail à effectuer La structure d une tâche à effectuer contient : la priorité de la tâche le nombre de blocs mémoire contigus à réserver le temps d exécution estimé s t r u c t my task i n t p r i o r i t y ; i n t n b r e q u i r e d m e m o r y b l o c k s ; i n t e s t i m a t e d e x e c t i m e ; La liste des tâches à traiter (my waiting tasks) et l espace total de mémoire disponible pour le module (my memory blocks) sont initialisés au chargement du module. #d e f i n e NB TASKS 100 my task m y w a i t i n g t a s k s [ NB TASKS ] ; #d e f i n e NB MEMORY BLOCKS 10 i n t my memory blocks [NB MEMORY BLOCKS ] ; Afin d implémenter le module de kernel vous devrez, dans le code du chargement du module : Créer un processus scheduler long term qui va récupérer la liste de tâches, les organiser par niveaux de priorité (il y en a trois de base) et préparer les prochaines tâches à exécuter, selon leur nombre de blocs mémoire (nb required memory blocks) et ainsi maximiser l utilisation de la mémoire globale (NB MEMORY BLOCKS), sans la dépasser évidemment. Créer un processus memory manager qui gère toutes les demandes d allocation mémoire des processus usagers. Ce processus est responsable de la gestion du tampon (ou buffer) my memory blocks. Il réserve donc nb required memory blocks blocs contigus dans ce buffer pour chacune des tâches pour la durée de son éxécution. Les blocs ainsi alloués pour une tâche doivent être désalloués et rendus disponibles pour les tâches suivantes. 2

Créer un processus scheduler short term qui récupère la liste des tâches ordonnées par le scheduler long term précédemment et qui les exécute de manière efficace. Pour simuler l exécution d une tâche utilisez la fonction simulate task thread function(...), déjà définie dans le fichier my kernel module.c fourni en annexe. Dans le code de déchargement du module, vous devrez: Attendre la fin de tous les processus ou les interrompre. Terminer tous les processus de manière propre à ce qu aucun processus zombie ne reste. Utiliser la commande console > ps -A ou > ps -A grep nom du thread pour vérifier les processus qui restent actifs après le déchargement du module, si cette liste contient des entrées, c est que vous avez des processus zombies encore actifs, ou en attente. Vous pouvez les tuer avec la commande killall nom du processus zombie (visez bien la tête! :). 3.1 Question 1 Pourquoi deux schedulers sont utilisés pour ce projet? Que risque-t-il de se passer si NB TASKS devient grand (e.g., 100000)? Comment éviter ce problème? Implémentez votre solution. 3.2 Question 2 Quelle est la contrainte de scheduling de ce module de kernel? (indice : NB MEMORY BLOCKS) Dans quel type d installation la recommanderiez-vous? Quelles sont les stratégies supplémentaires que vous avez choisi de mettre en oeuvre? Optionnel (+3%) : Quelle sont les modifications à apporter aux processus pour limiter les deadlocks? Codez-le. 4 Documentation fournie Attention, vous êtes en mode kernel et les librairies disponibles ne sont pas les mêmes qu en mode user. Les principaux fichiers d entête sont disponibles dans le dossier /usr/src/linux-2.6.39.4/include/linux ou /usr/src/linux-header-3.0.21-tinycore/include/linux, vous devrez alors déterminer la manière d utiliser ces fonctionnalités. Les fonctionnalités de base pour la compilation, le chargement, l affichage du log du module de kernel ou sa destruction sont disponibles en annexe dans les fichiers script de chargement.sh, Makefile et my kernel module.c. Quelques fonctions de base du mode Kernel sont également fournies en annexe. Pour le reste : API du kernel de Linux http://www.kernel.org/doc/htmldocs/kernel-api/ Autre lien utile http://www.makelinux.net/kernel map/ Et ne vous limitez pas au premier résultat donné par google. Bonne chance! 5 Format des documents à remettre Vous devrez remettre vos fichiers corps *.c, entêtes *.h, script de chargement.sh et rapport NOM PRENOM IFT2245 2013 TP1.pdf dans une archive NOM PRENOM IFT2245 2013 TP1.tar.gz et l envoyer sur StudiUM. 3

6 Notation L ensemble du travail réalisé sera évalué : logique de programmation, rigueur d écriture du code et du rapport, organisation des fonctionnalités et des fichiers ainsi que validité et rapidité d exécution du code. 7 Annexes A Example de fichier script sh pour charger puis décharger votre module Chacune des fonctions de ce fichier peuvent être appelées indépendamment pour faire du pas à pas depuis un terminal, ou toutes en séquence en tapant > sh s c r i p t d e c h a r g e m e n t. sh Copiez-collez le code suivant dans un nouveau fichier script de chargement.sh et modifiez-le à votre convenance avant de l exécuter. #! / b i n / bash c l e a r make c l e a n make i f [ $? eq 0 ] ; then echo [ ] C o m p i l a t i o n S u c c e s s echo [ ] Backup s a v e... sudo cp m y k e r n e l m o dule. c / h o s t s h a r e d r e p / IFT2245 /Backup/ echo [ ] S y n c h r o n i z i n g... sync echo [ ] C l e a r i n g o l d k e r n e l l o g sudo dmesg c > p r e v i o u s k e r n e l. l o g echo [ ] Loading k e r n e l module... sudo insmod m y k e r n e l m o dule. ko echo [ ] L i s t o f l o a d e d k e r n e l modules lsmod grep m y k e r n e l m o dule echo [ ] P r i n t i n g k e r n e l l o g a f t e r l o a d i n g k e r n e l module dmesg echo [ ] Waiting f o r 5 s e c o n d s... s l e e p 5 echo [ ] Removing k e r n e l module sudo rmmod m y k e r n e l m o dule. ko echo [ ] P r i n t i n g k e r n e l l o g a f t e r k e r n e l module removal dmesg e l s e echo [!! ] C o m p i l a t i o n E r r o r! f i B Makefile Copiez-collez le code suivant dans un nouveau fichier Makefile obj m += m y k e r n e l m o d u l e. o a l l : make C / l i b / modules /$ ( s h e l l uname r )/ b u i l d M=$ (PWD) modules c l e a n : make C / l i b / modules /$ ( s h e l l uname r )/ b u i l d M=$ (PWD) c l e a n 4

C Module de kernel my kernel module.c #i n clude <l i n u x / i n i t. h> #i n clude <l i n u x / module. h> #i n clude <l i n u x / k e r n e l. h> #i n clude <l i n u x / k t h r e a d. h> #i n clude <l i n u x / sched. h> #i n clude <l i n u x / p i d. h> #i n clude <l i n u x / l i s t. h> #i n clude <l i n u x / t h r e a d i n f o. h> #i n clude <l i n u x / t i m e r. h> #i n clude <l i n u x / d e l a y. h> #i n clude <l i n u x / workqueue. h> #i n clude <l i n u x / semaphore. h> #i n clude <l i n u x /random. h> // S t r u c t u r e de t a c h e // L a i s s e r au minimum l e s i n f o r m a t i o n s // de base s t r u c t my task i n t p r i o r i t y ; i n t n b r e q u i r e d m e m o r y b l o c k s ; i n t e s t i m a t e d e x e c t i m e ; ; // Tableau c o n t e n a n t t o u t e l e s t c h e s, // i n i t i a l i s e s pseudo a l a t o i r e m e n t. //C e s t l que vous t r o u v e r e z l e s i n f o r m a t i o n s // de t r a i t e m e n t pour une t c h e. // ( Vous p o u r r e z e n s u i t e l e s c o p i e r dans une // s t r u c t u r e de d o n n e de v o t r e c h o i x s i n c e s s a i r e ) #define NB TASK 100 s t r u c t my task m y w a i t i n g t a s k s [ NB TASK ] ; // Les b l o c s m m o i r e u t i l i s s e t /ou non // u t i l i s s. i n t == 0 s i non u t i l i s, 1 s i o u i #define NB MEMORY BLOCKS 10 i n t my memory blocks [NB MEMORY BLOCKS ] ; // V a l e u r s pseudo a l a t o i r e pour i n i t i a l i s e r // l e s temps d a t t e n t e a c t i v e du t r a i t e m e n t //d une t c h e. Ne pas m o d i f i e r. #define MAX PRIORITY LEVEL 3 #define MAX TASK EXECUTION TIME 100 s t a t i c i n t seedn0 = 7 1 ; s t a t i c i n t seedn1 = 9 7 ; s t a t i c i n t maxrandomvalue = 100; i n t g e t r a n d o m f i b o n a c c i ( i n t mod) i n t next = ( seedn0 + seedn1)%maxrandomvalue ; seedn0 = seedn1 ; 5

seedn1 = next ; return next%mod ; p t a s k s [ i ]. n b r e q u i r e d m e m o r y b l o c k s = g e t r a n d o m f i b o n a c c i (NB MEMORY BLO // F o n c t i o n d i n i t i a l i s a t i o n des d o n n e s // V e u i l l e z ne pas m o d i f i e r c e t t e f o n c t i o n // a i n s i que son a p p e l dans l e chargement // de module. i n t i n i t ( s t r u c t my task p t a s k s ) //Ne pas m o d i f i e r c e t t e f o n c t i o n unsigned i n t i ; f o r ( i = 0 ; i <NB TASK ; ++i ) p t a s k s [ i ]. p r i o r i t y = g e t r a n d o m f i b o n a c c i (MAX PRIORITY LEVEL ) ; p t a s k s [ i ]. e s t i m a t e d e x e c t i m e = g e t r a n d o m f i b o n a c c i (MAX TASK EXECUTION return 0 ; // V a r i a b l e c o n t e n a n t l e temps d e p u i s l a f i n // de l i n i t i a l i s a t i o n des d o n n e s s t a t i c s t r u c t t i m e v a l nano0 ; // F o n c t i o n de s i m u l a t i o n d un t c h e, que vous d e v r e z a p p e l e r // une f o i s s u r chacune des t c h e s i n t s i m u l a t e t a s k t h r e a d f u n c t i o n ( s t r u c t my task ptask, i n t mem addr ) // E c r i r e dans l a memoire a l l o u e e i n t i ; s t r u c t t a s k s t r u c t c u r r e n t t a s k = g e t c u r r e n t ( ) ; f o r ( i =0; i <ptask >n b r e q u i r e d m e m o r y b l o c k s ;++ i ) mem addr [ i ]= c u r r e n t t a s k >p i d ; //Ne pas m o d i f i e r d i r e c t e m e n t c e t t e f o n c t i o n s t r u c t t i m e v a l nano1 ; long i n t d i f f ; mdelay ( ptask >e s t i m a t e d e x e c t i m e ) ; d o g e t t i m e o f d a y (&nano1 ) ; d i f f = ( nano1. t v s e c nano0. t v s e c ) 1 0 0 0 ; d i f f+= ( nano1. t v u s e c nano0. t v u s e c ) / 1 0 0 0 ; p r i n t k ( S i m u l a t e d t a s k e x e c u t i o n : waited f o r %d ms : Time s i n c e s t a r t o f s c h e d u msec \n, ptask >e s t i m a t e d e x e c t i m e, d i f f ) ; // V e r i f i e r que l e s donnees n ont pas e t e m o d i f i e e s pendant l a t t e n t e f o r ( i =0; i <ptask >n b r e q u i r e d m e m o r y b l o c k s ;++ i ) i f ( mem addr [ i ]!= c u r r e n t t a s k >p i d ) p r i n t k ( Memory l e a k \n, ptask >e s t i m a t e d e x e c t i m e, d i f f ) ; break ; 6

return 0 ; / Cette f o n c t i o n e s t a p p e l e e l o r s du chargement du module / i n t s i m p l e i n i t ( void ) i n t i ; // P r i n t i n t o the k e r n e l l o g f i l e p r i n t k (KERN INFO Loading Module\n ) ; // Tasks i n i t i a l i s a t i o n. Ne pas m o d i f i e r. i n i t ( m y w a i t i n g t a s k s ) ; d o g e t t i m e o f d a y (&nano0 ) ; // Task e x e c u t i o n s i m u l a t i o n // I c i, l e t r a i t e m e n t des t c h e s e s t r a l i s s q u e n t i e l l e m e n t // par une b o u c l e f o r, ce q u i c o n t r a i n t chaque i t e r a t i o n a t t e n d r e // l a f i n de l a p r c d e n t e. f o r ( i = 0 ; i <NB TASK ; ++i ) i n t f i r s t e l t = 0 ; i n t t a s k f i r s t m e m e l t a d d r =&(my memory blocks [ f i r s t e l t ] ) ; s i m u l a t e t a s k t h r e a d f u n c t i o n (&( m y w a i t i n g t a s k s [ i ] ), t a s k f i r s t m e m e l t return 0 ; / Cette f o n c t i o n e s t a p p e l e e l o r s du decargement du module. / void s i m p l e e x i t ( void ) // P r i n t i n t o the k e r n e l l o g f i l e p r i n t k (KERN INFO Removing Module\n ) ; / Macros d e n r e g i s t r e m e n t des p o i n t s d e n t r e e e t de s o r t i e du module. / m o d u l e i n i t ( s i m p l e i n i t ) ; m o d u l e e x i t ( s i m p l e e x i t ) ; MODULE LICENSE( GPL ) ; MODULE DESCRIPTION( Simple Module ) ; MODULE AUTHOR( SGG ) ; D Commandes console utiles Lister les processus. > ps A Tuer un processus de pid = [pidnum] > k i l l 9 [ pidnum ] Tuer tous les processus portant le nom [nomproc] > k i l l a l l [ nomproc ] Lancer une application dans un autre terminal. 7

> gnome t e r m i n a l x bash c n o m a p p l i c a t i o n param1 param2 [... ] ; bash E Fonctions et structures de données utiles Pointeur vers une structure de processus (sched.h) s t r u c t t a s k s t r u c t t a s k ; Création de thread à partir et mise en attente de lancement : -d un pointeur de fonction ayant pour paramètre un pointeur vers une données, -le pointeur vers la donnée, casté en (void *), -le nom du thread tel qu il apparaîtra dans la liste des processus courants (commande console ps -A) s t r u c t t a s k s t r u c t k t h r e a d c r e a t e ( i n t ( t h r e a d f n ( void data ), void data, const char namefmt [ ],... ) ; Création et lancement de thread à partir : -d un pointeur de fonction ayant pour paramètre un pointeur vers une données, -le pointeur vers la donnée, casté en (void *), -le nom du thread tel qu il apparaîtra dans la liste des processus courants (commande console ps -A) s t r u c t t a s k s t r u c t k t h r e a d r u n ( i n t ( t h r e a d f n ( void data ), void data, const char namefmt [ ],... ) ; Retourne un pointeur vers la structure du processus courant s t r u c t t a s k s t r u c t g e t c u r r e n t ( ) ; Attente d evènement void s e t c u r r e n t s t a t e ( s t a t e v a l u e ) ; void s c h e d u l e ( ) ; Réveiller un processus en attente de lancement ou d évènement void w a k e u p p r o c e s s ( s t r u c t t a s k s t r u c t t a s k ) ; Indiquer à un thread qu il doit s arrêter void k t h r e a d s t o p ( s t r u c t t a s k s t r u c t t a s k ) ; Savoir si le thread courant doit s arrêter void k t h r e a d s h o u l d s t o p ( ) ; Création d un sémaphore S à n jetons s t r u c t semaphore sem = SEMAPHORE INITIALIZER ( sem, n ) ; Ajouter un jeton au semaphore up ( s t r u c t semaphore sem ) Retirer un jeton du semaphore dès lors qu il est disponible down ( s t r u c t semaphore sem ), down timeout ( s t r u c t semaphore sem ),... Déclaration de mutex initialisé par l un ou l autre des paramètres (ouvert ou fermé) Debian : s p i n l o c k t mshareddatamutex = SPIN LOCK UNLOCKED SPIN LOCK LOCKED ; unsigned long f l a g s ; 8

TinyCore : s t a t i c DEFINE SPINLOCK ( mshareddatamutex ) ; // D e f i n i debloque par d e f a u t unsigned long f l a g s ; Blockage et déblocage du mutex Debian et TinyCore: s p i n l o c k i r q s a v e (&mshareddatamutex, f l a g s ) ; [ Code c r i t i q u e ] s p i n u n l o c k i r q r e s t o r e (&mshareddatamutex, f l a g s ) ; 9