Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Memoria virtual

2016-01-21T18:49:05Z

Alemarmar5: Página creada con «= Introducción = La memoria virtual se encuentra principalmente en el archivo '''''vm.c'''''. En él están los métodos que implementan la memoria virtual tal y como la ...»

= Introducción =

La memoria virtual se encuentra principalmente en el archivo '''''vm.c'''''. En él están los métodos que implementan la memoria virtual tal y como la hemos visto en teoría. Como pasaba en el planificador de procesos, ''vm.c'' también llama a otros archivos en los cuales se implementa código necesario, como por ejemplo '''''mmu.h'''''. Dicho archivo implementa en ''C'' el dispositivo hardware conocido como [https://en.wikipedia.org/wiki/Memory_management_unit mmu], el cual lleva a cabo el manejo de la memoria virtual.
A continuación se muestran los archivos citados anteriormente:

Archivo '''''vm.c''''':

<source lang="C">

#include "param.h"
#include "types.h"
#include "defs.h"
#include "x86.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
#include "elf.h"

extern char data[]; // defined by kernel.ld
pde_t *kpgdir; // for use in scheduler()
struct segdesc gdt[NSEGS];

// Set up CPU's kernel segment descriptors.
// Run once on entry on each CPU.
void
seginit(void)
{
struct cpu *c;

// Map "logical" addresses to virtual addresses using identity map.
// Cannot share a CODE descriptor for both kernel and user
// because it would have to have DPL_USR, but the CPU forbids
// an interrupt from CPL=0 to DPL=3.
c = &cpus[cpunum()];
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);

// Map cpu, and curproc
c->gdt[SEG_KCPU] = SEG(STA_W, &c->cpu, 8, 0);

lgdt(c->gdt, sizeof(c->gdt));
loadgs(SEG_KCPU << 3);

// Initialize cpu-local storage.
cpu = c;
proc = 0;
}

// Return the address of the PTE in page table pgdir
// that corresponds to virtual address va. If !=0,
// create any required page table pages.
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int alloc)
{
pde_t *pde;
pte_t *pgtab;

pde = &pgdir[PDX(va)];
if(*pde & PTE_P){
pgtab = (pte_t*)p2v(PTE_ADDR(*pde));
} else {
if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)
return 0;
// Make sure all those PTE_P bits are zero.
memset(pgtab, 0, PGSIZE);
// The permissions here are overly generous, but they can
// be further restricted by the permissions in the page table
// entries, if necessary.
*pde = v2p(pgtab) | PTE_P | PTE_W | PTE_U;
}
return &pgtab[PTX(va)];
}

// Create PTEs for virtual addresses starting at va that refer to
// physical addresses starting at pa. va and size might not
// be page-aligned.
static int
mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm)
{
char *a, *last;
pte_t *pte;

a = (char*)PGROUNDDOWN((uint)va);
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
for(;;){
if((pte = walkpgdir(pgdir, a, 1)) == 0)
return -1;
if(*pte & PTE_P)
panic("remap");
*pte = pa | perm | PTE_P;
if(a == last)
break;
a += PGSIZE;
pa += PGSIZE;
}
return 0;
}

// There is one page table per process, plus one that's used when
// a CPU is not running any process (kpgdir). The kernel uses the
// current process's page table during system calls and interrupts;
// page protection bits prevent user code from using the kernel's
// mappings.
//
// setupkvm() and exec() set up every page table like this:
//
// 0..KERNBASE: user memory (text+data+stack+heap), mapped to
// phys memory allocated by the kernel
// KERNBASE..KERNBASE+EXTMEM: mapped to 0..EXTMEM (for I/O space)
// KERNBASE+EXTMEM..data: mapped to EXTMEM..V2P(data)
// for the kernel's instructions and r/o data
// data..KERNBASE+PHYSTOP: mapped to V2P(data)..PHYSTOP,
// rw data + free physical memory
// 0xfe000000..0: mapped direct (devices such as ioapic)
//
// The kernel allocates physical memory for its heap and for user memory
// between V2P(end) and the end of physical memory (PHYSTOP)
// (directly addressable from end..P2V(PHYSTOP)).

// This table defines the kernel's mappings, which are present in
// every process's page table.
static struct kmap {
void *virt;
uint phys_start;
uint phys_end;
int perm;
} kmap[] = {
{ (void*)KERNBASE, 0, EXTMEM, PTE_W}, // I/O space
{ (void*)KERNLINK, V2P(KERNLINK), V2P(data), 0}, // kern text+rodata
{ (void*)data, V2P(data), PHYSTOP, PTE_W}, // kern data+memory
{ (void*)DEVSPACE, DEVSPACE, 0, PTE_W}, // more devices
};

// Set up kernel part of a page table.
pde_t*
setupkvm(void)
{
pde_t *pgdir;
struct kmap *k;

if((pgdir = (pde_t*)kalloc()) == 0)
return 0;
memset(pgdir, 0, PGSIZE);
if (p2v(PHYSTOP) > (void*)DEVSPACE)
panic("PHYSTOP too high");
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
if(mappages(pgdir, k->virt, k->phys_end - k->phys_start,
(uint)k->phys_start, k->perm) < 0)
return 0;
return pgdir;
}

// Allocate one page table for the machine for the kernel address
// space for scheduler processes.
void
kvmalloc(void)
{
kpgdir = setupkvm();
switchkvm();
}

// Switch h/w page table register to the kernel-only page table,
// for when no process is running.
void
switchkvm(void)
{
lcr3(v2p(kpgdir)); // switch to the kernel page table
}

// Switch TSS and h/w page table to correspond to process p.
void
switchuvm(struct proc *p)
{
pushcli();
cpu->gdt[SEG_TSS] = SEG16(STS_T32A, &cpu->ts, sizeof(cpu->ts)-1, 0);
cpu->gdt[SEG_TSS].s = 0;
cpu->ts.ss0 = SEG_KDATA << 3;
cpu->ts.esp0 = (uint)proc->kstack + KSTACKSIZE;
ltr(SEG_TSS << 3);
if(p->pgdir == 0)
panic("switchuvm: no pgdir");
lcr3(v2p(p->pgdir)); // switch to new address space
popcli();
}

// Load the initcode into address 0 of pgdir.
// sz must be less than a page.
void
inituvm(pde_t *pgdir, char *init, uint sz)
{
char *mem;

if(sz >= PGSIZE)
panic("inituvm: more than a page");
mem = kalloc();
memset(mem, 0, PGSIZE);
mappages(pgdir, 0, PGSIZE, v2p(mem), PTE_W|PTE_U);
memmove(mem, init, sz);
}

// Load a program segment into pgdir. addr must be page-aligned
// and the pages from addr to addr+sz must already be mapped.
int
loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
{
uint i, pa, n;
pte_t *pte;

if((uint) addr % PGSIZE != 0)
panic("loaduvm: addr must be page aligned");
for(i = 0; i < sz; i += PGSIZE){
if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
panic("loaduvm: address should exist");
pa = PTE_ADDR(*pte);
if(sz - i < PGSIZE)
n = sz - i;
else
n = PGSIZE;
if(readi(ip, p2v(pa), offset+i, n) != n)
return -1;
}
return 0;
}

// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned. Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
char *mem;
uint a;

if(newsz >= KERNBASE)
return 0;
if(newsz < oldsz)
return oldsz;

a = PGROUNDUP(oldsz);
for(; a < newsz; a += PGSIZE){
mem = kalloc();
if(mem == 0){
cprintf("allocuvm out of memory\n");
deallocuvm(pgdir, newsz, oldsz);
return 0;
}
memset(mem, 0, PGSIZE);
mappages(pgdir, (char*)a, PGSIZE, v2p(mem), PTE_W|PTE_U);
}
return newsz;
}

// Deallocate user pages to bring the process size from oldsz to
// newsz. oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz. oldsz can be larger than the actual
// process size. Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
pte_t *pte;
uint a, pa;

if(newsz >= oldsz)
return oldsz;

a = PGROUNDUP(newsz);
for(; a < oldsz; a += PGSIZE){
pte = walkpgdir(pgdir, (char*)a, 0);
if(!pte)
a += (NPTENTRIES - 1) * PGSIZE;
else if((*pte & PTE_P) != 0){
pa = PTE_ADDR(*pte);
if(pa == 0)
panic("kfree");
char *v = p2v(pa);
kfree(v);
*pte = 0;
}
}
return newsz;
}

// Free a page table and all the physical memory pages
// in the user part.
void
freevm(pde_t *pgdir)
{
uint i;

if(pgdir == 0)
panic("freevm: no pgdir");
deallocuvm(pgdir, KERNBASE, 0);
for(i = 0; i < NPDENTRIES; i++){
if(pgdir[i] & PTE_P){
char * v = p2v(PTE_ADDR(pgdir[i]));
kfree(v);
}
}
kfree((char*)pgdir);
}

// Clear PTE_U on a page. Used to create an inaccessible
// page beneath the user stack.
void
clearpteu(pde_t *pgdir, char *uva)
{
pte_t *pte;

pte = walkpgdir(pgdir, uva, 0);
if(pte == 0)
panic("clearpteu");
*pte &= ~PTE_U;
}

// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz)
{
pde_t *d;
pte_t *pte;
uint pa, i, flags;
char *mem;

if((d = setupkvm()) == 0)
return 0;
for(i = 0; i < sz; i += PGSIZE){
if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
panic("copyuvm: pte should exist");
if(!(*pte & PTE_P))
panic("copyuvm: page not present");
pa = PTE_ADDR(*pte);
flags = PTE_FLAGS(*pte);
if((mem = kalloc()) == 0)
goto bad;
memmove(mem, (char*)p2v(pa), PGSIZE);
if(mappages(d, (void*)i, PGSIZE, v2p(mem), flags) < 0)
goto bad;
}
return d;

bad:
freevm(d);
return 0;
}

//PAGEBREAK!
// Map user virtual address to kernel address.
char*
uva2ka(pde_t *pgdir, char *uva)
{
pte_t *pte;

pte = walkpgdir(pgdir, uva, 0);
if((*pte & PTE_P) == 0)
return 0;
if((*pte & PTE_U) == 0)
return 0;
return (char*)p2v(PTE_ADDR(*pte));
}

// Copy len bytes from p to user address va in page table pgdir.
// Most useful when pgdir is not the current page table.
// uva2ka ensures this only works for PTE_U pages.
int
copyout(pde_t *pgdir, uint va, void *p, uint len)
{
char *buf, *pa0;
uint n, va0;

buf = (char*)p;
while(len > 0){
va0 = (uint)PGROUNDDOWN(va);
pa0 = uva2ka(pgdir, (char*)va0);
if(pa0 == 0)
return -1;
n = PGSIZE - (va - va0);
if(n > len)
n = len;
memmove(pa0 + (va - va0), buf, n);
len -= n;
buf += n;
va = va0 + PGSIZE;
}
return 0;
}

//PAGEBREAK!
// Blank page.
//PAGEBREAK!
// Blank page.
//PAGEBREAK!
// Blank page.

</source>

Archivo '''''mmu.h''''':

<source lang="C">

// This file contains definitions for the
// x86 memory management unit (MMU).

// Eflags register
#define FL_CF 0x00000001 // Carry Flag
#define FL_PF 0x00000004 // Parity Flag
#define FL_AF 0x00000010 // Auxiliary carry Flag
#define FL_ZF 0x00000040 // Zero Flag
#define FL_SF 0x00000080 // Sign Flag
#define FL_TF 0x00000100 // Trap Flag
#define FL_IF 0x00000200 // Interrupt Enable
#define FL_DF 0x00000400 // Direction Flag
#define FL_OF 0x00000800 // Overflow Flag
#define FL_IOPL_MASK 0x00003000 // I/O Privilege Level bitmask
#define FL_IOPL_0 0x00000000 // IOPL == 0
#define FL_IOPL_1 0x00001000 // IOPL == 1
#define FL_IOPL_2 0x00002000 // IOPL == 2
#define FL_IOPL_3 0x00003000 // IOPL == 3
#define FL_NT 0x00004000 // Nested Task
#define FL_RF 0x00010000 // Resume Flag
#define FL_VM 0x00020000 // Virtual 8086 mode
#define FL_AC 0x00040000 // Alignment Check
#define FL_VIF 0x00080000 // Virtual Interrupt Flag
#define FL_VIP 0x00100000 // Virtual Interrupt Pending
#define FL_ID 0x00200000 // ID flag

// Control Register flags
#define CR0_PE 0x00000001 // Protection Enable
#define CR0_MP 0x00000002 // Monitor coProcessor
#define CR0_EM 0x00000004 // Emulation
#define CR0_TS 0x00000008 // Task Switched
#define CR0_ET 0x00000010 // Extension Type
#define CR0_NE 0x00000020 // Numeric Errror
#define CR0_WP 0x00010000 // Write Protect
#define CR0_AM 0x00040000 // Alignment Mask
#define CR0_NW 0x20000000 // Not Writethrough
#define CR0_CD 0x40000000 // Cache Disable
#define CR0_PG 0x80000000 // Paging

#define CR4_PSE 0x00000010 // Page size extension

#define SEG_KCODE 1 // kernel code
#define SEG_KDATA 2 // kernel data+stack
#define SEG_KCPU 3 // kernel per-cpu data
#define SEG_UCODE 4 // user code
#define SEG_UDATA 5 // user data+stack
#define SEG_TSS 6 // this process's task state

//PAGEBREAK!
#ifndef __ASSEMBLER__
// Segment Descriptor
struct segdesc {
uint lim_15_0 : 16; // Low bits of segment limit
uint base_15_0 : 16; // Low bits of segment base address
uint base_23_16 : 8; // Middle bits of segment base address
uint type : 4; // Segment type (see STS_ constants)
uint s : 1; // 0 = system, 1 = application
uint dpl : 2; // Descriptor Privilege Level
uint p : 1; // Present
uint lim_19_16 : 4; // High bits of segment limit
uint avl : 1; // Unused (available for software use)
uint rsv1 : 1; // Reserved
uint db : 1; // 0 = 16-bit segment, 1 = 32-bit segment
uint g : 1; // Granularity: limit scaled by 4K when set
uint base_31_24 : 8; // High bits of segment base address
};

// Normal segment
#define SEG(type, base, lim, dpl) (struct segdesc) \
{ ((lim) >> 12) & 0xffff, (uint)(base) & 0xffff, \
((uint)(base) >> 16) & 0xff, type, 1, dpl, 1, \
(uint)(lim) >> 28, 0, 0, 1, 1, (uint)(base) >> 24 }
#define SEG16(type, base, lim, dpl) (struct segdesc) \
{ (lim) & 0xffff, (uint)(base) & 0xffff, \
((uint)(base) >> 16) & 0xff, type, 1, dpl, 1, \
(uint)(lim) >> 16, 0, 0, 1, 0, (uint)(base) >> 24 }
#endif

#define DPL_USER 0x3 // User DPL

// Application segment type bits
#define STA_X 0x8 // Executable segment
#define STA_E 0x4 // Expand down (non-executable segments)
#define STA_C 0x4 // Conforming code segment (executable only)
#define STA_W 0x2 // Writeable (non-executable segments)
#define STA_R 0x2 // Readable (executable segments)
#define STA_A 0x1 // Accessed

// System segment type bits
#define STS_T16A 0x1 // Available 16-bit TSS
#define STS_LDT 0x2 // Local Descriptor Table
#define STS_T16B 0x3 // Busy 16-bit TSS
#define STS_CG16 0x4 // 16-bit Call Gate
#define STS_TG 0x5 // Task Gate / Coum Transmitions
#define STS_IG16 0x6 // 16-bit Interrupt Gate
#define STS_TG16 0x7 // 16-bit Trap Gate
#define STS_T32A 0x9 // Available 32-bit TSS
#define STS_T32B 0xB // Busy 32-bit TSS
#define STS_CG32 0xC // 32-bit Call Gate
#define STS_IG32 0xE // 32-bit Interrupt Gate
#define STS_TG32 0xF // 32-bit Trap Gate

// A virtual address 'la' has a three-part structure as follows:
//
// +--------10------+-------10-------+---------12----------+
// | Page Directory | Page Table | Offset within Page |
// | Index | Index | |
// +----------------+----------------+---------------------+
// \--- PDX(va) --/ \--- PTX(va) --/

// page directory index
#define PDX(va) (((uint)(va) >> PDXSHIFT) & 0x3FF)

// page table index
#define PTX(va) (((uint)(va) >> PTXSHIFT) & 0x3FF)

// construct virtual address from indexes and offset
#define PGADDR(d, t, o) ((uint)((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))

// Page directory and page table constants.
#define NPDENTRIES 1024 // # directory entries per page directory
#define NPTENTRIES 1024 // # PTEs per page table
#define PGSIZE 4096 // bytes mapped by a page

#define PGSHIFT 12 // log2(PGSIZE)
#define PTXSHIFT 12 // offset of PTX in a linear address
#define PDXSHIFT 22 // offset of PDX in a linear address

#define PGROUNDUP(sz) (((sz)+PGSIZE-1) & ~(PGSIZE-1))
#define PGROUNDDOWN(a) (((a)) & ~(PGSIZE-1))

// Page table/directory entry flags.
#define PTE_P 0x001 // Present
#define PTE_W 0x002 // Writeable
#define PTE_U 0x004 // User
#define PTE_PWT 0x008 // Write-Through
#define PTE_PCD 0x010 // Cache-Disable
#define PTE_A 0x020 // Accessed
#define PTE_D 0x040 // Dirty
#define PTE_PS 0x080 // Page Size
#define PTE_MBZ 0x180 // Bits must be zero

// Address in page table or page directory entry
#define PTE_ADDR(pte) ((uint)(pte) & ~0xFFF)
#define PTE_FLAGS(pte) ((uint)(pte) & 0xFFF)

#ifndef __ASSEMBLER__
typedef uint pte_t;

// Task state segment format
struct taskstate {
uint link; // Old ts selector
uint esp0; // Stack pointers and segment selectors
ushort ss0; // after an increase in privilege level
ushort padding1;
uint *esp1;
ushort ss1;
ushort padding2;
uint *esp2;
ushort ss2;
ushort padding3;
void *cr3; // Page directory base
uint *eip; // Saved state from last task switch
uint eflags;
uint eax; // More saved state (registers)
uint ecx;
uint edx;
uint ebx;
uint *esp;
uint *ebp;
uint esi;
uint edi;
ushort es; // Even more saved state (segment selectors)
ushort padding4;
ushort cs;
ushort padding5;
ushort ss;
ushort padding6;
ushort ds;
ushort padding7;
ushort fs;
ushort padding8;
ushort gs;
ushort padding9;
ushort ldt;
ushort padding10;
ushort t; // Trap on task switch
ushort iomb; // I/O map base address
};

// PAGEBREAK: 12
// Gate descriptors for interrupts and traps
struct gatedesc {
uint off_15_0 : 16; // low 16 bits of offset in segment
uint cs : 16; // code segment selector
uint args : 5; // # args, 0 for interrupt/trap gates
uint rsv1 : 3; // reserved(should be zero I guess)
uint type : 4; // type(STS_{TG,IG32,TG32})
uint s : 1; // must be 0 (system)
uint dpl : 2; // descriptor(meaning new) privilege level
uint p : 1; // Present
uint off_31_16 : 16; // high bits of offset in segment
};

// Set up a normal interrupt/trap gate descriptor.
// - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.
// interrupt gate clears FL_IF, trap gate leaves FL_IF alone
// - sel: Code segment selector for interrupt/trap handler
// - off: Offset in code segment for interrupt/trap handler
// - dpl: Descriptor Privilege Level -
// the privilege level required for software to invoke
// this interrupt/trap gate explicitly using an int instruction.
#define SETGATE(gate, istrap, sel, off, d) \
{ \
(gate).off_15_0 = (uint)(off) & 0xffff; \
(gate).cs = (sel); \
(gate).args = 0; \
(gate).rsv1 = 0; \
(gate).type = (istrap) ? STS_TG32 : STS_IG32; \
(gate).s = 0; \
(gate).dpl = (d); \
(gate).p = 1; \
(gate).off_31_16 = (uint)(off) >> 16; \
}

#endif

</source>

= Analisis =

Aunque solo se muestran dos archivos, el proceso de manejo de memoria es mas complejo, hay muchos mas archivos y métodos que forman parte de esto. Si se quiere indagar mas a fondo lo ideal es fijarse en los archivos que son llamados en ''vm.c'' por ejemplo, y ver que métodos de estos archivos estan siendo utilizados. Para consultar estos archivos dirigete a la sección de ''Descarga e instalación de XV6''

Xv6

2016-01-21T18:28:17Z

Alemarmar5: /* 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

Scheduler xv6

2016-01-17T19:13:05Z

Alemarmar5: Página creada con «= Introducción = El planificador de procesos se encuentra en el archivo '''''proc.c'''''. Como se puede observar, se hace un '''''include''''' de otros archivos, como '''...»

= Introducción =

El planificador de procesos se encuentra en el archivo '''''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.

= 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.

Xv6

2016-01-17T18:53:20Z

Alemarmar5: /* 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- [[mmu_xv6|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-17T18:53:03Z

Alemarmar5:

= 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- [[mmu_xv6|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-15T18:44:14Z

Alemarmar5: Página creada con «= 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 desarrollad...»

= 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 SO está basado en la versión 6 de UNIX.
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

Archivo:Qemu synaptic.png

2016-01-15T17:57:59Z

Alemarmar5:

Archivo:Instalacion qemu.png

2016-01-15T17:50:46Z

Alemarmar5:

Página Principal

2016-01-15T17:07:23Z

Alemarmar5: /* 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í]].
* XV6, un SO creado por el MIT [[xv6|aquí]]