Dissecting Xv6
1.0.0
Obtendrá el último VERON modificado de XV6 de acuerdo con este repositorio aquí
Clone el repositorio oficial de XV6 desde aquí. Necesitamos un emulador para arrancar XV6. Usaremos QEMU para este propósito. Para instalar Qemu, ejecute desde su terminal
sudo apt install qemu
Luego, desde donde se clonó XV6, ejecute make para compilar XV6. Luego, para iniciar el emulador, ejecute make qemu y verá QEMU en una ventana diferente. Si Qemu no se lanza, entonces ejecute
sudo apt install qemu-system-x86
make qemu
Esta vez, debería funcionar. Aún así, puede enfrentar problemas como este, entonces aquí hay un camino.
Para ejecutar qemu en el mismo terminal que está utilizando, ejecute make qemu-nox en lugar de make qemu .
Después de que se inicie QEMU, verá las siguientes llamadas del sistema ejecutando ls 
Podemos modificar el código fuente y ver los efectos al instante. Las letras dicen que queremos reemplazar el signo $ con algo más. Para hacer esto, vaya al archivo sh.c y cambie dentro del método getcmd .
printf ( 2 , ANSI_COLOR_GREEN " afnan@Xv6:$ " ANSI_COLOR_RESET);Agregue dos líneas en la parte superior de este archivo
# define ANSI_COLOR_GREEN " x1b [32m "
# define ANSI_COLOR_RESET " x1b [0m " Ahora renuncie desde el terminal QEMU presionando cntrl+A , suelte y luego escriba X inmediatamente (como puede ver que es una tarea tediosa y crearemos una llamada del sistema para salir del terminal). Luego se ejecuta, make qemu-nox nuevamente y vea el resultado ahora
El uso de dos CPU siempre parece ser del 100%. Para resolver esto, hacer la modificación después.
En proc.c , modifique la función 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 ();
}
}
} y en x86.h , agregue una función halt
static inline void
halt ()
{
asm volatile ( " hlt " : : );
} Creemos una llamada del sistema para salir del terminal QEMU. Lo nombramos como shutdown . Así que queremos hacer algo que nos permita salir del terminal simplemente escribiendo el shutdown del comando.
Primero cree un archivo llamado 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
}Observe que para imprimir cualquier cosa en la consola, necesitamos agregar un descriptor de archivo como el primer parámetro de printf a diferencia del idioma C.
Luego en Makefile, agrégalo en los asentadores
UPROGS=
_cat
_echo
_forktest
_grep
_init
_kill
_ln
_ls
_mkdir
_rm
_sh
_stressfs
_usertests
_wc
_zombie
_shutdownAgrégalo también 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 Ahora puede salir del terminal QEMU y ejecutar make qemu-nox nuevamente y ver que ls enumerará shutdown como una llamada del sistema. Pero ejecutar este comando no hará nada por ahora. Tenemos que agregar esta llamada del sistema a 4 siguientes archivos
extern int sys_shutdown(void); Luego, en el siguiente bloque, agregue [SYS_shutdown] sys_shutdown,#define SYS_shutdown 23SYSCALL(shutdown)void shutdown(void); Ahora, hay dos archivos que contienen los métodos para las llamadas del sistema. sysfile.c contiene métodos relacionados con archivos y sysproc.c contiene métodos relacionados con procesos. Tenemos que escribir un nuevo método llamado sys_shutdown en sysproc.c .
void sys_shutdown ( void ){
outw ( 0xB004 , 0x0 | 0x2000 );
outw ( 0x604 , 0x0 | 0x2000 );
} Si todo está bien hasta ahora, entonces puede salir shutdown QEMU, ejecutar make qemu-nox y ver las llamadas de Sytem disponibles ejecutando ls .
NB : Ya he implementado algunas llamadas de Sytem más. No verás ADD, INC, Getize, etc. por ahora si no se implementan.
En primer lugar, modifique la función atoi en el archivo ulib.c para que también maneje los números negativos.
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);
} Luego crea un archivo 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 ();
}Modifique los archivos que se necesitan para ser.
extern int sys_incr(void); Luego en el siguiente bloque, agregue [SYS_incr] sys_incr,#define SYS_incr 23SYSCALL(incr)int incr(int);_incr en Uprogs Agregue incr.c en extra Luego agregue un método en sysproc.c
int sys_incr ( void ){
int num;
argint ( 0 ,&num); // retrieving first integer argument
// cprintf("%d - Inside system call!",num);
return num + 1 ;
} Ahora, salir y ejecutar make-qemu-nox nuevamente le permitirá usar el comando incr .
Supongamos que queremos una llamada al sistema para que add 2 5 -1 4 nos devuelva 10 Puede haber tantos números como argumentos. Ahora aquí hay un problema. ¿Cómo pasar múltiples argumentos desde el espacio del usuario al espacio del núcleo? En caso de incr usamos el método argint para recuperar el argumento, pero ¿qué hacer cuando hay valores múltiples?
Necesitamos usar una estructura.xv6 tiene un archivo stat.h que trata con estructuras. Define una nueva estructura en ese archivo.
struct mystat {
int *nums;
int sz;
}; En sysproc.c agregue el siguiente método y asegúrese de agregar el archivo de encabezado 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;
} Crear un nuevo archivo 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 ();
}Ahora modifique los siguientes archivos en consecuencia
extern int sys_add(void); Luego en el siguiente bloque, agregue [SYS_add] sys_add,#define SYS_add 24SYSCALL(add)int add(struct mystat*); y agregar struct mystat; en la parte superior. Ahora, salir y ejecutar make-qemu-nox nuevamente le permitirá usar el comando add .
Supongamos que queremos generar subcadres desde una cadena especificando el índice de inicio y la longitud de la subcadena. substr alupotol 3 5 emitirá potol . Agregar una nueva función en sysproc.c
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;
}
Y el archivo substr.c correspondiente
# 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 ();
}Agregar la firma de esta llamada del sistema a otros archivos como se muestra anteriormente nos permitirá usar la llamada del sistema
Queremos dar una sort 3 5 2 7 4 y esperar la salida 2 3 4 5 7 Para agregar un Syscall como este, crear un archivo 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 ();
} Y la función sys_sort correspondiente en el archivo 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 ;
}Después de modificar otros archivos en consecuencia, puede usar el comando
