Ressources
Description officielle
Maîtriser et appliquer les concepts fondamentaux des systèmes d’exploitation. Comprendre les mécanismes et les politiques mises-en-oeuvre par les systèmes d’exploitations. Maîtriser la programmation système UNIX/Linux en C.
Rôles, types et structure générale des systèmes d’exploitation. Mécanismes noyaux : appels systèmes, interruptions, modes d’exécution processeur. Gestion des processus : états des processus, création et terminaison (fork et exec). Multitâche : changement de contexte, fils (threads), ordonnancement des tâches. Gestion des fichiers : systèmes de fichiers, inodes, descripteurs de fichiers, fichiers spéciaux. Communication inter-processus : échanges de messages, signaux, tubes, mémoire partagée. Concurrence : synchronisation, sections critiques, interblocages. Gestion de la mémoire : adressage, allocation, protection, pagination, mémoire virtuelle. Entrées-sorties : pilotes, pseudo-périphériques. Les considérations de sécurité seront intégrées au développement de la matière.
Évaluations et échéancier des rendus
Les dates de remise sont des dates “au plus tard”, et s’entendent sur le fuseau horaire de Montréal, à 23:55 le jour de la date de remise. Tout rendu hors délai recevra la note de zéro (0), mais rien ne vous empêche de livrer avant l’échéance. Les règles concernant le plagiat seront appliquées sans aucune tolérance.
La note finale (en lettre, A+, A, etc.) pour le trimestre sera attribuée en fonction de l’atteinte des objectifs spécifiques à travers les évaluations. La distribution des résultats dans le groupe pourrait aussi être utilisée. Aucune autre opportunité (travail supplémentaire, etc.) d’augmenter le nombre de points ne sera accordée.
Semainier des séances
Les diapositives téléchargeables (pdf) datent de la sessions d’été 2021 mais le contenu est à jour et sera utilisé tel quel pour la session d’automne 2021.
Anciens examens
Liens
- The Linux Kernel documentation. Documentation officielle du noyau Linux
- LWN. Site d’information spécialisé sur le noyau linux et son ecosystème (Linux Weekly News)
- POSIX.1-2017. Norme POSIX (Open Group et IEEE).
- The Unix Tree. Code source original de nombreuses versions historiques de Unix.
Médiagraphie
Les ressources suivantes sont recommandées.
- SILBERSCHATZ, A., GAVIN, P.B., GAGNE, G. – Operating Systems Concepts, 10TH EDITION, WILEY, 2018.
- TANENBAUM, Andrew S. – Modern Operating Systems – PRENTICE HALL, 4RD ED., 2014.
- TANENBAUM, Andrew S. – Système d’exploitation – PERSON EDUCATION, 3RD ED. (en français)
Des ressources complémentaires sont disponibles
- NUTT, G. – Operating system concepts – ADDISON WESLEY.
- STALLING, W. – Operating systems Internals and Design Principles – PRENTICE HALL.
- BIC, L.F. et SHAW, A.C. – Operating systems principles – PRENTICE HALL.
- KERNIGHAN, B.W., RITCHIE, D.M. – The C programming language – PRENTICE HALL.
- BLAESS, C. – Développement système sous Linux – EYROLLES
- RIFFLET, J.M. – La programmation sous Unix – SCIENCE INTERNATIONAL, PARIS.
- KERRISK M. – The Linux Programming Interface – NO STARCH PRESS.
- GRAY, J.S. – Inteprocess communications in Linux – THE NOOKS AND GRANMIS.
- ROBBINGS, K.A. et ROBBINGS, S. – Unix Systems Programming – PRENTICE HALL.
Remarque: n’oubliez pas, lors de l’utilisation d’appels systèmes, de traiter les cas d’erreur.
Echo Le programme srv_echo.c #include<stdlib.h> #include<stdio.h> #include<unistd.h> #include<string.h> #include<sys/socket.h> #include<sys/un.h> #include<signal.h> void gere(int sock) { fprintf(stderr, "** Terminaison du serveur et libération des ressources **\n"); close(sock); unlink("sock"); exit(EXIT_SUCCESS); } int main(int argc, char** argv){ struct sigaction action; sigemptyset(&action.sa_mask); action.sa_flags = 0; action.sa_handler = gere; sigaction(SIGINT, &action, NULL); int sock = socket(AF_UNIX, SOCK_STREAM, 0); struct sockaddr_un addr; addr.sun_family = AF_UNIX; strncpy(addr.
Objectif: utiliser les sockets du domaine Unix (AF_UNIX et SOCK_STREAM) et le multiplexage d’entrée-sorties.
Remarque: n’oubliez pas, lors de l’utilisation d’appels système, de traiter les cas d’erreur.
Écho Développez un serveur simple srv_echo.c qui accepte les clients et leur renvoie tel quel et directement ce qu’ils envoient. Le serveur traite entièrement chaque client l’un après l’autre. Le serveur reçoit et envoie au fur et à mesure : n’attendez pas de recevoir tous les octets avant de commencer à envoyer.
Remarque: n’oubliez pas, lors de l’utilisation d’appels systèmes, de traiter les cas d’erreur.
Dîner des philosophes Le problème du Dîner des philosophes consiste en un nombre de n (habituellement égal à cinq) de philosophes assis autour d’une table ronde, sur laquelle sont installées n assiettes et n couverts. Chaque philosophe dispose d’un couvert de chaque côté de son assiette.
Les philosophes, ont trois états penser, manger, attendre de manger. Les philosophes commencent tous dans l’état penser.
Remarque: n’oubliez pas, lors de l’utilisation d’appels systèmes, de traiter les cas d’erreur.
Dîner des philosophes diner_phi avec sleep #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> #define NOMBRE_DE_PHILOSOPHE 5 #define NOMBRE_DE_REPAS 2 // Attends pendant une durée pseudo-aléatoire entre 1 et 5 secondes void attendre() { int sleep_time = (rand() % 5) + 1; // int sleep_time = 1; sleep(sleep_time); } // Tableau qui contient le nombre de repas mangés par chaque philosophe.
Remarque: n’oubiez pas, lors de l’utilisation d’appels systèmes, de traiter les cas d’erreur.
Producteurs/consommateurs Le programme produc_conso avec des int comme compteurs. #include <pthread.h> #include <semaphore.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #define MAXDONNEE 5 // Nombre maximal de données produites par chaque producteur void attendre() { int sleep_time = (rand() % 5) + 1; // int sleep_time = 1; sleep(sleep_time); } // La déclaration des deux compteurs permettant de savoir s'il y a une donnée disponible pour le consommateur et si le producteur doit produire une donnée int empty; int full; #define TAILLE_MAX 10 // Liste d'attente char liste[TAILLE_MAX][100]; int index_ecriture=0; int index_lecture=0; //Nombre de consommateurs/producteurs int nombre_produ, nombre_conso; int TOTALDONNEE; void* producteur(void *id) { int id_producteur = *((int *) id); for (int i = 0; i < MAXDONNEE; i++) { // Gestion de la disponibilité des données while (empty <= 0) { attendre(); } empty--; int j = index_ecriture; index_ecriture++; if (index_ecriture == TAILLE_MAX) index_ecriture = 0; // Génération de la donnée sprintf(liste[j], "Le producteur %d a créé la donnée %d", id_producteur, i); printf("(+) Le producteur %d a produit : \n\tLe producteur %d a créé la donnée %d\n",id_producteur ,id_producteur, i); attendre(); // Gestion de la disponibilité des données full++; } } void* consommateur(void *id) { int id_consommateur = *((int *) id); // Calcul du nombre de données à consommer pour chaque consommateur int nb_a_consommer = TOTALDONNEE / nombre_conso + (TOTALDONNEE % nombre_conso > id_consommateur); for (int i = 0; i < nb_a_consommer; i++) { // Gestion de la disponibilité des données while (full <= 0) { attendre(); } full--; int j = index_lecture; index_lecture++; if (index_lecture == TAILLE_MAX) index_lecture = 0; printf ("(-) Consommateur %d a consommé la donnée : \n\t\"%s\"\n", id_consommateur, liste[j]); // Gestion de la disponibilité des données empty++; } } int main(int argc, char** argv) { int i; if(argc == 3){ char* endptr = NULL; nombre_produ = strtol(argv[1], &endptr, 0); if (*endptr !
Producteurs/consommateurs Dans le problème du producteur et consommateur, il y a un ensemble de producteurs qui ont pour travail de générer une donnée et de la mettre en attente dans une file d’attente globale. Le travail du consommateur est de récupérer cette donnée et de la consommer.
L’objectif du laboratoire est de développer plusieurs versions du programme produc_conso en vous basant sur le squelette de code ci-dessous. Ce programme prend en argument un nombre de producteurs et un nombre de consommateurs, chacun représenté par un thread.
Remarque: n’oubliez pas, lors de l’utilisation d’appels système, de traiter les cas d’erreurs.
mmap L’objectif de cet exercice est de projeter un fichier en mémoire puis d’utiliser cette projection pour effectuer des opérations.
Créez un programme memcat qui prend en argument le fichier à projeter et en affiche le contenu. Note: le fichier passé en argument doit nécessairement exister; le cas échéant affichez un message d’erreur adéquat. Utilisez les appels système mmap pour projeter le fichier en mémoire et munmap pour détruire la projection.
Remarque: n’oubliez pas, lors de l’utilisation d’appels systèmes, de traiter les cas d’erreurs.
mmap Le programme memcat qui prend en argument le fichier à projeter et en affiche le contenu. #include<stdio.h> #include<unistd.h> #include<fcntl.h> #include<sys/stat.h> #include<sys/mman.h> int main(int argc, char **argv){ if(argc != 2){ printf("usage : %s nom_fichier\n", argv[0]); return 1; } int fd, resWrite; struct stat stat; char *buf; fd = open(argv[1], O_RDONLY); if(fd == -1){ perror("open"); return 1; } if(fstat(fd, &stat) == -1){ perror("stat"); return 1; } buf = mmap(NULL, stat.
L’objectif de ce laboratoire est de programmer avec des appels systèmes et de regarder les comportements.
Bibliothèques C Développer un programme prime qui calcule en C le nombre de nombres premiers inférieurs ou égaux au nombre passé en argument.
$ ./prime 5 3 $ ./prime 50 15 $ ./prime 10000000 664579 Vous utiliserez l’algo suivant (crible d’Ératosthène) :
#include <math.h> long int argument; // Argument du programme long int* primes; // Tableau de nombres premiers trouvés (à allouer dans le tas et réallouer) size_t nb; // Nombre de nombres premiers trouvés for (long int i=2; i<=argument; i++) { int prime = TRUE; for (size_t k=0; k<nb; k++) { long int j = primes[k]; if (j>sqrt(i)) { break; // on trouvera plus de diviseur, inutile de continuer de chercher } if (i%j == 0) { prime = FALSE; // c'est divisible, donc pas premier break; } } if (prime) { // on enregistre et passe au nombre suivant primes[nb] = i; // Réalouer peut-etre nb++; } } print(nb); // et voila!
L’objectif de ce laboratoire est de regarder l’organisation de la mémoire dans les processus et de s’initier à la programmation multithread.
Tailles des binaires Écrivez puis compilez :
un programme p0 qui retourne seulement 42: echo 'int main(int argc, char *argv[]){ return 42; }' > p0.c. un programme p1 similaire à p0 mais qui include les trois fichiers d’entête standard: stdlib.h, stdio.h, unistd.h. un programme p2 similaire à p0 mais en ajoutant une variable globale non initialisée char tableau[8000];.
