register caddr_t chan

ANNEXE B
/*
* Wake up all processes sleeping on chan.
*/
wakeup(chan)
register caddr_t chan;
{
register struct proc *p;
register c, i ;
c = chan;
p = &proc[0];
i = NPROC;
do {
if(p->p_wchan == c) {
setrun(p);
}
p++;
} while(--i);
}
6
struct
{
proc
short
p_addr;
/* address of swappable image */
short
p_size;
/* size of swappable image (pages) */
int
p_flag;
/* process flags */
char
p_stat;
/* process state */
char
p_pri;
/* priority, negative is high */
char
p_slptime; /* Seconds since last sleep */
char
p_nice;
/* nice for scheduling */
long
p_sig;
/* signal number sent to this process */
short
p_uid;
/* real user id, used to direct tty signals */
short
p_suid;
/* set (effective) user id */
short
p_time;
/* resident time for scheduling */
int
p_cpu;
/* cpu usage for scheduling */
short
*p_ttyp;
/* controlling tty */
short
p_pid;
/* unique process id */
short
p_ppid;
/* process id of parent */
caddr_t p_wchan;
/* event process is awaiting */
struct text *p_textp; /* pointer to text structure */
short
p_tsize;
/* size of text */
short
p_ssize;
/* size of stack */
short
p_clktim; /* time to alarm clock signal */
short
p_swaddr; /* disk address when swapped */
short
p_swsize; /* number if clicks already swapped */
} proc[NPROC];
5
Code Noyau (Extrait des TD)
ANNEXE A
/*
* Structure of the super-block
*/
struct filsys
{
unsigned short s_isize; /* size in blocks of i-list */
daddr_t s_fsize;
/* size in blocks of entire volume */
short
s_nfree;
/* number of addresses in s_free */
daddr_t s_free[NICFREE];/* free block list */
short
s_ninode;
/* number of i-nodes in s_inode */
ino_t
s_inode[NICINOD];/* free i-node list */
char
s_flock;
/* lock during free list manipulation */
char
s_ilock;
/* lock during i-list manipulation */
char
s_fmod;
/* super block modified flag */
char
s_ronly;
/* mounted read-only flag */
time_t s_time;
/* last super block update */
daddr_t s_tfree;
/* total free blocks*/
ino_t
s_tinode;
/* total free inodes */
short
s_m;
/* interleave factor */
short
s_n;
/* " " */
char
s_fname[6];
/* file system name */
char
s_fpack[6];
/* file system pack name */
ino_t
/* stuff for inode hashing */
s_lasti;
/* start place for circular search */
ino_t
s_nbehind;
/* est # free inodes before s_last */
};
#define NICFREE 50
#define NICINOD 100
4
Exercice 2 : Etude du noyau (12 points)
2.1 De manière générale, quels sont les processus réveillés lors d’un wakeup ?
2.2 Pourquoi, souvent, la stratégie de réveil de wakeup est peu performante ?
2.3 Modifier le code de wakeup présenté en annexe B pour une fonction
wakeup_one qui ne réveille qu’un seul processus.
2.4 Soit la portion de code suivante illustrant une synchronisation "classique" :
...
while(flags & MYLOCK) {
sleep(&event, MYPRIO);
}
flags |= MYLOCK;
Traitement();
flags &= ~MYLOCK;
wakeup(&event);
...
Commentez ce code puis modifiez le pour utiliser désormais wakeup_one.
2.5 Existe-t-il un problème de famine ? Si oui, indiquez un scénario illustrant ce
problème ; si non justifiez.
Modifiez si nécessaire votre code pour résoudre ce problème.
2.6 Modifiez wakeup_one pour prendre en compte le priorité des processus en
réveillant le processus le plus prioritaire.
3
Soit la configuration de superbloc suivante :
Pour la partition part1 :
s_nfree = 1
s_free[] 130
SuperBloc
sn_free = NICFREE
s_free[] 543 345 ...
Bloc 130
801 401
Pour la partition part2:
SuperBloc
s_nfree = 1
s_free[] 100
sn_free = NICFREE
s_free[] 443 956 ...
Bloc 100
801 601
Le programme exécute maintenant :
8
9
10
11
lseek(fd1,
lseek(fd2,
write(fd1,
write(fd2,
O, SEEK_END);
O, SEEK_END);
1500, buf);
500, buf);
Quels sont les numéros des blocs alloués aux fichiers 1 et 2. Refaites un schéma
des superblocs après l’allocation.
1.4 Enfin le programme réalise:
12
13
close(fd1);
close(fd2);
Quel est le nombre minumum d’entrées/sorties engendrée par ces deux instructions ?
2
Maîtrise d’Informatique - Examen d’UNIX - Septembre 1999
Partie 2 : Mécanisme Internes
(P. Sens)
1 heure 30 - Tous documents autorisés
Exercice 1 : Etude des structures de données (8 points)
1.1 Brièvement quel est le rôle de la table des inodes en mémoire ?
1.2
On considère deux partitions distinctes "/part1" (device numéro 1) et "/part2"
(device numéro 2). Le fichier f1 a un numéro d’inode égal à 1234 et f2 4321. Les
blocs disque ont une taille de 1024. La table des inodes en mémoire contient déjà
l’entrée <1,1234> (<device, i_number>).
Soit le programme suivant :
1
2
3
4
5
6
main() {
int fd1, fd2;
char buf[4096];
fd1 = open("/part1/f1", O_RDWR);
fd2 = open("/part2/f2", O_RDWR);
...
}
Faites un schéma des structures de données concernant les fichiers à la fin de cette portion de code.
Quel est le nombre minimum d’entrées/sorties qu’il a fallu effectuer ?
1.2 Le programme exécute ensuite cette portion de code :
6
7
read(fd1, buf, 1024);
read(fd2, buf, 1024);
Refaites un schéma des structures.
Quel est le nombre minimum d’entrées/sorties qu’il a fallu effectuer.
1.3 Quels sont les rôles principaux des superblocs ?
On considère la structure de superbloc présenté dans l’annexe A (même structure
qu’en TD).
1