Dissecting Xv6
1.0.0
Vous obtiendrez le dernier Verson modifié de XV6 en fonction de ce référentiel ici
Clone le référentiel officiel XV6 d'ici. Nous avons besoin d'un émulateur pour démarrer XV6.Nous utiliserons QEMU à cet effet. Pour installer Qemu, courez à partir de votre terminal
sudo apt install qemu
Ensuite, à partir de l'endroit où XV6 a été cloné, make à compiler XV6. Ensuite, pour lancer l'émulateur, exécutez make qemu et vous verrez Qemu dans une fenêtre différente. Si Qemu ne se lance pas, alors exécutez
sudo apt install qemu-system-x86
make qemu
Cette fois, cela devrait fonctionner. Pourtant, vous pourriez faire face à des problèmes comme celui-ci, alors voici un moyen de contourner.
Pour exécuter Qemu dans le même terminal que vous utilisez, exécutez make qemu-nox au lieu de make qemu .
Une fois le Qemu lancé, vous verrez les appels du système suivant en exécutant ls 
Nous sh.c modifier le code source et getcmd les effets instantanément.Lets disent que nous voulons remplacer le signe $ par autre chose.
printf ( 2 , ANSI_COLOR_GREEN " afnan@Xv6:$ " ANSI_COLOR_RESET);Ajoutez deux lignes en haut de ce fichier
# define ANSI_COLOR_GREEN " x1b [32m "
# define ANSI_COLOR_RESET " x1b [0m " Maintenant, quittez le terminal QEMU en appuyant sur cntrl+A , libérez puis tapez make qemu-nox immédiatement (comme vous pouvez le voir, c'est une tâche fastidie
L'utilisation des deux processeurs semble toujours être à 100% pour résoudre ce problème, faites après modification.
Dans proc.c , modifiez la fonction schduler
void
scheduler ( void )
{
struct proc *p;
int ran;
struct cpu *c = mycpu ();
c-> proc = 0 ;
for (;;){
// Enable interrupts on this processor.
sti ();
// Loop over process table looking for process to run.
acquire (&ptable. lock );
for (ran = 0 , p = ptable. proc ; p < &ptable. proc [NPROC]; p++){
if (p-> state != RUNNABLE)
continue ;
// Switch to chosen process. It is the process's job
// to release ptable.lock and then reacquire it
// before jumping back to us.
ran = 1 ;
c-> proc = p;
switchuvm (p);
p-> state = RUNNING;
swtch (&(c-> scheduler ), p-> context );
switchkvm ();
// Process is done running for now.
// It should have changed its p->state before coming back.
c-> proc = 0 ;
}
release (&ptable. lock );
if (ran == 0 ) {
halt ();
}
}
} et dans x86.h , ajoutez une fonction halt
static inline void
halt ()
{
asm volatile ( " hlt " : : );
} Créons un appel système pour shutdown shutdown terminal Qemu.
Créez d'abord un fichier nommé shutdown.c .
# include " types.h "
# include " stat.h "
# include " user.h "
int main ( int argc, char * argv[])
{
printf ( 1 , " Exiting n " );
shutdown ();
exit (); // eq to return zero
}Notez que pour imprimer quoi que ce soit dans la console, nous devons ajouter un descripteur de fichier comme premier paramètre de printf contrairement à la langue C.
Ensuite, dans Makefile, ajoutez-le dans les Uprogs
UPROGS=
_cat
_echo
_forktest
_grep
_init
_kill
_ln
_ls
_mkdir
_rm
_sh
_stressfs
_usertests
_wc
_zombie
_shutdownAjoutez-le aussi en extra
EXTRA=
mkfs.c ulib.c user.h cat.c echo.c forktest.c grep.c kill.c
ln.c ls.c mkdir.c rm.c stressfs.c usertests.c wc.c zombie.c shutdown.c Maintenant, vous pouvez quitter le terminal Qemu et exécuter REFORMER make qemu-nox et voir que ls répertoriera shutdown en tant qu'appel système. Mais exécuter cette commande ne fera rien pour l'instant. Nous devons ajouter cet appel système à 4 fichiers suivants suivants
extern int sys_shutdown(void); Ensuite, dans le bloc suivant, ajoutez [SYS_shutdown] sys_shutdown,#define SYS_shutdown 23SYSCALL(shutdown)void shutdown(void); Maintenant, il existe deux fichiers qui contiennent les méthodes pour les appels système. sysfile.c contient des méthodes liées aux fichiers et sysproc.c contient des méthodes liées aux processus.Nous devons écrire une nouvelle méthode nommée sys_shutdown dans sysproc.c .
void sys_shutdown ( void ){
outw ( 0xB004 , 0x0 | 0x2000 );
outw ( 0x604 , 0x0 | 0x2000 );
} Si tout va bien jusqu'à présent, vous pouvez sortir de Qemu, exécuter make qemu-nox et voir les appels sytem disponibles en exécutant ls .Run l' shutdown de la commande et vous verrez le terminal quitter.
NB : J'ai déjà implémenté quelques appels de système supplémentaires.
Tout d'abord, modifiez la fonction atoi dans le fichier ulib.c afin qu'il gère également les nombres négatifs.
int
atoi ( const char *s)
{
int i;
int sign;
int val;
i = 0 ;
sign = 1 ;
val = 0 ;
if (s[i] == ' - ' )
{
sign = - 1 ;
i++;
}
while (s[i] >= ' 0 ' && s[i] <= ' 9 ' && s[i] != ' ' )
{
val = val * 10 + (s[i]- ' 0 ' );
i++;
}
return (val * sign);
} Créez ensuite un fichier incr.c
# include " types.h "
# include " user.h "
# include " fcntl.h "
// give command : incr 7
// it will output 8
int main ( int argc , char * argv[]){
printf ( 1 , " %d n " , incr ( atoi (argv[ 1 ])));
exit ();
}modifiez les fichiers qui doivent être.
extern int sys_incr(void); Ensuite, dans le bloc suivant, ajoutez [SYS_incr] sys_incr,#define SYS_incr 23SYSCALL(incr)int incr(int);_incr dans les vers incr.c vers Puis ajoutez une méthode dans sysproc.c
int sys_incr ( void ){
int num;
argint ( 0 ,&num); // retrieving first integer argument
// cprintf("%d - Inside system call!",num);
return num + 1 ;
} Maintenant, sortir et exécuter make-qemu-nox vous permettra d'utiliser la commande incr .
Supposons que nous voulons un appel système afin d' add 2 5 -1 4 nous renverra 10 Il peut y avoir autant de nombres que les arguments. Maintenant, il y a un problème. Comment transmettre plusieurs arguments de l'espace utilisateur à l'espace du noyau? En cas de incr nous avons utilisé la méthode argint pour récupérer l'argument mais que faire lorsqu'il y a plusieurs valeurs?
Nous devons utiliser une structure.xv6 a un fichier stat.h traitant des structures.Definine une nouvelle structure dans ce fichier.
struct mystat {
int *nums;
int sz;
}; Dans sysproc.c ajoutez la méthode suivante et assurez-vous d'ajouter le fichier d'en-tête stat.h
int sys_add ( void ){
struct mystat *ct;
argptr ( 0 , ( void *)&ct , sizeof (*ct));
int s = 0 ;
int i;
for (i= 0 ;i<ct-> sz ;i++){
s+=ct-> nums [i];
// cprintf("%d " , ct->nums[i]);
}
return s;
} Créer un nouveau fichier add.c
# include " types.h "
# include " user.h "
# include " fcntl.h "
# include " stat.h "
int main ( int argc , char * argv[]){
struct mystat *ct = malloc ( sizeof ( struct mystat ));
ct-> sz = argc - 1 ;
int i;
for (i = 1 ;i<argc;i++){
// printf(1,"%d->" , atoi(argv[i]));
ct-> nums [i- 1 ] = atoi (argv[i]);
}
printf ( 1 , " %d n " , add (ct));
exit ();
}Modifiez maintenant les fichiers suivants en conséquence
extern int sys_add(void); Ensuite, dans le bloc suivant, ajoutez [SYS_add] sys_add,#define SYS_add 24SYSCALL(add)int add(struct mystat*); et ajouter struct mystat; en haut. Désormais à nouveau sortir et exécuter make-qemu-nox vous permettra d'utiliser la commande add .
Supposons que nous voulons générer une sous-chaîne à partir d'une chaîne en spécifiant l'index de démarrage et la longueur de la sous-chaîne. substr alupotol 3 5 publiera sysproc.c potol .
char * sys_substr ( void ){
static char *str;
int start_idx , len;
argint ( 1 , &start_idx);
argint ( 2 , &len);
argstr ( 0 , &str);
char * s = &str[ 0 ];
int i;
int k = 0 ;
for (i = start_idx ; i < start_idx+len ; i++){
s[k++] = str[i];
}
s[k]= ' ' ;
return s;
}
Et fichier substr.c correspondant
# include " types.h "
# include " user.h "
# include " stat.h "
int main ( int argc , char * argv[]){
char *s = argv[ 1 ];
int start_idx = atoi (argv[ 2 ]);
int len = atoi (argv[ 3 ]);
printf ( 1 , " %s " , substr (s , start_idx , len));
exit ();
}L'ajout de signature de cet appel système à d'autres fichiers comme indiqué précédemment nous permettra d'utiliser l'appel système
Nous voulons donner un sort 3 5 2 7 4 et nous attendons à la sortie 2 3 4 5 7 Pour ajouter un système comme celui-ci, créez un fichier sort.c
# include " types.h "
# include " user.h "
# include " fcntl.h "
# include " stat.h "
int main ( int argc , char * argv[]){
struct mystat *ct = malloc ( sizeof ( struct mystat ));
ct-> sz = argc - 1 ;
int i;
for (i = 1 ;i<argc;i++){
ct-> nums [i- 1 ] = atoi (argv[i]);
}
int *sorted_nums = sort (ct);
for ( int i= 0 ;i<ct-> sz ;i++){
printf ( 1 , " %d " , *(sorted_nums+i));
}
printf ( 1 , " n " );
exit ();
} Et fonction sys_sort correspondante dans le fichier sysproc.c
int * sys_sort ( void ){
struct mystat *ct;
argptr ( 0 , ( void *)&ct , sizeof (*ct));
int n = ct-> sz ;
int temp, j, k;
for (j = 0 ; j < n; ++j)
{
for (k = j + 1 ; k < n; ++k)
{
if (ct-> nums [j] > ct-> nums [k])
{
temp = ct-> nums [j];
ct-> nums [j] = ct-> nums [k];
ct-> nums [k] = temp;
}
}
}
return ct-> nums ;
}Après avoir modifié d'autres fichiers en conséquence, vous pouvez utiliser la commande
