Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Xv6

2016-01-22T09:43:11Z

Danhidsan: /* Analizando XV6 */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://michaelee@bitbucket.ort/michaelee/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu-nox'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

[[Archivo:captura_inicializacion_xv6.png]]

= Analizando XV6 =

A continuación veremos la sección del código de xv6 de cada una de las partes básicas de un sistema operativo vistas en teoría.

1- [[scheduler_xv6|Planificador de procesos]]

2- [[memoria_virtual|Administracion de memoria]]

3- [[driver_xv6|Gestor de E/S]]

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU
* '''Video Explicativo de la Instalación'''
https://vimeo.com/69135539

Xv6

2016-01-22T09:41:37Z

Danhidsan: /* Analizando XV6 */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://michaelee@bitbucket.ort/michaelee/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu-nox'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

[[Archivo:captura_inicializacion_xv6.png]]

= Analizando XV6 =

A continuación veremos la sección del código de xv6 de cada una de las partes básicas de un sistema operativo vistas en teoría.

1- [[scheduler_xv6|Planificador de procesos]]

2- [[memoria_virtual|Administracion de memoria]]

3- [[Xv6_E/S|Gestor de E/S]]

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU
* '''Video Explicativo de la Instalación'''
https://vimeo.com/69135539

Driver xv6

2016-01-22T09:37:17Z

Danhidsan:

A continuación se muestra el condigo que hacer referencia al gestor de entrada/salida, en concreto el código que gestiona el bus IDE, al que se encuentra conectado el disco duro del ordenador sobre el que se esté ejecutando xv6.
Como se puede observar, xv6 gestiona L/E por muestreo. Esto se puede comprobar en la primera función que se implementa, en la que existe un bucle
''''while'''', del que no se sale mientras el bus IDE no reclama la atención del sistema.
En clase hemos visto el concepto de DMA. Se trataba de un dispositivo, bien implementado en el propio dispositivo de entrada salida o implementado en el sistema, que ayudaba con la comunicación entre la memoria principal y el dispositivo de E/S. Como podemos ver en este trozo de código del xv6, este es un IDE driver sin DMA, se puede contemplar en el primer comentario del código.

<source lang="C">
// Simple PIO-based (non-DMA) IDE driver code.

#include "types.h"
#include "defs.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
#include "x86.h"
#include "traps.h"
#include "spinlock.h"
#include "fs.h"
#include "buf.h"

#define SECTOR_SIZE 512
#define IDE_BSY 0x80
#define IDE_DRDY 0x40
#define IDE_DF 0x20
#define IDE_ERR 0x01

#define IDE_CMD_READ 0x20
#define IDE_CMD_WRITE 0x30

// idequeue points to the buf now being read/written to the disk.
// idequeue->qnext points to the next buf to be processed.
// You must hold idelock while manipulating queue.

static struct spinlock idelock;
static struct buf *idequeue;

static int havedisk1;
static void idestart(struct buf*);

// Wait for IDE disk to become ready.
static int
idewait(int checkerr)
{
int r;

while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
;
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
return -1;
return 0;
}

void
ideinit(void)
{
int i;

initlock(&idelock, "ide");
picenable(IRQ_IDE);
ioapicenable(IRQ_IDE, ncpu - 1);
idewait(0);

// Check if disk 1 is present
outb(0x1f6, 0xe0 | (1<<4));
for(i=0; i<1000; i++){
if(inb(0x1f7) != 0){
havedisk1 = 1;
break;
}
}

// Switch back to disk 0.
outb(0x1f6, 0xe0 | (0<<4));
}

// Start the request for b. Caller must hold idelock.
static void
idestart(struct buf *b)
{
if(b == 0)
panic("idestart");
if(b->blockno >= FSSIZE)
panic("incorrect blockno");
int sector_per_block = BSIZE/SECTOR_SIZE;
int sector = b->blockno * sector_per_block;

if (sector_per_block > 7) panic("idestart");

idewait(0);
outb(0x3f6, 0); // generate interrupt
outb(0x1f2, sector_per_block); // number of sectors
outb(0x1f3, sector & 0xff);
outb(0x1f4, (sector >> 8) & 0xff);
outb(0x1f5, (sector >> 16) & 0xff);
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
if(b->flags & B_DIRTY){
outb(0x1f7, IDE_CMD_WRITE);
outsl(0x1f0, b->data, BSIZE/4);
} else {
outb(0x1f7, IDE_CMD_READ);
}
}

// Interrupt handler.
void
ideintr(void)
{
struct buf *b;

// First queued buffer is the active request.
acquire(&idelock);
if((b = idequeue) == 0){
release(&idelock);
// cprintf("spurious IDE interrupt\n");
return;
}
idequeue = b->qnext;

// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
insl(0x1f0, b->data, BSIZE/4);

// Wake process waiting for this buf.
b->flags |= B_VALID;
b->flags &= ~B_DIRTY;
wakeup(b);

// Start disk on next buf in queue.
if(idequeue != 0)
idestart(idequeue);

release(&idelock);
}

//PAGEBREAK!
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
void
iderw(struct buf *b)
{
struct buf **pp;

if(!(b->flags & B_BUSY))
panic("iderw: buf not busy");
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
panic("iderw: nothing to do");
if(b->dev != 0 && !havedisk1)
panic("iderw: ide disk 1 not present");

acquire(&idelock); //DOC:acquire-lock

// Append b to idequeue.
b->qnext = 0;
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
;
*pp = b;

// Start disk if necessary.
if(idequeue == b)
idestart(b);

// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
sleep(b, &idelock);
}

release(&idelock);
}

</source>

Driver xv6

2016-01-21T21:42:00Z

Danhidsan: Página creada con «A continuación se muestra el condigo que hacer referencia al gestor de entrada/salida, en concreto el código que gestiona el bus IDE, al que se encuentra conectado el dis...»

A continuación se muestra el condigo que hacer referencia al gestor de entrada/salida, en concreto el código que gestiona el bus IDE, al que se encuentra conectado el disco duro del ordenador sobre el que se esté ejecutando xv6.
Como se puede observar, xv6 gestiona L/E por muestreo. Esto se puede comprobar en la primera función que se implementa, en la que existe un bucle <
while, del que no se sale mientras el bus IDE no reclama la atención del sistema.

<source lang="C">
// Simple PIO-based (non-DMA) IDE driver code.

#include "types.h"
#include "defs.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
#include "x86.h"
#include "traps.h"
#include "spinlock.h"
#include "fs.h"
#include "buf.h"

#define SECTOR_SIZE 512
#define IDE_BSY 0x80
#define IDE_DRDY 0x40
#define IDE_DF 0x20
#define IDE_ERR 0x01

#define IDE_CMD_READ 0x20
#define IDE_CMD_WRITE 0x30

// idequeue points to the buf now being read/written to the disk.
// idequeue->qnext points to the next buf to be processed.
// You must hold idelock while manipulating queue.

static struct spinlock idelock;
static struct buf *idequeue;

static int havedisk1;
static void idestart(struct buf*);

// Wait for IDE disk to become ready.
static int
idewait(int checkerr)
{
int r;

while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
;
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
return -1;
return 0;
}

void
ideinit(void)
{
int i;

initlock(&idelock, "ide");
picenable(IRQ_IDE);
ioapicenable(IRQ_IDE, ncpu - 1);
idewait(0);

// Check if disk 1 is present
outb(0x1f6, 0xe0 | (1<<4));
for(i=0; i<1000; i++){
if(inb(0x1f7) != 0){
havedisk1 = 1;
break;
}
}

// Switch back to disk 0.
outb(0x1f6, 0xe0 | (0<<4));
}

// Start the request for b. Caller must hold idelock.
static void
idestart(struct buf *b)
{
if(b == 0)
panic("idestart");
if(b->blockno >= FSSIZE)
panic("incorrect blockno");
int sector_per_block = BSIZE/SECTOR_SIZE;
int sector = b->blockno * sector_per_block;

if (sector_per_block > 7) panic("idestart");

idewait(0);
outb(0x3f6, 0); // generate interrupt
outb(0x1f2, sector_per_block); // number of sectors
outb(0x1f3, sector & 0xff);
outb(0x1f4, (sector >> 8) & 0xff);
outb(0x1f5, (sector >> 16) & 0xff);
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
if(b->flags & B_DIRTY){
outb(0x1f7, IDE_CMD_WRITE);
outsl(0x1f0, b->data, BSIZE/4);
} else {
outb(0x1f7, IDE_CMD_READ);
}
}

// Interrupt handler.
void
ideintr(void)
{
struct buf *b;

// First queued buffer is the active request.
acquire(&idelock);
if((b = idequeue) == 0){
release(&idelock);
// cprintf("spurious IDE interrupt\n");
return;
}
idequeue = b->qnext;

// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
insl(0x1f0, b->data, BSIZE/4);

// Wake process waiting for this buf.
b->flags |= B_VALID;
b->flags &= ~B_DIRTY;
wakeup(b);

// Start disk on next buf in queue.
if(idequeue != 0)
idestart(idequeue);

release(&idelock);
}

//PAGEBREAK!
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
void
iderw(struct buf *b)
{
struct buf **pp;

if(!(b->flags & B_BUSY))
panic("iderw: buf not busy");
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
panic("iderw: nothing to do");
if(b->dev != 0 && !havedisk1)
panic("iderw: ide disk 1 not present");

acquire(&idelock); //DOC:acquire-lock

// Append b to idequeue.
b->qnext = 0;
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
;
*pp = b;

// Start disk if necessary.
if(idequeue == b)
idestart(b);

// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
sleep(b, &idelock);
}

release(&idelock);
}

</source>

Scheduler xv6

2016-01-19T11:49:24Z

Danhidsan: /* Introducción */

= Introducción =

El planificador de procesos se encuentra en los archivos '''''proc.h''''', '''''proc.c'''''. Como se puede observar, se hace un '''''include''''' de otros archivos, como '''''types.h''''' o '''''defs.h'''''. En estos archivos se declaran variables y constantes necesarias para la ejecución del planificador.

Este trozo de código, es el archivo proc.h, dónde podemos encontrar por ejemplo la declaración del struct que va a formar el proceso y toda la información que lo compone. Podemos observar algunas propiedades del struct que hemos visto en clase, por ejemplo, el tamaño del proceso, el numero de pagina, el estado en que se encuentra el proceso, el PID del proceso, si tiene proceso padre, de que proceso padre es hijo, etc.

<source lang="C">
// Segments in proc->gdt.
#define NSEGS 7

// Per-CPU state
struct cpu {
uchar id; // Local APIC ID; index into cpus[] below
struct context *scheduler; // swtch() here to enter scheduler
struct taskstate ts; // Used by x86 to find stack for interrupt
struct segdesc gdt[NSEGS]; // x86 global descriptor table
volatile uint started; // Has the CPU started?
int ncli; // Depth of pushcli nesting.
int intena; // Were interrupts enabled before pushcli?

// Cpu-local storage variables; see below
struct cpu *cpu;
struct proc *proc; // The currently-running process.
};

extern struct cpu cpus[NCPU];
extern int ncpu;

// Per-CPU variables, holding pointers to the
// current cpu and to the current process.
// The asm suffix tells gcc to use "%gs:0" to refer to cpu
// and "%gs:4" to refer to proc. seginit sets up the
// %gs segment register so that %gs refers to the memory
// holding those two variables in the local cpu's struct cpu.
// This is similar to how thread-local variables are implemented
// in thread libraries such as Linux pthreads.
extern struct cpu *cpu asm("%gs:0"); // &cpus[cpunum()]
extern struct proc *proc asm("%gs:4"); // cpus[cpunum()].proc

//PAGEBREAK: 17
// Saved registers for kernel context switches.
// Don't need to save all the segment registers (%cs, etc),
// because they are constant across kernel contexts.
// Don't need to save %eax, %ecx, %edx, because the
// x86 convention is that the caller has saved them.
// Contexts are stored at the bottom of the stack they
// describe; the stack pointer is the address of the context.
// The layout of the context matches the layout of the stack in swtch.S
// at the "Switch stacks" comment. Switch doesn't save eip explicitly,
// but it is on the stack and allocproc() manipulates it.
struct context {
uint edi;
uint esi;
uint ebx;
uint ebp;
uint eip;
};

enum procstate { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };

// Per-process state
struct proc {
uint sz; // Size of process memory (bytes)
pde_t* pgdir; // Page table
char *kstack; // Bottom of kernel stack for this process
enum procstate state; // Process state
int pid; // Process ID
struct proc *parent; // Parent process
struct trapframe *tf; // Trap frame for current syscall
struct context *context; // swtch() here to run process
void *chan; // If non-zero, sleeping on chan
int killed; // If non-zero, have been killed
struct file *ofile[NOFILE]; // Open files
struct inode *cwd; // Current directory
char name[16]; // Process name (debugging)
};

// Process memory is laid out contiguously, low addresses first:
// text
// original data and bss
// fixed-size stack
// expandable heap
</source>

A continuación se puede ver el archivo ''''proc.c'''', en el que se observa como funciona el planificador de procesos.

<source lang="C">
#include "types.h"
#include "defs.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "x86.h"
#include "proc.h"
#include "spinlock.h"

struct {
struct spinlock lock;
struct proc proc[NPROC];
} ptable;

static struct proc *initproc;

int nextpid = 1;
extern void forkret(void);
extern void trapret(void);

static void wakeup1(void *chan);

void
pinit(void)
{
initlock(&ptable.lock, "ptable");
}

//PAGEBREAK: 32
// Look in the process table for an UNUSED proc.
// If found, change state to EMBRYO and initialize
// state required to run in the kernel.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
struct proc *p;
char *sp;

acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
if(p->state == UNUSED)
goto found;
release(&ptable.lock);
return 0;

found:
p->state = EMBRYO;
p->pid = nextpid++;
release(&ptable.lock);

// Allocate kernel stack.
if((p->kstack = kalloc()) == 0){
p->state = UNUSED;
return 0;
}
sp = p->kstack + KSTACKSIZE;

// Leave room for trap frame.
sp -= sizeof *p->tf;
p->tf = (struct trapframe*)sp;

// Set up new context to start executing at forkret,
// which returns to trapret.
sp -= 4;
*(uint*)sp = (uint)trapret;

sp -= sizeof *p->context;
p->context = (struct context*)sp;
memset(p->context, 0, sizeof *p->context);
p->context->eip = (uint)forkret;

return p;
}

//PAGEBREAK: 32
// Set up first user process.
void
userinit(void)
{
struct proc *p;
extern char _binary_initcode_start[], _binary_initcode_size[];

p = allocproc();
initproc = p;
if((p->pgdir = setupkvm()) == 0)
panic("userinit: out of memory?");
inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size);
p->sz = PGSIZE;
memset(p->tf, 0, sizeof(*p->tf));
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
p->tf->es = p->tf->ds;
p->tf->ss = p->tf->ds;
p->tf->eflags = FL_IF;
p->tf->esp = PGSIZE;
p->tf->eip = 0; // beginning of initcode.S

safestrcpy(p->name, "initcode", sizeof(p->name));
p->cwd = namei("/");

p->state = RUNNABLE;
}

// Grow current process's memory by n bytes.
// Return 0 on success, -1 on failure.
int
growproc(int n)
{
uint sz;

sz = proc->sz;
if(n > 0){
if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)
return -1;
} else if(n < 0){
if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)
return -1;
}
proc->sz = sz;
switchuvm(proc);
return 0;
}

// Create a new process copying p as the parent.
// Sets up stack to return as if from system call.
// Caller must set state of returned proc to RUNNABLE.
int
fork(void)
{
int i, pid;
struct proc *np;

// Allocate process.
if((np = allocproc()) == 0)
return -1;

// Copy process state from p.
if((np->pgdir = copyuvm(proc->pgdir, proc->sz)) == 0){
kfree(np->kstack);
np->kstack = 0;
np->state = UNUSED;
return -1;
}
np->sz = proc->sz;
np->parent = proc;
*np->tf = *proc->tf;

// Clear %eax so that fork returns 0 in the child.
np->tf->eax = 0;

for(i = 0; i < NOFILE; i++)
if(proc->ofile[i])
np->ofile[i] = filedup(proc->ofile[i]);
np->cwd = idup(proc->cwd);

safestrcpy(np->name, proc->name, sizeof(proc->name));

pid = np->pid;

// lock to force the compiler to emit the np->state write last.
acquire(&ptable.lock);
np->state = RUNNABLE;
release(&ptable.lock);

return pid;
}

// Exit the current process. Does not return.
// An exited process remains in the zombie state
// until its parent calls wait() to find out it exited.
void
exit(void)
{
struct proc *p;
int fd;

if(proc == initproc)
panic("init exiting");

// Close all open files.
for(fd = 0; fd < NOFILE; fd++){
if(proc->ofile[fd]){
fileclose(proc->ofile[fd]);
proc->ofile[fd] = 0;
}
}

begin_op();
iput(proc->cwd);
end_op();
proc->cwd = 0;

acquire(&ptable.lock);

// Parent might be sleeping in wait().
wakeup1(proc->parent);

// Pass abandoned children to init.
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p->parent == proc){
p->parent = initproc;
if(p->state == ZOMBIE)
wakeup1(initproc);
}
}

// Jump into the scheduler, never to return.
proc->state = ZOMBIE;
sched();
panic("zombie exit");
}

// Wait for a child process to exit and return its pid.
// Return -1 if this process has no children.
int
wait(void)
{
struct proc *p;
int havekids, pid;

acquire(&ptable.lock);
for(;;){
// Scan through table looking for zombie children.
havekids = 0;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p->parent != proc)
continue;
havekids = 1;
if(p->state == ZOMBIE){
// Found one.
pid = p->pid;
kfree(p->kstack);
p->kstack = 0;
freevm(p->pgdir);
p->state = UNUSED;
p->pid = 0;
p->parent = 0;
p->name[0] = 0;
p->killed = 0;
release(&ptable.lock);
return pid;
}
}

// No point waiting if we don't have any children.
if(!havekids || proc->killed){
release(&ptable.lock);
return -1;
}

// Wait for children to exit. (See wakeup1 call in proc_exit.)
sleep(proc, &ptable.lock); //DOC: wait-sleep
}
}

//PAGEBREAK: 42
// Per-CPU process scheduler.
// Each CPU calls scheduler() after setting itself up.
// Scheduler never returns. It loops, doing:
// - choose a process to run
// - swtch to start running that process
// - eventually that process transfers control
// via swtch back to the scheduler.
void
scheduler(void)
{
struct proc *p;

for(;;){
// Enable interrupts on this processor.
sti();

// Loop over process table looking for process to run.
acquire(&ptable.lock);
for(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.
proc = p;
switchuvm(p);
p->state = RUNNING;
swtch(&cpu->scheduler, proc->context);
switchkvm();

// Process is done running for now.
// It should have changed its p->state before coming back.
proc = 0;
}
release(&ptable.lock);

}
}

// Enter scheduler. Must hold only ptable.lock
// and have changed proc->state.
void
sched(void)
{
int intena;

if(!holding(&ptable.lock))
panic("sched ptable.lock");
if(cpu->ncli != 1)
panic("sched locks");
if(proc->state == RUNNING)
panic("sched running");
if(readeflags()&FL_IF)
panic("sched interruptible");
intena = cpu->intena;
swtch(&proc->context, cpu->scheduler);
cpu->intena = intena;
}

// Give up the CPU for one scheduling round.
void
yield(void)
{
acquire(&ptable.lock); //DOC: yieldlock
proc->state = RUNNABLE;
sched();
release(&ptable.lock);
}

// A fork child's very first scheduling by scheduler()
// will swtch here. "Return" to user space.
void
forkret(void)
{
static int first = 1;
// Still holding ptable.lock from scheduler.
release(&ptable.lock);

if (first) {
// Some initialization functions must be run in the context
// of a regular process (e.g., they call sleep), and thus cannot
// be run from main().
first = 0;
iinit(ROOTDEV);
initlog(ROOTDEV);
}

// Return to "caller", actually trapret (see allocproc).
}

// Atomically release lock and sleep on chan.
// Reacquires lock when awakened.
void
sleep(void *chan, struct spinlock *lk)
{
if(proc == 0)
panic("sleep");

if(lk == 0)
panic("sleep without lk");

// Must acquire ptable.lock in order to
// change p->state and then call sched.
// Once we hold ptable.lock, we can be
// guaranteed that we won't miss any wakeup
// (wakeup runs with ptable.lock locked),
// so it's okay to release lk.
if(lk != &ptable.lock){ //DOC: sleeplock0
acquire(&ptable.lock); //DOC: sleeplock1
release(lk);
}

// Go to sleep.
proc->chan = chan;
proc->state = SLEEPING;
sched();

// Tidy up.
proc->chan = 0;

// Reacquire original lock.
if(lk != &ptable.lock){ //DOC: sleeplock2
release(&ptable.lock);
acquire(lk);
}
}

//PAGEBREAK!
// Wake up all processes sleeping on chan.
// The ptable lock must be held.
static void
wakeup1(void *chan)
{
struct proc *p;

for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
if(p->state == SLEEPING && p->chan == chan)
p->state = RUNNABLE;
}

// Wake up all processes sleeping on chan.
void
wakeup(void *chan)
{
acquire(&ptable.lock);
wakeup1(chan);
release(&ptable.lock);
}

// Kill the process with the given pid.
// Process won't exit until it returns
// to user space (see trap in trap.c).
int
kill(int pid)
{
struct proc *p;

acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p->pid == pid){
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
p->state = RUNNABLE;
release(&ptable.lock);
return 0;
}
}
release(&ptable.lock);
return -1;
}

//PAGEBREAK: 36
// Print a process listing to console. For debugging.
// Runs when user types ^P on console.
// No lock to avoid wedging a stuck machine further.
void
procdump(void)
{
static char *states[] = {
[UNUSED] "unused",
[EMBRYO] "embryo",
[SLEEPING] "sleep ",
[RUNNABLE] "runble",
[RUNNING] "run ",
[ZOMBIE] "zombie"
};
int i;
struct proc *p;
char *state;
uint pc[10];

for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p->state == UNUSED)
continue;
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
state = states[p->state];
else
state = "???";
cprintf("%d %s %s", p->pid, state, p->name);
if(p->state == SLEEPING){
getcallerpcs((uint*)p->context->ebp+2, pc);
for(i=0; i<10 && pc[i] != 0; i++)
cprintf(" %p", pc[i]);
}
cprintf("\n");
}
}

</source>

= Análisis =

Aunque hay mucho código en '''''proc.c''''' el método que implementa el planificador es '''''sched''''' (Lineas 300 - 316). Para averiguar, por ejemplo, cuantos procesos se pueden ejecutar a la vez en xv6, debemos ir al archivo llamado '''''param.h'''''. Una vez dentro vemos que 64 en el máximo numero de procesos que se pueden ejecutar simultaneamente (definido por ''NPROC''). En este mismo archivo se pueden encontrar otras constantes necesarias para la ejecución del planificador.

Página Principal

2016-01-16T13:58:10Z

Danhidsan: /* Anexo */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla. ¡Contribuye!

= Novedades y noticias =

* [http://1984.lsi.us.es/~pablo/notas-ssoo-2015-2016.pdf Notas del primer, segundo, tercer y cuarto control de evaluación continua, incluida media] --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 15:22 14 ene 2016 (CET)
* [http://1984.lsi.us.es/~pablo/ssoo-c3.pdf Notas del primer, segundo y tercer control de evaluación continua] --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 08:42 7 ene 2016 (CET)
* [http://1984.lsi.us.es/~pablo/ssoo-c2.pdf Notas del primer y segundo control de evaluación continua] --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 00:26 17 dic 2015 (CET)

= Unidades didácticas =

A continuación encontrarás las unidades didácticas que forman parte de la asignatura.

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Arranque del sistema|Arranque del sistema]]
* 2.5. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.6. [[Conceptos básicos|Conceptos básicos]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]

== Modelos de diseño de Sistemas Operativos ==

* 3.1. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 3.2. [[Virtualización]]
* 3.3. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 4.1. [[Multiprogramación|La multiprogramación]]
* 4.2. [[Estados de los procesos|Estados de los procesos]]
* 4.3. [[Planificador de procesos|El planificador de procesos]]
* 4.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 4.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 4.6. [[Conmutación de procesos|La conmutación de procesos]]
* 4.7. [[Hilos|Hilos]]
* 4.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 5.1 [[Planificación de procesos|La planificación de procesos]]
* 5.2 [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 5.3 [[Criterios de planificación|Criterios de planificación]]
* 5.4 [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 5.5 [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 5.6 [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 5.7 [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 5.8 [[Ejercicios planificación de procesos|Ejercicios]]
* 5.9 [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 6.1 [[Concurrencia de procesos|Concurrencia de procesos]]
* 6.2 [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 6.3 [[Cerrojos|Cerrojos]]
* 6.4 [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 6.5 [[Semáforos|Semáforos]]
* 6.6 [[Monitores|Monitores]]
* 6.7 [[Mensajería|Mensajería]]
* 6.8 [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 7.1 [[Definición de interbloqueo|Definición]]
* 7.2 [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 7.3 [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 7.4 [[Ejercicios]]

== Administración de memoria ==

* 8.1 [[Introducción|Introducción]]
* 8.2 [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 8.3 [[Segmentación|Segmentación]]
* 8.4 [[Paginación|Paginación]]
* 8.5 [[Sistema combinado|Sistema combinado]]
* 8.6 [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 8.7 [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1 [[Memoria Virtual|Introducción]]
* 9.2 [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3 [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4 [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1 [[EstructuraES|Estructura dispositivo E/S]]
* 10.2 [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3 [[Diseño modular E/S|Diseño modular E/S]]
* 10.4 [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión L/E ==

* 11.1 [[Discos Magnéticos|Discos Magnéticos]]
* 11.2 [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3 [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4 [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5 [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1 [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2 [[FAT|FAT]]
* 12.3 [[EXT2 |EXT2]]
* 12.4 [[Ejercicios Administración Ficheros|Ejercicios]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Xv6

2016-01-16T13:55:53Z

Danhidsan: /* Enlaces de interés */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://michaelee@bitbucket.ort/michaelee/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu-nox'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

[[Archivo:captura_inicializacion_xv6.png]]

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU
* '''Video Explicativo de la Instalación'''
https://vimeo.com/69135539

Xv6

2016-01-16T13:54:26Z

Danhidsan: /* Descarga e instalacion de XV6 */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://michaelee@bitbucket.ort/michaelee/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu-nox'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

[[Archivo:captura_inicializacion_xv6.png]]

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU

Xv6

2016-01-16T13:51:00Z

Danhidsan: /* Descarga e instalacion de XV6 */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://github.com/guilleiguaran/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu-nox'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

[[Archivo:captura_inicializacion_xv6.png]]

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU

Archivo:Captura inicializacion xv6.png

2016-01-16T13:49:46Z

Danhidsan:

Xv6

2016-01-16T13:31:47Z

Danhidsan: /* Descarga e instalacion de XV6 */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://github.com/guilleiguaran/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

Si no consigues con estas instrucciones que te funcione hay una gran cantidad de videos en YouTube y Vimeo que te enseñan a hacerlo.

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU

Archivo:Captura compilacion xv6.png

2016-01-16T12:37:29Z

Danhidsan:

Archivo:Captura clonacion xv6.png

2016-01-16T12:31:13Z

Danhidsan:

Xv6

2016-01-16T12:21:26Z

Danhidsan: /* Instalación de QEMU en Linux Ubuntu */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público, para ello hay que escribir esto en el terminal:

'''''git clone https://github.com/guilleiguaran/xv6.git'''''

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.
Navegamos con el terminal hasta la carpeta recientemente creada.
Una vez dentro escribimos ''make'' y cuando termine de ejecutarse escribimos ''make qemu''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

Si no consigues con estas instrucciones que te funcione hay una gran cantidad de videos en YouTube y Vimeo que te enseñan a hacerlo.

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU

Archivo:Captura instalacion qemu.png

2016-01-16T12:16:24Z

Danhidsan:

Xv6

2016-01-16T11:59:26Z

Danhidsan: /* Instalación de QEMU en Linux Ubuntu */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal
-Por un gestor de paquetes.

Instalacion de QEMU por terminal:

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

Por paquetes:

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, darle doble click y clickar en "aplicar" en el menú de arriba. Una vez termine la instalación ya tendrás QEMU en tu ordenador

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público, para ello hay que escribir esto en el terminal:

'''''git clone https://github.com/guilleiguaran/xv6.git'''''

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.
Navegamos con el terminal hasta la carpeta recientemente creada.
Una vez dentro escribimos ''make'' y cuando termine de ejecutarse escribimos ''make qemu''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

Si no consigues con estas instrucciones que te funcione hay una gran cantidad de videos en YouTube y Vimeo que te enseñan a hacerlo.

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU

Xv6

2016-01-16T11:52:26Z

Danhidsan: /* Introducción a XV6 */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas pero las mas sencillas son por terminal o por algun gestor de paquetes.

Por terminal:

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

Por paquetes:

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, darle doble click y clickar en "aplicar" en el menú de arriba. Una vez termine la instalación ya tendrás QEMU en tu ordenador

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público, para ello hay que escribir esto en el terminal:

'''''git clone https://github.com/guilleiguaran/xv6.git'''''

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.
Navegamos con el terminal hasta la carpeta recientemente creada.
Una vez dentro escribimos ''make'' y cuando termine de ejecutarse escribimos ''make qemu''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

Si no consigues con estas instrucciones que te funcione hay una gran cantidad de videos en YouTube y Vimeo que te enseñan a hacerlo.

= Analizando XV6 =

Proximamente

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU