*->lire une information:

ARCHITECTURE DES ORDINATEUR -charger l'adresse de mot qu'on veut lire dans RAM;
-lancer la commane R/W = 1
**architecture de Von neuman** -l'information se trouve dans RIM ,au bout d'un cetain temp;
constituer d'une memoire centrale , et d'une unite centrale
(processeur) cette *->Ecrire une information:
derniere il a 2 unitee UAL(Arithmetique est logic) est uniter de -charger l'adresse memoire ou on veut mettre l'information;
commade (controle); -placer l'information qu'on veut enregister dans le RIM;
-activer la commande R/W = 0 ,pour ecrire l'information;
*->memoire :dispositif capable d'enregistrer des informations;
*->Memoire modulaire (eviter qu'un cpu monopolise toute la
capacite:quatite d'information qu'on peut stocker dans une memoire)
memoire; • découper la mémoire en plusieurs modules.
volatilite:une memoire perd son contenus lors d'une coupure • Plusieurs bus permettent d’accéder simultanément (en même
de courant; temps) à la MC.
mode d'acess:soit mode ecriture ou lecture; • Possible d’avoir autant d’accès que de modules.
temps d'access:c'est le temps qui separe la demande et la • On ne peut pas accéder simultanément à un module.
disponiblite • Les bits du poid fort pour selectionner un module.
de l'information;
*->Mémoire entrelacée:(eviter qu'un cpu monopolise un
*->classification des memoires module)
memoire semi-conducteure:RAM,ROM,;(tansistor ou • Un module est divisé en plusieurs Blocs .
condencateur) • les adresses consécutive sont placé dans des bloc différents .
memoire magnetique:disque dur,disquette; • Le nombre de blocs représente le degré d’entrelacement.
memoire optique:CD,DVD-ROM; • Les bits de poids forts pour sélectionner un module ,les bit de
poid faible
*->memoire semi-conducteur: pour selectioner un bloc dans un module. le milier pour
memoire vive: selectioner le mot.
statique(bascule);dynamique(condensateur);associative(entre
les 2); Execution d'un programme:
memoire mort:en lecture seul,ROM,PROM,EPROM; LEC:lecture mot memoire de la memoire vers registre mot.
(ECR)
*->memoire central:c'est l'espace de travail du LMM:lecture mot memoire de Registre mots vers bus de
processeur;pour executer donnes.(EMM)
un programme il faut le charger dans une MC; LCO:lecture compteur ordinal,transfert le contenu de CO
RAM:memoire access aleatoire ,le temp d'avoir une dans bus adresse.(CCO:chargement)
information est independant PSR:pointage sur registre,copie l'@ de bus d'adresse vers
de sa place dans la memoire registre d'adresse.
CRI:charger registre d'instruction,mettre le mot memoire
*->vue logique d'un memoire: dans le registre d'instruction.
-memoire est un vecteure constitue des mots memoire CAD:chargement adresse,copie l'@ de Registre d'istruction
-mot memoire de n bit(cellule) vers Registre d'adresse.
-chaque mot a une adresse unique ,qui le represente ; CEA:chargement entree A de l'UAL aupres de bus de donne
-aderesse sont sequentielle,et sa taille depand de la capacite CEA:chargement entree B de l'UAL,aupres de bus de donne
memoire; ou Registre accumelateur.
CRA:chargement registre Accumelateur,enregistre le resultat
*->vue physique d'une memoire: de l'UAL.
-RAM(regitre d'adresse memoire):stock l'adresse EDA:enrgistrement donne accumelateur.soit dans UAL ou
concernee(ecrire/lire); dans la memoire.
-RIM(regitre d'information memoire):stock le mots memoire
qu'on veut lire rechere d'instruction,pointage vers instruction
apres de le recevoir de la MC,ou stock le mot qu'on veut suivant,execution d'instruction.
mettre dans la MC.
-Decodeure:selectionner un mot memoire ,apres avoir son ***la pile****
adresse de RAM;
-R/W:commande qui selctionne soit operation de lecture ou ***->etaps d'execution d'un programme.
d'ecrtiture; le compteur ordial contient l'adresse de l'instruction a
-Bus d’adresses de taille k bits; executer,il le passe
-Bus de données de taille n bits; au registre adresse RAM,l'instruction se charge dans le
registre d'instruction a l'aide du
register mot RIM,si cette instruction contient un adresse
memoire d'une information dont on
a besoin ,l'unite de controle passe un signal pour piloter les bus
et de mettre l'adresse
dans le RAM , l'information et disponible au RIM,si c'est une
operation de calcul on passe
cette information a UAL et on enregistre le resultat dans
accumulateur,si c'est une
instruction d'ecriture ,on deplace l'information de
l'accumulateur vers le registre RIM,
et on charge l'adresse ou on veut mettre l'information dans le
RAM,et on
incremente compteur ordinal pour passer a l'instruction
suivantes.
***les Tableaux***
tab1   db   10   dup   (0) :nom tab1,chaque case a 8
bits,taille(10)
,tous les case initialiser par 0.
tab2   dd   5   0, 1, 2, 3, 4:nom tab2,chaque case a 16 bits,taille
5 ,initialiser
progressivemt par 0 ,1,2,3,4
tab3   dw   100   dup   (?) :chaque case a 32 bits,tableau
contient des valeur aliatoire
**foction call & ret**
eip contient l'adresse de instruction a executer ,lorsequ'il
trouve la fct call,
cette dernier push l'adresse de l'instruction suivante dans la
pile, et met l'adresse de
de la 1 ere instruction de la foction (qu'on veut executer) dans
EIP, la derniere
insturction de la fonction on se trouve avec ret ,cette dernier
depile l'adresse de
l'instruction qu'on a empiler avec call dans EIP pour revenir
au programme principal main ,
**passage de parametre a la pile***
on passe les paramettre un par un dans la pile,et on empile
&return,
esp point sur &retun,on peur appler parm1 par [esp + 4];4 la
taille d'@ de return
le parrametre suivant c'est [esp + 4 + taille(para1)]
**variable local***
on empile ebp pour avoir un point fixe pour l'appel des
paramettres,
&return,epb;4 + 4;on empile les variable locale
1ere variable local [ebp - taille(var1)]
2eme variable local [ebp - taille(var1 + var2)]
1ere parametere [ebp + 8];
2eme parametere [ebp + 8 + taille(param1)];
***pipe-line***
avec les pipline on peut avoir multiple instruction en execution
simultanemant;
pipline :on divise l'execution on plusieurs etapes.
etape 1 -> LE: c'est l'etape qui separe la lecture de l'@
d'instrution de EP,et d'avoir
l'information de l'instruction dans ler RIM;
etape 2 -> DE: copie l'information de l'instruction de RIM
vers le registre d'instruction
puis decodage de l'operation(connaitre le type de
l'instruction);
etape 3 -> CH: chargememt des registres de travails selon le
type de l'instruction qu'on a
dans l'unite de calcul;
etape 4 -> EX: execution du instruction selon son type;
etape 5 -> ENR: enregistrmemnt des resultat dans le registre
destination;
**->aleas
*->aleas strucruel:en cas d'instruction de type
lecture/ecriture,access en memoire dans les
etapes lecture et execution demande le travail avec la meme
unite d'acees memoire , qui cree
un conflit;
solution:
-attendre pour une etape que l'unite soit disponible(decalage);
-ajouter d'autre unite d'access memoire dans le processeur;
*->aleas de donnes:c'est quand une instruction besoin d'une
donnes qui n'est pas actuellment
disponible ,ca veut dire que l'instruction depand de resultat
d'une instruction precedante,
qui est n'est pas encore fini son travail;
par example:
inst 1: R1 = 10 + R2
inst 2: R2 = R1 x 20
ici instruction 2 besoin que R1 soit deja caluler,
l'etape chargement(inst2) depasse l'etape
enregistrement(int1);
solution:
-suspension de l'etape CH(int2) tant que ENR(int1) n'est pas
terminer;
-Reordonnancement: changer l'ordre de l'execution des
instruction(mettre l'inst2 a la fin);
deux types de réordonnancement :Logiciel (compilateur)
Matériel (fait par le processeur);
-court-circuit:apres l'etape EXE(int1) on connait R1,en la
reinjecte directiment
dans registre A ou B de l'UAL(la ou on a etape CH(int2)), sans
attendre la terminaison
de l'etape ENR(int1);
*->aleas de controle:se pause dans le saute conditionel
inst 1: R1 = 10 + R2
inst 2: if (R1 > 30) then R3 = 10 + 1 ;else R3 = 20 + 1
R1 n'est pas connue ,alors on ne connait pas l'instruction
suivante ,donc on aura un
problem dans l'etape Lecture de inst2;
solution:
-solution avec attendre:on attend que ENR(ins1) soit
terminer , et on pass a LE(inst2);
-Réordonnancer le code : pas toujours suffisant et possible; le processeur va donc chercher @ dans la MC,et la mettre
-Prédire la valeur de R1 et commencer le calcul selon cette dans le cache a l'entree corespandate,
prédiction si non il prend directement l'information du cache.
on prend le chemin(brache) plus souvent atteinte;
pour cela on utilse: 00: |000|00 mots 0
BTB:Tampon des brache(chemin) cible ,contient les adresses 04: |001|00 mots 1
des instructions a suivre; 08: |010|00 mots 2
BHT:table qui mémorise l’historique des choix de 12: |011|00 mots 3
branchements,dépend de l’algorithme utilisé 16: |100|00 mots 4
par example 2 bits associés à chaque branche 20: |101|00 mots 5
00 : branchement jamais pris jusqu’à présent 24: |110|00 mots 6
01 : branchement parfois pris jusqu’à présent 28: |111|00 mots 7
10 : branchement souvent pris jusqu’à présent 3 pemier bits c'est l'index;
11 : branchement toujours pris jusqu’à présent 2 dernier bits le numero de l'octet dans le mots;

***cache memoire*** ***language assambleur***

cpu cherche tjr l'instruction dans le cache si elle existe,sinon il CMP A,B
va la chercher a la MC, JE (JNE):jump if (NO)Equal
car l'acces au cache est plus rapide que la l'acces a la MC JG (JGE) (JNGE):jump if (not)(equal) A great than B
**->cache a correspandance direct: JL (JLE) (JNLE):jump if (not)(equal) A less than B
se fait avec la correspandance suivantes:
@mot en MC modulo la taille de cache.par example cache de 8 example de la bouble for
blocs; for (cx=0; cx<5; cx++) ax = ax + cx;
adresse 1 , 9 , 17 , 25 en MC correspandant au bloc 1 dans le MOV AX,0 ; initialisation de AX et CX à 0
cache; MOV CX,0 ; CX est le compteur de boucle
pour faire la coresspandant inverse(cache vers MC)en utilse for:
des etiquites: CMP CX, 5 ; compare CX à 5 JGE endfor ; si CX >= 5, on sort
index correspand le numero de bloc de cache; de la boucle
etiquite:le mot memoire correspand ds MC; ADD AX, CX ; fait le calcul
pour bloc 1 : INC CX ; CX est incrémenté de 1
index = 001 ,etiquite = 00 --->@ MC 00 001 :1 JMP for ; on reprend au début de la boucle endfor:
index = 001 ,etiquite = 01 --->@ MC 01 001 :9
index = 001 ,etiquite = 10 --->@ MC 00 001 :17 ja jump above (x > y non-signé ) CF = 0 & ZF = 0
index = 001 ,etiquite = 11 --->@ MC 00 001 :25 jna jump not above = jbe
**->cache totalement associatifs: jae jump above or equal CF = 0
en place le mot memoire a n'import quelle bloc de memoire jnae jump not above or equal = jb
cache; jb jump below (x < y non-signé) CF = 1
**->cache associatifs par ensemble: jnb jump not below = jae
on divise le cache en n ensembles, jbe jump below or equal CF = 1 | ZF = 1
pour placer un mot dans une ensemble; en utilise principe de jnbe jump not below or equal = ja
cache correspendance direct;
@mot modulo n nombre d'enseble ,ensuite en place le mot *loop decriment CX tanque CX>0
n'import ou dans l'ensemble; for (cx=5; cx>0; cx--) ax = ax + cx
MOV AX,0 MOV CX,5 ; CX est le compteur de boucle
en genral l'adresse se present pour le cache comme ce ci for:
example d'@ 12 bits. ADD AX,CX ; fait le calcul
LOOP for ; décrémente CX. Si CX > 0 fait ; le saut à for
offset:si le mot memoire se compose de 8 octet,offset prendra
donc 3 bits pour les representes
index:c'est le cache contient 16 entree,index prendra 4 bits
pour les representes.
etiquette:prendra les bits qui reste de la taille d'adresse.
0 0 0 0 0|00 00| 0 0 0
etiquette|index|offset
5 4 3
**->recherche d'un @ dans le cache:
le processeur prend l'index pour savoir l'entree du cache
correspendante,si l'entree est
vide ou la comparaison avec l'etique n'est pas identique,il se
produit un defaut du cache,
 systeme d’exploitation II
->*Outils de devlopement:
-Compilateur:d'apres un fichier source a.c :passer le
preprocesseur a.i,generer un fichier assembleur a.s,
faire l'assemblage de ce fichier pour obtenir un fichier
a.o,faire l'edition de lien avec les libraires utilisee pour obtenir
un fichier executable.
-Editeur de lien:assosier les fichier objets avec les
bibioltheque utilisee,le resultat un fichier executable.
-Debogeur :permet l'execution pas a pas du code,pour cela il a
besion de code source et de fichier executable.
**->Les processus :
un processus est un programme entrain d'execution,chaque
processus est lance par un autre processus pere,
le processus init est la racine des processus il a le pid 1,lui
aussi et lance par le processus inactif du system
-demons: des processus system,sont tjr en activite ,fournit des
services system.
*-> les etat de processus:
-Running R:processus en cours d'execution.
-Sleeping S:en attente d'un evenement comme la fin d'une
entre sortie,
-Stopped T:processus a ete temporerment arrete par un
signal,
-Zombie Z: le processus s'est termine, mais son pere n'a pas
encore lu son code de retour.
*->PCB processus control Block:
le system utilise une table des processus ,chaque processus
possede une entree dans la table, et chaque entre
contient les informations suivantes:
-le pid,ppid,uid,gid de processus
-les fichier overt par le processus ,dossier courant,tty de
processus,memoire didier au processus,signaux recus
*->les foction processus;
getpid() ,return le pid de processus pid_t;
getppid(),return le pid du pere;
la appel system fork :permet de cree un processus,qui a le
meme code que son pere, et ils s'execute parallelement.
fork() ,retourne 0 pour le fils,pid de fils pour le pere,-1 en cas
d'erreur.
en cas d'erreur:
errno = ENOMEM -> sys n'a pas assez de memoire disponible
pour cree un processus
errno = EAGAIN ->processus pere a deja trop de processus
en cours d'execution.
exit(int status)-> permet de quiter un processus
immediatement,type de return void.
wait(int* status) set a attendre la mort d'un fils:return le pid
de fils mort
return -1: si le processus n'a pas de fils a attendre.
WIFEXITED(int status) return true si le fils est mort de
facons normal.
WEXITSTATUS(int status) return l'argument de la fct exit
utilse par le fils,
on l'utilise en cas de WIFEXITED = TRUE.
*->PASSER LES ARGUMENTS AU PROGRAMME
on ajoute 2 argument a la fct main(int argc,char* argv[])
pour consulter les arguments passer en ligne de commande
dans notre programme en utilise
la ce code : for(i=1;i<argc;i++) printf("argument %d = %s
",i,argv[i]);
*->variables d'environement:
pour passer les variable d'environment au programme on
declare un tableau de string globalement:
extern char **environ ce le dernier element de ce tableau =
NULL;
*->Appel EXEEC:
en faisent appel a exeec ,en remplace notre programme par un
commande ou un script shell,
le code restant ne s'execute pas,
-execl(char* path,char* argv1,char* argv2,NULL);example
exeec("\bin\ls","ls","-l",NULL).
-execv(char* path,char* argv[]) avec argv[] = ("ls","-
l",NULL);
-execlp(char* nomdefichier,char* arg1,...,NULL)
execlp("ls","ls","-l",NULL) evite de specifier le chemin des
commandes.
*->Threads: plusier fils d'execution qui partage le meme
espace d'adresage et les meme resousrces, et chaque
thread asa propre pile et son propre compteur
ordinal,parcontre les processus a son prpre espaced'adressage
et
son propre ressources.
-avantage de threads.le processus legere s'executes meme si
certaine parties son bloke.
-partage meme ressources, economie d'espace memoire est de
temp.
biblio <pthread.h> on ajouter -lpthread lors de compilation.
-pthread_self():permet de connaitre l'identifinat de thread
-pthread_create(&thread,NULL,&fonction,argument
fct(NULL)) permet de donner a un thread une fonction
-pthread_join(thread,NULL(valeur de return de la fct de
thread)comme la fct de wait pour les processus,
-pthread_exit(&valeur de retour(NULL)) terminer le thread
appellant;
*->L'ordonnecement:
l'ordonnecement : c'est l'effet de gerer l'utilisation de
processeur entre les processuse en etat pret.
-Efficacite:le processeur doit travailler a 100% de temps.
-Rendement:executer maximum des programme en un temps
donnes.
-Temps de repanse:le temps moyen pour repondre aux entrees
de l'utilisateura(systeme interactive).
-Temps d'execution:chaque programme doit s'executer le plus
vite possible.
-Equite:partager le temps processeur en equilbre entre les
processeurs.
-le temps de sejour:en soustrait le temps d'entree du temps de
terminaison(sortie);
-le temps d'attemps:le temps de sejour moins le temps
d'execution,
2 familles d'ordonneceur:
non-preemptif:en passe a un autre processus,en cas de
terminaison ou de blockage de processus courant.
preemptif:a un temp donne, l'ordonneceur prend la main et
choisie un autre processus.
-fifo :non preeptif ->premier arriver ,premier servie,
-SJF: shortes first job -> on choisi le processus a le moins
temps d'execution, en cas d'egalite
en revient au fifo,temp de reponse moins que fifo.
SRT:shortest remaing time,on compare le temps d'execution
de processus arrivant avec le processus actuel
,on choisi le plus court.
avec priorite: on affecte un valeur a chaque
processus,processus elu est le processus qui a la valeur
la plus eleve.
*->gestion de fichier:
le fichier c'est l'unite de conservation sur le support de
masse(disque dur,CD-ROM).
*->le systeme de fichier SGF:gerer les fichier,
point de vue utilisateur:nommage ,protection et droit
d'access,operation autorisees sur les fichier.
point de vue de l'implantation:organisation d'un fichier sur un
disque,gestion des blocs physique d'un fichier
gestion de l'espace libre.
mode d'acces du SGF:
Acces sequentiel: les enregistrement de fichier sont places les
unes apres les autres.(contigue)
Acces direct ou aleatoire:des enregistrement logique de meme
taille.acces immediat a un enregistrement,
Acces indixe:on utilse un table d'idixe faite la correspance cles
article.
*->gestion d'espace disque:
un fichier est constitue d'un ensemble de blocs physique.
l'allocation des blocs pour un fichier:
Allocation contigue:le fichier occupe un ensemble de blocs
contigus sur le disque.(ses difficulte ,
la fragmentation: trouver l'espace suffisant pour l'allocation.
le compactage: regrouper l'espace libre,dans
une seul cote).
Allocation par bloc chaine:
un fichier est represente comme une liste chainee des blocs, qui
peut etre disperses n'importe ou.
Allocation indexee:
un fichier representer par un tableau qui contient ses blocs.
Gestion de l'espace libre:
approche statique: le systeme utilse un table de bits,chaque
bloc correspond un bits,0 si libre,1 si non
approche dynamique:utilise une liste chaine des element dont
elles memorisant les blocs libre.
*->le repertoire: est une table d'entree, chaque entree
correspand a un fichier,il stock pour chaque fichier
l'adresse des blocs allouer a ce fichier,Répertoire à une
structure arborescente.
*->Fichier linux:
utilise allocation indixe, compose un descripteur appele
inode,et de bloc physique,chaque bloc code sur 4
octet, la taille de bloc multiple d'un secteur 512 octet -> 1024.
->inode :structure cree lors d'allocation,reperer par un
numero contient les infos suivant:
-nom,type,droit,taille,tables index des bloc,heures diverses.
tableau des blocs contient 15 entree, 12 premier a access direct
au bloc,ce qui reste aussi des table indixe.
13 table d'indexe indirect 1 point sur 256 blocs.
14 table d'indexe indirect 2_1 et 2_2 chaqune point sur 212
bloc
*->Virtuel file system:VFS contient 2 cache:
cache conserve les derniers conversions nom de fichier a un
numero de peripherique et numero d'inode.
buffer cache contient un ensemble de blocs de donnes lus
depuis le disque.
*structure VFS:se compose des objets:
-objet fichier:objet fichier contient just les
operation(lecture,ecriture,ouverture,fermeture).
-objet dentry:effectue le lien entre l'inode et le nom de fichier
-objet inode:
-objet superbloc:le point de montage,la taille de bloc,droit
d'access
*->liaison du processus avec objet du vfs:
PCB contient un table de fichier ouverts par le
processus ,chaque entree de cette table nomme
descripteur de fichier, point ->Objet_fichier->Objet_dentry-
>Objet_inode
I-fichier dans linux;
il faut utiliser les biblio
#include<sys/stat.h>
#include <fcntl.h>
poud ouvrir un fichier ,on cree un variable de type entier par
example
int fd;
fd = open(Nom_fichiet,mode_ouverture,droit);
mode_ouvert:
O_RDONLY: pour la lecture seul;
O_WRONLY: pour l'ecritrue seel;
O_RDWR: pour la lecture et ecriture;\\
O_APPEND:pour l'ecriture a la fin de ficher;
O_CREAT ,pour cree un fichier,il faut specifier les droit
d'access pour ce mode.
les droits d'acess:
S_IRUSR ,S_IWUSR, S_IXUSR ,rwx pour user; tous dans une
seul S_IRWXU
S_IRGRP ,S_IWGRP, S_IXGRP ,rwx pour group; tous dans
une seul S_IRWXG
S_IROTH ,S_IWOTH, S_IXOTH ,rwx pour others; tous dans
une seul S_IRWXO
pour ajouter multiple droit en un fichier c'est mieux d'utiliser
une variable mode_t mode.
on separant les expressions par in | ;
mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP;equivalent
a 660;
les droits d'acces sont dans include <sys/stat.h>
*->pour fermer un discripteur de fichier on fait close(fd);
*->pour ecrire dans un descripteur de ficher ,on utilise la fct
write(desc_fich,pointeur_buff,la taille de buf);
example buf peut etre une string , sa taille strleng(buf)
write(fd,chaine,strleng(chaine));
buf peut etre un pointeur de type struct
read(f,&struct,sizeof(struct));
*->pour lire d'un descripteur de fichier ,on utilse la fct
read(desc_fich,pointeur_buf,taille_de_buff_onOctet);
fct read and write renvoie le nombre d'octets lire ou ecrire;
*->pour se deplacer dans un fichier on utilise la fct
lseek(des_fichier,nombre_d'octet_aDepasser,point_de_depart);
point de depart:SEEK_SET->DEBUT DE FICHIER;
SEEK_CUR->LE POINT OU ON ETAIT
ARRETER;
SEEK_END->POINT SUR DERNIER ELEMENT
DE FICHIER;
*->acess au information d'un ficher dans un programme;on
utilise la foction
stat(emplacemnt_fichier,(struct stat)&buf) fct stat retourne -1
en cas d'absence de fichier;
il ya une structure predifine pour buffer,il suffit de declarer
une variable :struct stat buf;
buf.st_mode:le type de ficher,et ses droit;
printf("%c:,buf.st_mode & S_IRUSR ? 'r':'-');il va afficher r
si user a le droit de lecture;
buf.st_ino:nombre de l'inode;%ld
buf.st_size:la taille de ficher;%d
buf.st_uid:le nombre de utilateur auquel appartient ce fichier;
%d
buf-st_gid:le nomber de group auquel ce ficheier appartient;
%d
buf.st_nlink:nombre de lien physique;ld
S_ISREG(buf.st_mode):retourn true si est un fichier
ordinaire;
S_ISDIR(buf.st_mode):return true si est un dossier;
S_ISFIFO(buf.st_mode):return true si est fichier;
*->pour cree un lien physique on utilise fct
link(nom_fichier,nom_nouveauFichier);
prour supprimer un lien physique on utlise la fcti
unlink(nom_fichier);
*->pour cree un lien symbolique on utilise fct
symlink(nom_fich,nouv_fich);
readlink(nom_fich,chaine,taille(chain)) ;chaine aura le nom de
fichier auquel se point nom_fich;
*->pour renomer un fichier on utilise la fct
rename(nouveau_nom,ancien_nom);
*->pour modifier les droit on utilse la fct
chmod(nom_fichier,mode)
pour le mode, soit on donne le code octal(0644) ou par example
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
*->pour manipuler les dossiers dans linux on utilise la biblio
include <dirent.h>
mkdir pour cree un dossier; mkdir(nom_dossier, mode_t
mode);
rmdir pour supprimer un dossier ;rmdir(nom_dossier);
chdir pour changer le repetroire courant de travail;
chdir(nom_dossier);
getcwd pour savoir le dossier courant de
travail;getcwd(chaine_buf,taill_de_chaine);
pour ouvrir un repertoire ,on cree un varialble de type DIR*
doss;
opendir pour ouvrir un repertoir:doss = opendir(nom_doss);
readdir renvoi un pointeur de type struct dirent;struct dirent*
readdir(doss);
pour avoir les info de cette sturcture on cree un pointeur de
type struct dirent
struct dirent* entre;entre = readdir(doss);
entre->d_name = nom de premier fichier dans le dossier;
entre->d_ino = nombre de l'inode de premier fichier de
dossier;
si on appell la fct une deuzieme fois, on pass au second ficher;
si on atteint la fin des fichers on tombe sur NULL;
****Memoire****
2 type d'adresse ,adresse logique ,adresse physique;
les programmes connaissent que les adresses logique, ne voient
pas les adresses physique.
chaque adresse physique est representee dans le system par
une adresse logique;
***pagination***
chaque programme est decouper en pages,chaque page a un
emplacement physique ou case memoire;
systeme a une table des cases qui indique que un case est
libre(-1) ou pas(p1,ou p2).
la MMU convert une addresse logique a une adresse physique.
pour savoir a quelle case se trouve une certain page ,chaque
processur a une table de page,
qui fait la correspandance (numero de page)@logique-
>@physique
***memoire virtuelle***
Le principe de la mémoire virtuelle consiste à charger en
mémoire centrale
que la partie couramment utile de l’espace d’adressage des
processus.
pout cela chaque entrée de la table des pages comporte un bit
de validation V,
1 si la page est en mémoire centrale, 0 sinon.

default de page: se produit lors de chercher un page dont son
bit de validation vaut 0,
la convertion ne se fait pas(@logique->@physique:par MMU);
pour remplacer un page on a 2 algorithmes:
FIFO:premier page charge,premier page a eleminer;
LRU:laisser les pages recemment utilser;
****signaux****
pour manipuler les signaux on utilise la biblio #include
<signal.h>
kill pour envoyer un signal a un processus kill(pid,signal);
pid = 0;envoie le signal au group de processus;
pie = -1;envoie le signal a tout les processus;
sigset_t ens:varial d'ensemble des signaux;
sigfillset(&ens) remplir l'ensemble avec tous les signaux de
sys;
sigaddset(&ens,SIGINT) ajoute le signal sigint a l'ensemble
ens;
sigdelset(&ens,SIGINT) supprimer le sigint de l'ensembele
ens;
sigemptyset(&ens) vider l'ensemble de tous les signaux;
sigismember(&ens,SIGINT) permet de savoir est-ce-que sigint
existe dans l'ensemble;
sigpromask(SIG_SETMASK,&ens,NULL) :avec l'option
setmask permet de blocker
les signaux existe dans ens pour un processus;
sigpending(&ens) permet d'enregister les signgaux blocker par
le processus ,lors de leur arrivage,
sinon elle reste vide.
sigsupend(&ens) permet de blocker just les signaux de ens,
temporellement jusqu'a l'arriver d'un
signal non blockee ou bien qui n'existe pas dans ens,apres il
restaure l'ancien mask des signaux bloque.
signal(SIGINT,handler); permet d'executer les instrucions de
la fonction handler. lors d'arrivage de signal
sigint pour cet example ,on ingnorant le fonctionememt de
sigint.il faut la placer au debut de code.
sleep(5) permet de mettre le processus en etat de block
pendant 5 seconds
pause() permet de blocker le processus en attant l'arrivage
d'un signal
qui est specifier dans la fonction signal avec un fonction pour
continuer.
alarm(5) permet de envoyer un signal SIGALARM au
processus appelant dans 5 seconds;
sigaction(SIGSEGV, &action, 0) meme role que signal()
permet d'executer un fonction a l'arrivage
d'un signal sigsegv ,seulement ici en utiise une structure
sigaction
struct sigaction action;
action.sa_handler = handler ;handler est la fonctions a
executer lors de recevoir du signal;
action.sa_flags = 0;pas de commantaire;
sigemptyset(&action.sa_mask) vider l'ensemble de sturcture;
action.sa_mask :ens des signaux seront blocke lors d'execution
de fonction handler
appelle a la foction avec :sigaction(SIGSEGV, &action, 0)
***les tubes****
pour envoyer un message d'un processus a un autre en utilise
les tubes
*->tube anonyme pere_fils
pour cree un tube anonyme en declare un tableux de taille egal
a 2;
int fd[2];en le mettre dans la fct : pipe(fd);
mnt fd[1] sera utilise pour ecrire un message ,et fd[0] pour lire
ce message;
dans le processus ecrivant on ferme le tube de lecture avec
close(fd[0]),
et on ecrit avec write(fd[1],message,taille(message))
dans le processus lisant on ferme le tube d'ecriture avec
close(fd[1]),
et on lit le message avec read(fd[0],message,taille(message));
/*message c'est une chaine de caratcter*/
on peut lie le tube d'ecriture avec STDOUT avec la commande
dup2(fd[1],STDOUT_FILENO);close(fd[1]);
et on peut lie le tube de lecture avec stdin avec la commande
dup2(fd[0],STDIN_FILENO);close(fd[0]);
*->tube nommes processus independants
on cree un tube avec la foction mkfifo(nom_fichie,mode)
/*mode contient les droit d'access*/
Processus ecrivant:pour ecrire dans le tube on utilise la
commande
fd = open(nom_pipe,O_WRONLY) et apres en utilise la
foction write;
Processus lisant :on ouver le tube on mode lecture seul;
fd = open(nom_pipe,O_RDONLY); et apres on utilise la
foction read;
il faut executer les 2 programme en meme temps;
PROGRAMATION II
**->pointeurs
example: int tab[100]; tab equivalent a &tab[0];tab + i
equivalent a &tab[i];*(tab + i) equivalent a tab[i];
**->Allocation dynamique:
**malloc**
void* malloc (size_t size);
float* tab = (float*)malloc(19*sizeof(float));
**calloc
void *calloc (size_t nb, size_t size);comme malloc sauf elle
initialise les case au depart par 0;
float* tab = (float*)calloc(19,sizeof(float));
**reallocvoid* realloc (void *p, size_t newsize);sert a changer
la taille (reallouer) d'un pointeurs
par example on veut changer la taille de 19 a 29;
tab = (float*)realloc(tab,29*sizeof(float));
**free
void free( void *p );sert a liberer l'espace deja allouer;il est
obligatoire de la mettre tjr apres un malloc ou calloc;
free(tab);tab = NULL;
**variable globale:c'est une variable connue pour toutes les
fonctions ,se declare dors des foctions;
**variable locale:accessible juste au sein de sa fct;
**variable static:garde le comportement global juste pour sa
fct;
**->chaines de caracteres
-chaine statique: char chaine[32];c'est une tableau de
caractere;
gets(chaine) equivalente a scanf("%s",chaine);
puts(chaine) equivalente a printf("%s",chaine);
-chaine dynamique: char* chaine =
(char*)malloc(32*sizeof(char));
-chaine constantes: char* chaine = "good days";on peut pas
modifier le contenu de chaine;
-Size_t strlen(const char * s);EXU : strlen(chaine):renvoie le
nombre de caractere de chaine;
-char * strcpy (char *dest, char *src) equivalent a dire (dest
recoit src);renvoie un ptr sur dest;la taille de dest doit etre
plus grand que src;
-char * strdup (const char * s):renvoie un ptr sur une copie de
la chaine s;
-char * strcat (char *dest, const char *src):sert a coller src a la
fin de dest;la taille de dest doit etre suffisante;
-int strcmp(const char *s1, const char *s2);renvoie 1 si s1 >
s2(code ASCI) ,0 si sont egaux,-1 si non;
-char *strtok(char *str, const char *delim);renvoie un ptr sur
la 1ere partie separer par delim de chaine str,
on appel une autre fois par strtok(NULL,delim) on aura l
2eme partie.....renvoie NULL si on arrive a la fin;
-int sprintf(char *str, const char *format, ...):sert a ecrire
*format dans str;EXU sprintf(chaine,"toto note = %d",note);
chaine = toto note = 15;si note est une variable initialiser par
15;
int sscanf(const char *str, const char *format, ...): sert de lire a
partir de str ;EXU:sscanf(chaine,"%d %s %c",&nb,ch,&c);
chaine = 77 toto R;donc nb = 77,ch = toto,c = R;
**->Gestion des fichier:
-Declaration de fichier: FILE* fic;
fic = fopen("empalecmentFichier,"mode d'ouverture");fic
point sur le debut de fichier;
EX text.txt "r","w","a","r+","rb","r+b"...........;
fclose(fic);fic = NULL;pour liberer l'espace occuppe par fic;
**->Accès au contenu de fichier:
-int fputc(int c, FILE* fic):ecrire caractere c dans fic;
-int fgetc(FILE *fich):renvoie code asci de caractere pointe
par fic;renvoid EOF en cas d'erreur ou arriver a la fin;
-feof(fic):renvoie c'est on est arriver a la fin de fichier ,valeur
differente de 0 si non;
-int fputs(const char* chaine, FILE* fic):ecrire chaine dans le
fichier fic;renvoie une valeur positive en cas de success;
EOF = -1 en cas d'echec;
-char* fgets(char* chaine,size_t taille,FILE* fic);retourn null
a la fin de fichier ou en cas d'erreur;
ecrire ce qui est pointe par fic + la taille dans chaine;
fread(void *Zone, size_t Taille de l’enregistr, size_t Nbr, FILE
*fp) ;
fwrite(void *Zone, size_t Taille de l’enregistr, size_t Nbr, FILE
*fp) ;
EXU
fread(tab,sizeof(int),10,fic) lire de fichier est mettre le resultat
dans un tableau d'entiers de taille 10,
fwrite(tab,sizeof(int),10,fic):mettre un tableau d'entier de
taille 10 dans un fichier;
-int fseek(FILE *fp, long int deplacement, int origine);
origine = 0 debut de fichier;1 = emplacement actuel de
fichier;2 = fin de fichier;
-void rewind(FILE *fich); retouR au début du fichier;
-long ftell(FILE *fich) ;Retourne le nombre d’octet depuis le
début du fichier;
-int rename(const char* ancienNom, const char*
nouveauNom);Renomme un fichier;
-int remove(const char* fichierASupprimer);supprimer un
fichier;
-fprintf(flot,"format de contrôle",var1,var2,...):ecrire dans un
fichier en respectant la format;
-fscanf(flot,"format de contrôle",var1,var2,...):lire du fichier
et les mettre dans les variables,var1,var2....
FILE *stdin, *stdout, *stderr;
stdin entree standart,(clavier);
stdout sortie standar,(ecran);
stderr sortie pour les messages des erreurs;
**->structure
example:
typedef struct etudiant
{
char nom[max];
int code;
int nbNotes;
float* note;
}etd,*etud;
etd* tab = (etd*)malloc(*N*sizeof(etd));
tab[0] et de type etd pour afficher le nom de tab 0 en utilise :
tab[0].nom;
tab[0].note[0] est le contenu de premier note de tab[0];
- acces direct : si un elemnt e : e.champ;
- acces par pointeur : si un elemnt *etud : etud→champ;
* typedef enum{const1,const2}nom;
* typedef ansien_type nouvele_type;//pour alias de type.