Cómo funciona el núcleo de Linux

El nucleo Linux
Copyright c 1996-1998 David A Rusling
david.rusling@digital.com
REVIEW, Version 0.8-2

15 de octubre de 1998
Este libro es para aquellos entusiastas de Linux que desean conocer como funciona el
nucleo de este sistema operativo. No es un manual acerca de los detalles internos. Mas
bien, se dedica a describir los principios y mecanismos que utiliza Linux los comos y
porques que explican la manera en que el nucleo trabaja. Linux es un blanco en movi-
miento este libro se basa en el nucleo estable actual, el de fuentes 2.0.33, pues es el que
mas individuos y compa~ as estan utilizando en la actualidad.
n
Este libro se puede distribuir libremente, y ademas Ud. puede copiarlo y redistribuirlo
bajo ciertas condiciones. Por favor, tenga a bien observar la declaracion de derechos de
copia y distribucion.

Esta pagina se ha dejado en blanco intencionalmente.

Dedicado a Gill, Esther y
Stephen

Noti caciones legales
UNIX es marca registrada de Univel.
Linux es marca registrada de Linus Torvalds, y no tiene ninguna relacion con
UNIXTM or Univel.
Copyright c 1996,1997,1998 David A Rusling
3 Foxglove Close, Wokingham, Berkshire RG41 3NF, UK
david.rusling@digital.com

El nucleo Linux" Puede reproducirse y distribuirse en un todo o en parte, siempre
que se cumplan las siguientes condiciones:
0. La declaracion de "copyright" precedente y esta declaracion de permiso se
deben preservar completas en todas las copias totales o parciales.
1. Cualquier traduccion o trabajo derivado de El nucleo Linux" debe ser apro-
bada por escrito por el autor antes de su distribucion.
2. Si Ud. distribuye El nucleo Linux" en parte, debera incluir instrucciones
para obtener la version completa, y debera proveer un medio para obtener
la version comkpleta.
3. Puede reproducirse a modo de ilustracion para revisiones o citas en otros
trabajos, sin necesidad de esta declaracion de permiso, siempre que se de
una cita apropiada.
4. Si Ud. imprime y distribuye El nucleo Linux", Ud. no podra referirse a el
como la Version o cial impresa .
5. La Licencia publica general GNU ( GNU General Public License ) que se
cita mas abajo, puede reproducirse bajo las condiciones que le son propias.
Hay excepciones a las reglas previamente mencionadas que pueden autorizarse con
propositos academicos: escriba a David Rusling a la direccion postal anterior, o
env e correo electronico a david.rusling@digital.com, y consulte. Estas restric-
ciones estan para protegernos a nosotros como los autores, y no para restringir a
los educadores y alumnos.

Todo el codigo fuente en El nucleo Linux" esta cubierto por la Licencia publica
general GNU . Si desea una copia de la GPL , vea en el apendice D.
El autor no es responsable judicialmente por ningun da~o, directo o indirecto, que
n
resulte de la informacion provista en este documento.

Prefacio
Linux es un fenomeno producto de Internet. Concebido como un proyecto para el
entretenimiento de un estudiante, ha crecido hasta sobrepasar en popularidad a to-
dos los demas sistemas operativos de distribucion libre. Para muchos Linux es un
enigma. >Como puede valer la pena algo que es gratis? En un mondo dominado por
un pu~ado de enormes corporaciones de software, >como puede ser que algo escrito
n
por una manada de hackers (sic) tenga la esperanza de competir?. >Como puede
ser que las contribuciones de software realizadas por tantas personas distintas, con
tan diferentes pa ses de origen de todo el mundo, tengan la esperanza de ser estables
y efectivas? Y sin embargo, es estable y efectivo, y tambien compite. Muchas univer-
sidades y establecimientos de investigacion lo utilizan para satisfacer sus necesidades
de computo cotidianas. La gente lo hace funcionar en las PCs de sus casas, y yo
puedo apostar a que la mayor a de las compa~ as lo estan utilizando en algun lugar,
n
aun cuando puede que no esten al tanto de ello. Linux se utiliza para navegar en la
web , para hospedar sitios web , escribir tesis, enviar correo electronico y, como
desde siempre se ha hecho con las computadoras, para divertirse con juegos. Debo
expresar enfaticamente que Linux no es un juguete es un sistema operativo comple-
tamente desarrollado, y escrito de manera profesional, y que utilizan los entusiastas
por todo el mundo.
Las ra ces de Linux pueden rastrearse hasta los or genes de UnixTM . En 1969, Ken
Thompson perteneciente al Grupo de investigacion (Research Group ) de los La-
boratorios Bell , comenzo a experimentar con un sistema operativo multiusuario,
multiprogramado1 trabajando sobre una PDP-7 que nadie utilizaba. Pronto se le
unio Dennis Richie y entre ambos, junto con otros miembros del Grupo de Investiga-
cion, produjeron las primeras versiones de UnixTM . Richie estab fuertemente in u do
por un proyecto anterior denominado MULTICS, y el nombre UnixTM es en s mis-
mo un gracioso juego de palabras derivado de MULTICS. Las primeras versiones se
escribieron en lenguaje ensamblador, pero la tercer version se escribio en el nuevo
lenguaje C. Richie dise~o y escribio el lenguaje de programacion C expresamente
n
para que sea utilizado en la escritura de sistemas operativos. Al rescribir UnixTM en
C, fue posible llevarlo a las computadoras mas poderosas PDP-11/45 y 11/70 que por
ese entonces fabricaba DIGITAL. El resto, como se suele decir, es historia. UnixTM
salio de los laboratorios y se introdujo en la corriente principal de los sistemas de
computo, y muy pronto los mas importantes fabricantes de computadoras estaban
produciendo sus propias versiones.
Linux fue en un principio la solucion a una simple necesidad. Al unico software que
Linus Torvalds |autor y principal encargado de mantenimiento de Linux| pod a
acceder era Minix. Minix es un sistema operativo sencillo, del estilo UnixTM que se
1 N. del T.: en ingles multi-task

iii

utiliza ampliamente como herramienta didactica. Linus no estaba muy impresionado
por sus caracter sticas, y para solucionarlo se decidio a escribir su propio software.
Como modelo, eligio a UnixTM pues ese era el sistema operativo con el cual estaba
familiarizado en su vida estudiantil. Con una PC basada en el Intel 386 comenzo
a escribir. El progreso fue rapido y esto lo entusiasmo, decidio entonces ofrecer el
resultado de sus esfuerzos a otros estudiantes a traves de la emergente red mundial de
computadoras, que por ese entonces era utilizada principalmente por la comunidad
academica. Otros vieron as el software y comenzaron a contribuir. La mayor a del
nuevo software que se agregaba a traves de las contribuciones ten a su origen en
la solucion a un problema que ten a quien contribu a. Poco tiempo despues, Linux
se hab a transformado en un sistema operativo. Es importante destacar que Linux
no contiene codigo UnixTM pues se trata de una rescritura basada en los estandares
POSIX publicados. Linux se construyo con el software GNU (GNU's Not UnixTM )
producido por la Free Software Foundation (de Cambridge, Massachusetts en los
Estados Unidos de America) y utiliza muchos de los productos de software de GNU.
La mayor a de las personas utilizan Linux simplemente como una herramienta, y con
frecuencia lo instalan a partir de una de las buenas distribuciones basadas en CD-
ROM. Un monton de usuarios de Linux lo utilizan para escribir aplicaciones, o para
correr aplicaciones escritas por otros. Muchos leen avidamente los COMOs2 y sienten
la emocion del exito cuando con guran correctamente alguna parte del sistema, y la
frustracion del fracaso cuando no pueden hacerlo. Una minor a es lo su cientemente
avezada como para escribir controladores de dispositivo, y para ofrecer parches para
el nucleo a Linus Torvalds, el creador y responsable del mantenimiento del nucleo
de Linux. Linus acepta las adiciones y modi caciones a los fuentes del nucleo, no
importa de donde provengan o quien las env e. Esto puede sonar como una invitacion
a la anarqu a, pero Linus ejerce un estricto control de calidad e introduce el codigo
nuevo por s mismo. En un momento dado, solo un pu~ado de gente contribuye
n
fuentes al nucleo de Linux.
La mayor a de los usuarios de Linux no se jan en como funciona el sistema operativo,
o como es que forma una unidad. Es una lastima que as suceda, porque una muy
buena forma de aprender el funcionamiento de un sistema operativo es mirar como
lo hace Linux. Se trata de un sistema bien escrito, y no solo eso, sino que sus fuentes
estan disponibles libremente (y gratis) para que les eche una ojeada. Las cosas estan
as dispuestas porque si bien los autores retienen los derechos ( copyright ) que les
son propios sobre su software, permiten la libre distribucion de los fuentes bajo la
Licencia Publica de GNU, un proyecto de la Free Software Foundation. Sin embargo,
a primera vista los fuentes pueden confundirnos un poco vera usted directorios con
nombres como kernel, mm y net, pero >que contienen? y >como funciona todo ese
codigo? Lo que se necesita entonces es un entendimiento mas amplio de la estructura
general y proposito de Linux. Para alcanzar esta nalidad, se ha escrito este libro:
para promover una clara comprension de como trabaja el sistema operativo Linux.
Deseo proporcionarle un modelo mental que le permita imaginarse que es lo que
sucede en el sistema cuando usted copia un chero de un lado a otro, o cuando lee su
correo electronico. Recuerdo muy bien el entusiasmo que sent cuando me di cuenta
por primera vez de la manera que el sistema funcionaba. Ese entusiasmo es lo que
quiero transmitir a los lectores de este libro.
Mi compromiso con Linux comienza a nales de 1994 cuando visite a Jim Paradis
2Un COMO es, como dice la palabra, un documento que describe como hacer algo. En ingles se
denominan HOWTO s.

que estaba trabajando para transportar Linux a sistemas basados en el procesador
Alpha AXP. He trabajado para Digital Equipment Co. Limited desde 1984, la mayor
parte en redes y comunicaciones, y en 1992 comence a trabajar en la recientemen-
te formada division Digital Semiconductor. La meta de esta division era meterse
completamente en el mercado de fabricantes de chips, en particular el rango de mi-
croprocesadores Alpha AXP y sus placas de sistema, y vender esos productos fuera
de Digital. Cuando escuche acerca de Linux por primera vez, inmediatamente vi una
oportunidad para vender mas hardware Alpha AXP. El entusiasmo de Jim era atra-
pante, y comence a ayudarlo en el transporte del codigo. A medida que trabajaba
en esto, empece a apreciar cada vez mas el sistema operativo, pero sobre todo a la
comunidad de ingenieros que lo produce. Se trata de un grupo de gente destaca-
ble, con cualquier paramtero que se los mida, y al involucrarme con ellos y con el
nucleo de Linux viv tal vez el per odo mas satisfactorio del tiempo que dedique al
desarrollo de software. La gente muchas veces me pregunta acerca de Linux en el
trabajo y en casa, y me hace muy feliz complacerles. Cuanto mas uso Linux tanto
en mi vida profesional como personal, mas me transformo en un celote de Linux.
Debe advertir que utilizo el termino entusiasta , y no fanatico mi de nicion
de entusiasta es una persona que reconoce la existencia de otros sistemas operativos,
pero pre ere no utilizarlos. Como mi esposa, Gill, que utiliza Windows 95, cierta vez
comento: Nunca hubiera pensado que tuvieramos el sistema operativo `de el' y el
`de ella' . Para m , como ingeniero, Linux satisface plenamente mis necesidades. Es
una herramienta de ingenier a super, exible y adaptable. La mayor a del software
disponible en forma libre puede compilarse facilmente para Linux, y con frecuencia
solo necesito obtener los binarios ya listos para ejecutar, o los instalo desde un CD
ROM. >Que otra cosa podr a utilizar para aprender a programar en C++, Perl, o
Java, y encima gratis?
Alpha AXP es solo una de las varias plataformas sobre las cuales corre Linux. La
mayor a de los nucleos de Linux estan funcionando sobre sistemas basados en procesa-
dores Intel, pero los sistemas Linux que corren en plataformas de hardware distintas
de Intel estan creciendo en numero, y estan disponibles de manera mas rutinaria.
Entre ellos estan Alpha AXP, MIPS, Sparc y PowerPC. Podr a haber escrito este
libro utilizando cualquiera de esas plataformas, pero mi conocimiento previo y ex-
periencias tecnicas con Linux se han dado con Linux en el Alpha AXP, y ese es el
motivo por el cual en este libro se usa dicho hardware para ilustrar algunos puntos
clave. Debe destacarse que cerca del 95% de los fuentes del nucleo de Linux es comun
a todas las plataformas de hadrware en las que corre. En el mismo sentido, alrededor
del 95% de este libro trata de las partes del nucleo de Linux independientes de la
maquina.

Per l del lector
Este libro no hace ninguna presuncion acerca del conocimiento o experiencia del
lector. Creo que el interes en el tema en cuestion fomentara el proceso de autoa-
prendizaje cuando sea requerido. Dicho esto, debo agregar que para que el lector
obtenga un bene cio real a partir de este material, ayudara un cierto grado de fa-
miliaridad con las computadoras, preferiblemente del tipo PC, y algun conocimiento
del lenguaje de programacion C.

Organizacion de este libro
Este libro no esta pensado para usarse como un manual de los aspectos internos
de Linux. En lugar de ello, se trata de una introduccion a los sistemas operativos
en general, y a linux en particular. Cada uno de los cap tulos siguen mi regla de
trabajar desde lo general a lo particular . Primero se presenta un panorama del
subsistema en cuestion, antes de lanzarse sobre los detalles espec cos.
En forma deliberada, no se describen los algoritmos del nucleo, que son los metodos
que utiliza para hacer las tareas, en terminos de la rutina X llama a la rutina Y,
la cual incrementa el campo foo en la estructura de datos bar. Si desea ver eso, no
tiene mas que mirar el codigo. Cada vez que necesito comprender una porcion de
codigo, o tengo de explicarsela a otra persona, con frecuencia comienzo por dibujar
sus estructuras de datos en una pizarra. Por ello, he descripto con cierto detalle
muchas de las estructuras de datos relevantes del nucleo.
Cada cap tulo es relativamente independiente, como los subsistemas del nucleo de
Linux que desribe cada uno de ellos. algunas veces, sin embargo, hay conexiones por
ejemplo, no se puede describir un proceso sin entender como funciona la memoria
virtual.
El cap tulo Aspectos basicos del hardware (Cap tulo 1) nos da una breve intro-
duccion a la PC moderna. Un sistema operativo debe trabajar ntimamente asociado
con el hardware del sistema que funciona como su cimiento. El sistema operativo
necesita ciertos servicios que solo pueden ser provistos por el hardware. Para enten-
der completamente el sistema operativo Linux, debera usted entender los aspectos
basicos del hardware subyacente.
El cap tulo Aspectos basicos del software (Cap tulo 2) introduce principios basicos
de software y pone una mirada en los lenguajes ensamblador y C. Aqu se aprecian
las herramientas que se utilizan para construir un sistema como Linux y se da un
panorama de la nalidad y funciones de un sistema operativo.
El cap tulo Gestion de memoria (Cap tulo 3) describe la forma en la cual Linux
administra las memorias f sica y virtual en el sistema.
El cap tulo Procesos (Cap tulo 4) describe que es un proceso, y como hace el
nucleo para crear, gestionar y eliminar los procesos en el sistema.
Los procesos se comunican entre s y con el nucleo a los nes de coordinar sus
actividades. En Linux hay disponibles cierto numero de mecanismos de comunicacion
inter-proceso (Inter-Process Communication : IPC) mechanisms. Dos de ellos son las
se~ales y las tuber as tambien se dispone del mecanismo de IPC conocido como tipo
n
System V, y que toma ese nombre a partir de su entrega con el sistema UnixTM , en
el cual aparecio por vez primera. Estos mecanismos de comunicacion entre procesos
se describen en el Cap tulo 5.
El estandar Peripheral Component Interconnect (PCI) se ha establecido rmemente
en la actualidad como el bus de alta perfomance y bajo costo para las PCs. El
cap tulo sobre PCI (Cap tulo 6) describe como hace el nucleo Linux para inicializar
y utilizar los buses y dispositivos PCI existentes en el sistema.
El cap tulo sobre Interrupciones y gestion de interrupciones (Cap tulo 7) nos
muestra como maneja las interrupciones el nucleo Linux. Si bien el nucleo tiene
mecanismos e interfaces genericos para la gestion de las interrupciones, parte de los
detalles de esta gestion es dependiente del hardware y de las cuestiones espec cas

de la arquitectura.
Uno de los puntos fuertes de Linux es su capacidad de funcionar con muchos de los
dispositivos de hardware disponibles para la PC moderna. El cap tulo sobre Con-
troladores de dispositivos (Cap tulo 8) describe como se controlan los dispositivos
f sicamente conectados al sistema.
El cap tulo sobre el Sistema de cheros (Cap tulo 9) describe como se mantienen
los cheros en el sistema de cheros que les da sosten. Se describe el Sistema de
cheros virtual (Virtual File System : VFS) y como se gestionan los sistemas de
cheros reales desde el nucleo Linux.
Redes y Linux son casi sinonimos. En cierta forma (muy real por cierto) Linux es
un producto de la Internet o de la World Wide Web (WWW). Sus desarrolladores
y usuarios utilizan la web para intercambiar informacion, ideas, codigo, y Linux en
s mismo con frecuencia se utiliza para sustentar las necesidades en el tema redes
que tienen las organizaciones. El Cap tulo 10 describe como funciona Linux con los
protocolos conocidos colectivamente como TCP/IP.
El cap tulo Mecanismos del nucleo (Cap tulo 11) nos muestra algunas de las tareas
y mecanismos generales que el nucleo Linux tiene que proveer, de manera que las
otras secciones del nucleo puedan trabajar efectivamente juntas.
El cap tulo Modulos (Cap tulo 12) describe la manera en la cual el nucleo Linux
puede cargar funciones dinamicamente , por ejemplo un sistema de cheros, solo
cuando se necesitan.
El cap tulo Fuentes (Cap tulo 13) describe donde buscar una funcion en particular,
entre todos los fuentes del nucleo.

Convenciones utilizadas en el libro
La siguiente es una lista de convenciones tipogra cas que se utilizan a lo largo del
libro.
tipo lineal identi ca ordenes, u otro texto que deba
ser ingresado literalmente por el usuario.
tipo monoespaciado para referirnos a estructuras de datos,
o campos dentro de las estructuras de datos.
A lo largo del texto existen referencias a ciertas porciones de codigo dentro del arbol
de directorios del nucleo de Linux (por ejemplo, la nota al margen encerrada en un
recuadro y adyacente a este texto ). Si usted desea echar una ojeada al codigo por foo/bar.c en
Vea foo()
s mismo, encontrara de utilidad estas referencias todas las rferencias a los cheros
son relativas a /usr/src/linux. Tomemos foo/bar.c como ejemplo, entonces el
nombre completo sera /usr/src/linux/foo/bar.c. Si usted esta utilizando Linux
(y deber a), entonces puede obtener una provechosa experiencia al mirar el codigo, y
puede utilizar este libro como ayuda para entender tanto el codigo como sus multiples
estructuras de datos.

Marcas registradas
Caldera, OpenLinux y el logotipo C" son marcas registradas de Caldera, Inc.
Caldera OpenDOS 1997 es una marca registrada de Caldera, Inc.

DEC es una marca registrada de Digital Equipment Corporation.
DIGITAL es una marca registrada de Digital Equipment Corporation.
Linux es una marca registrada de Linus Torvalds.
Motif es una marca registrada de The Open System Foundation, Inc.
MSDOS es una marca registrada de Microsoft Corporation.
Red Hat, glint y el logotipo Red Hat logo son marcas registradas de Red Hat Software,
Inc.
UNIX es una marca registrada de X/Open.
XFree86 es una marca registrada de XFree86 Project, Inc.
X Window System es una marca registrada de el X Consortium y del Massachusetts
Institute of Technology.

Agradecimientos
Debo agradecer a las muchas personas que han sido tan amables como para tomarse
el tiempo para enviarme por correo electronico sus comentarios acerca de este libro.
He intentado incorporar dichos comentarios en cada nueva version que he producido.
Estoy especialmente agradecido a John Rigby y Michael Bauer que me proporcio-
naron completas y detalladas notas de revision de todo el libro. Una tarea nada
facil.

Indice General
Prefacio iii
1 Aspectos basicos del hardware 1
1.1 La CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Buses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Controladores y perifericos . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Espacios de direcciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 Cronometros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2 Aspectos basicos del software 7
2.1 Lenguajes de computadora . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Lenguajes ensambladores . . . . . . . . . . . . . . . . . . . . . 7
2.1.2 El Lenguaje de Programacion C y su Compilador . . . . . . . . 8
2.1.3 Enlazadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 >Que es un sistema operativo? . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Gestion de memoria . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.2 Procesos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.3 Controladores de unidad . . . . . . . . . . . . . . . . . . . . . . 11
2.2.4 El Sistema de Ficheros . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Estructuras de datos del nucleo . . . . . . . . . . . . . . . . . . . . . . 12
2.3.1 Lista Enlazadas . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.2 Tablas Hash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.3 Interfaces Abstractos . . . . . . . . . . . . . . . . . . . . . . . . 13
3 Gestion de memoria 15
3.1 Modelo Abstracto de Memoria Virtual . . . . . . . . . . . . . . . . . . 16
3.1.1 Paginacion por Demanda . . . . . . . . . . . . . . . . . . . . . 18
3.1.2 Intercambio (swapping) . . . . . . . . . . . . . . . . . . . . . . 19
3.1.3 Memoria virtual compartida . . . . . . . . . . . . . . . . . . . . 20
3.1.4 Modos de direccionamiento f sico y virtual . . . . . . . . . . . . 20
3.1.5 Control de acceso . . . . . . . . . . . . . . . . . . . . . . . . . . 20

ix

3.2 Caches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3 Tablas de Paginas en Linux . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4 Asignacion y liberacion de paginas . . . . . . . . . . . . . . . . . . . . 24
3.4.1 Asignacion de paginas . . . . . . . . . . . . . . . . . . . . . . . 25
3.4.2 Liberacion de paginas . . . . . . . . . . . . . . . . . . . . . . . 26
3.5 Proyeccion de Memoria (Memory Mapping) . . . . . . . . . . . . . . . 26
3.6 Paginacion por Demanda . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.7 La Cache de Paginas de Linux . . . . . . . . . . . . . . . . . . . . . . 28
3.8 Intercambiando y Liberando Paginas . . . . . . . . . . . . . . . . . . . 29
3.8.1 Reduciendo el tama~o de la Cache de Paginas y el Bu er Cache
n 30
3.8.2 Intercambio de Paginas compartidas (System V Shared Me-
mory Pages) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.8.3 Intercambiando y Descartando Paginas . . . . . . . . . . . . . 32
3.9 La cache de Intercambio . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.10 Cargando Paginas de Intercambio . . . . . . . . . . . . . . . . . . . . . 34
4 Procesos 37
4.1 Procesos de Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2 Identi cadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.3 Plani cacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.3.1 Plani cacion en Sistemas Multiprocesador . . . . . . . . . . . . 44
4.4 Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.5 Memoria Virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.6 Creacion de un Proceso . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.7 Tiempos y Temporizadores . . . . . . . . . . . . . . . . . . . . . . . . 49
4.8 Ejecucion de Programas . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.8.1 ELF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.8.2 Ficheros de Guion . . . . . . . . . . . . . . . . . . . . . . . . . 53
5 Mecanismos de Comunicacion Interprocesos 55
5.1 Se~ales . . . . . . . . . . . . . . . .
n . . . . . . . . . . . . . . . . . . . . 55
5.2 Tuber as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.3 Enchufes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5.3.1 Mecanismos IPC System V . . . . . . . . . . . . . . . . . . . . 59
5.3.2 Colas de Mensajes . . . . . . . . . . . . . . . . . . . . . . . . . 60
5.3.3 Semaforos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.3.4 Memoria Compartida . . . . . . . . . . . . . . . . . . . . . . . 63
6 PCI 65
6.1 PCI Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
6.2 PCI Con guration Headers . . . . . . . . . . . . . . . . . . . . . . . . 66

6.3 PCI I/O and PCI Memory Addresses . . . . . . . . . . . . . . . . . . . 68
6.4 PCI-ISA Bridges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
6.5 PCI-PCI Bridges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
6.5.1 PCI-PCI Bridges: PCI I/O and PCI Memory Windows . . . . 69
6.5.2 PCI-PCI Bridges: PCI Con guration Cycles and PCI Bus
Numbering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
6.6 Linux PCI Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.6.1 The Linux Kernel PCI Data Structures . . . . . . . . . . . . . 71
6.6.2 The PCI Device Driver . . . . . . . . . . . . . . . . . . . . . . 72
6.6.3 PCI BIOS Functions . . . . . . . . . . . . . . . . . . . . . . . . 74
6.6.4 PCI Fixup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
7 Interrupciones y Manejo de Interrupciones 79
7.1 Controladores de Interrupciones Programables . . . . . . . . . . . . . 81
7.2 Inicializando las Estructuras de Datos del Manejo de Interrupciones . 81
7.3 Manejo de Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . 83
8 Device Drivers 85
8.1 Polling and Interrupts . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
8.2 Direct Memory Access (DMA) . . . . . . . . . . . . . . . . . . . . . . 87
8.3 Memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
8.4 Interfacing Device Drivers with the Kernel . . . . . . . . . . . . . . . . 89
8.4.1 Character Devices . . . . . . . . . . . . . . . . . . . . . . . . . 89
8.4.2 Block Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
8.5 Hard Disks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
8.5.1 IDE Disks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
8.5.2 Initializing the IDE Subsystem . . . . . . . . . . . . . . . . . . 94
8.5.3 SCSI Disks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
8.6 Network Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8.6.1 Initializing Network Devices . . . . . . . . . . . . . . . . . . . . 100
9 The File system 103
9.1 The Second Extended File system (EXT2) . . . . . . . . . . . . . . . . 105
9.1.1 The EXT2 Inode . . . . . . . . . . . . . . . . . . . . . . . . . . 106
9.1.2 The EXT2 Superblock . . . . . . . . . . . . . . . . . . . . . . . 107
9.1.3 The EXT2 Group Descriptor . . . . . . . . . . . . . . . . . . . 108
9.1.4 EXT2 Directories . . . . . . . . . . . . . . . . . . . . . . . . . . 108
9.1.5 Finding a File in an EXT2 File System . . . . . . . . . . . . . 109
9.1.6 Changing the Size of a File in an EXT2 File System . . . . . . 110
9.2 The Virtual File System (VFS) . . . . . . . . . . . . . . . . . . . . . . 111
9.2.1 The VFS Superblock . . . . . . . . . . . . . . . . . . . . . . . . 113

9.2.2 The VFS Inode . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
9.2.3 Registering the File Systems . . . . . . . . . . . . . . . . . . . 114
9.2.4 Mounting a File System . . . . . . . . . . . . . . . . . . . . . . 115
9.2.5 Finding a File in the Virtual File System . . . . . . . . . . . . 117
9.2.6 Creating a File in the Virtual File System . . . . . . . . . . . . 117
9.2.7 Unmounting a File System . . . . . . . . . . . . . . . . . . . . 117
9.2.8 The VFS Inode Cache . . . . . . . . . . . . . . . . . . . . . . . 117
9.2.9 The Directory Cache . . . . . . . . . . . . . . . . . . . . . . . . 118
9.3 The Bu er Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.3.1 The bdflush Kernel Daemon . . . . . . . . . . . . . . . . . . . 120
9.3.2 The update Process . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.4 The /proc File System . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.5 Device Special Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
10 Networks 123
10.1 An Overview of TCP/IP Networking . . . . . . . . . . . . . . . . . . . 123
10.2 The Linux TCP/IP Networking Layers . . . . . . . . . . . . . . . . . . 126
10.3 The BSD Socket Interface . . . . . . . . . . . . . . . . . . . . . . . . . 126
10.4 The INET Socket Layer . . . . . . . . . . . . . . . . . . . . . . . . . . 129
10.4.1 Creating a BSD Socket . . . . . . . . . . . . . . . . . . . . . . 131
10.4.2 Binding an Address to an INET BSD Socket . . . . . . . . . . 131
10.4.3 Making a Connection on an INET BSD Socket . . . . . . . . . 132
10.4.4 Listening on an INET BSD Socket . . . . . . . . . . . . . . . . 133
10.4.5 Accepting Connection Requests . . . . . . . . . . . . . . . . . . 133
10.5 The IP Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
10.5.1 Socket Bu ers . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
10.5.2 Receiving IP Packets . . . . . . . . . . . . . . . . . . . . . . . . 135
10.5.3 Sending IP Packets . . . . . . . . . . . . . . . . . . . . . . . . . 136
10.5.4 Data Fragmentation . . . . . . . . . . . . . . . . . . . . . . . . 137
10.6 The Address Resolution Protocol (ARP) . . . . . . . . . . . . . . . . . 137
10.7 IP Routing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
10.7.1 The Route Cache . . . . . . . . . . . . . . . . . . . . . . . . . . 139
10.7.2 The Forwarding Information Database . . . . . . . . . . . . . . 140
11 Kernel Mechanisms 143
11.1 Bottom Half Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
11.2 Task Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
11.3 Timers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
11.4 Wait Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
11.5 Buzz Locks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

11.6 Semaphores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
12 Modules 149
12.1 Loading a Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
12.2 Unloading a Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
13 El codigo fuente del nucleo de Linux 155
A Las estructuras de datos de Linux 161
B El procesador AXP de Alpha 181
C Lugares utiles en Web y FTP 183
D The GNU General Public License 185
D.1 Preamble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
D.2 Terms and Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
D.3 How to Apply These Terms . . . . . . . . . . . . . . . . . . . . . . . . 190
Glosario 193
Bibliograf a 196

Indice de Figuras
1.1 Una placa madre de PC t pica. . . . . . . . . . . . . . . . . . . . . . . 2
3.1 Modelo abstracto de traduccion de memoria virtual a f sica. . . . . . . 16
3.2 Entrada de tabla de paginas del Alpha AXP . . . . . . . . . . . . . . . 21
3.3 Tablas de paginas de tras niveles . . . . . . . . . . . . . . . . . . . . . 23
3.4 La estructura de datos free area . . . . . . . . . . . . . . . . . . . . . 25
3.5 Areas de Memoria Virtual . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.6 La Cache de Paginas de Linux . . . . . . . . . . . . . . . . . . . . . . 29
4.1 Los Ficheros de un Proceso . . . . . . . . . . . . . . . . . . . . . . . . 45
4.2 La Memoria Virtual de un Proceso . . . . . . . . . . . . . . . . . . . . 47
4.3 Formatos Binarios Registrados . . . . . . . . . . . . . . . . . . . . . . 51
4.4 El Formato de Ficheros Ejecutable ELF . . . . . . . . . . . . . . . . . 52
5.1 Tuber as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.2 Colas de Mensajes IPC System V . . . . . . . . . . . . . . . . . . . . . 60
5.3 Semaforos IPC System V . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.4 Memoria Compartida IPC System V . . . . . . . . . . . . . . . . . . . 63
6.1 Example PCI Based System . . . . . . . . . . . . . . . . . . . . . . . . 66
6.2 The PCI Con guration Header . . . . . . . . . . . . . . . . . . . . . . 67
6.3 Type 0 PCI Con guration Cycle . . . . . . . . . . . . . . . . . . . . . 69
6.4 Type 1 PCI Con guration Cycle . . . . . . . . . . . . . . . . . . . . . 69
6.5 Linux Kernel PCI Data Structures . . . . . . . . . . . . . . . . . . . . 71
6.6 Con guring a PCI System: Part 1 . . . . . . . . . . . . . . . . . . . . 73
6.10 PCI Con guration Header: Base Address Registers . . . . . . . . . . . 76
7.1 Un diagrama logico del rutado de interrupciones . . . . . . . . . . . . 80
7.2 Estructuras de Datos del Manejo de Interrupciones en Linux . . . . . 83
8.1 Character Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

xv

8.2 Bu er Cache Block Device Requests . . . . . . . . . . . . . . . . . . . 91
8.3 Linked list of disks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
8.4 SCSI Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
9.1 Physical Layout of the EXT2 File system . . . . . . . . . . . . . . . . 105
9.2 EXT2 Inode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
9.3 EXT2 Directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.4 A Logical Diagram of the Virtual File System . . . . . . . . . . . . . . 111
9.5 Registered File Systems . . . . . . . . . . . . . . . . . . . . . . . . . . 114
9.6 A Mounted File System . . . . . . . . . . . . . . . . . . . . . . . . . . 116
9.7 The Bu er Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
10.1 TCP/IP Protocol Layers . . . . . . . . . . . . . . . . . . . . . . . . . . 125
10.2 Linux Networking Layers . . . . . . . . . . . . . . . . . . . . . . . . . 127
10.3 Linux BSD Socket Data Structures . . . . . . . . . . . . . . . . . . . . 130
10.4 The Socket Bu er (sk bu ) . . . . . . . . . . . . . . . . . . . . . . . . 134
10.5 The Forwarding Information Database . . . . . . . . . . . . . . . . . . 140
11.1 Bottom Half Handling Data Structures . . . . . . . . . . . . . . . . . . 143
11.2 A Task Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
11.3 System Timers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
11.4 Wait Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
12.1 The List of Kernel Modules . . . . . . . . . . . . . . . . . . . . . . . . 151

Cap tulo 1
Aspectos basicos del
hardware
Un sistema operativo debe trabajar ntimamente con el hardware que
le sirve de cimientos. El sistema operativo necesita ciertos servicios que
solo pueden suministrar el hardware. Para entender totalmente el sistema
operativo Linux, se necesita entender los aspectos basicos del hardware
que hay debajo. Este cap tulo muestra una breve introduccion a dicho
hardware: el PC moderno.
Cuando el numero de Enero de 1975 de la revista Popular Electronics" salio impreso
con una ilustracion del Altair 8080 en su portada, comenzo una revolucion. El
Altair 8080, llamado as por el lugar de destino de uno de los primeros episodios
de Star Trek, pod a ser ensamblado por entusiastas de la electronica domestica por
solo unos $397. Con su procesador Intel 8080 y 256 bytes de memoria, pero sin
pantalla ni teclado, era una baratija segun los estandares actuales. Su inventor,
Ed Roberts, acu~o el termino computadora personal" (personal computer) para
n
describir su nuevo invento, pero el termino PC se usa ahora para referirse a casi
cualquier ordenador que una persona puede levantar del suelo sin necesidad de ayuda.
Siguiendo esta de nicion, incluso algunos de los muy poderosos sistemas Alpha AXP
son PCs.
Los hackers entusiastas vieron el potencial del Altair, y comenzaron a escribir softwa-
re y construir hardware para el. Para esos primeros pioneros representaba libertad
liberarse de los enormes sistemas mainframe" con sus colas de proceso, adminis-
trados y protegidos por una elite clerical. Grandes fortunas fueron hechas de la
noche a la ma~ana por gente que abandonaba los estudios fascinados por este nuevo
n
fenomeno, una computadora que se pod a tener en casa sobre la mesa de la cocina.
Una gran cantidad de hardware estaba apareciendo, cada uno diferente de los demas
hasta cierto punto, y los hackers del software estaban felices de escribir software
para esas nuevas maquinas. Paradojicamente, fue IBM quien cincelo el molde del
PC moderno anunciando el IBM PC en 1981, y sirviendoselo a los compradores a
principios de 1982. Con su procesador Intel 8088, 64K de memoria (expandible a
256K), dos unidades de discos exibles y un Adaptador de Gra cos en Color (Co-
lour Graphics Adapter - CGA) de 80 caracteres por 25 l neas, no era muy poderoso
segun los estandares actuales, pero se vendio bien. Fue seguido, en 1983, por el IBM
PC-XT, que contaba con el lujo de un disco duro de 10Mbyte. No paso demasiado

1

power power

parallel port
CPU
COM1 COM2

Memory SIMM Slots

PCI Slots

ISA Slots

Figura 1.1: Una placa madre de PC t pica.

tiempo hasta que los clones del IBM PC comenzaron a ser producidos por una hueste
de compa~ as como por ejemplo Compaq, y la arquitectura del PC se convirtio en
n
un estandar de hecho. Este estandar de hecho ayudo a una multitud de empresas
de hardware a competir entre ellas en un mercado creciente que, para alegr a de
los consumidores, mantuvo los precios bajos. Muchas de las caracter sticas arqui-
tectonicas del sistema de aquellos primitivos PCs se han mantenido hasta llegar al
PC moderno. Por ejemplo, incluso el mas poderoso sistema basado en el Pentium
Pro de Intel arranca en el modo de direccionamiento del Intel 8086. Cuando Linus
Torvalds comenzo a escribir lo que se convertir a en Linux, escogio el hardware mas
completo y de precio mas razonable, un PC Intel 80386.

Mirando un PC desde fuera, los componentes mas obvios son una caja de sistema,
un teclado, un raton y un monitor de v deo. En el frente de la caja del sistema
hay algunos botones, un peque~o indicador que muestra algunos numeros y una
n
disquetera. La mayor a de los sistemas actualmente tienen un CD ROM, y si uno
siente que debe proteger sus datos, entonces habra tambien una unidad de cinta para
copias de seguridad. Esos dispositivos se conocen de modo colectivo como perifericos.

Aunque la CPU controla todo el sistema, no es el unico dispositivo inteligente. Todos
los controladores de perifericos, por ejemplo el controlador IDE, tienen algun nivel de
inteligencia. Dentro del PC (Figura 1.1) se puede ver una placa madre que contienen
la CPU o microprocesador, la memoria y un numero de conectores (slots) para los
controladores de perifericos ISA o PCI. Algunos de los controladores, por ejemplo el
controlador de disco IDE, pueden estar integrados en la placa del sistema.

1.1 La CPU
La CPU, o mejor, microprocesador, es el corazon de cualquier computadora. El
microprocesador calcula, realiza operaciones logicas y gestiona ujos de datos leyen-
do instrucciones desde la memoria y ejecutandolas. En los primeros d as de la in-
formatica los componentes funcionales del microprocesador eran unidades separadas
(y grandes f sicamente). Fue entonces cuando se acu~o el termino Unidad Central
n
de Proceso (Central Processing Unit). El microprocesador moderno combina esos
componentes en un circuito integrado, grabado en una peque~a pieza de silicio. Los
n
terminos CPU, microprocesador y procesador se usan de manera intercambiable en
este libro.
Los microprocesadores operan sobre datos binarios estos son datos compuestos de
unos y ceros. Estos unos y ceros corresponden a interruptores electricos que estan
encendidos o apagados. Igual que 42 es un numero decimal que signi ca 4 decenas
y 2 unidades", un numero binario es una serie de d gitos binarios, cada uno repre-
sentando una potencia de 2. En este contexto, una potencia signi ca el numero de
veces que un numero es multiplicado por si mismo. 10 elevado a 1 ( 101 ) es 10, 10
elevado a 2 ( 102 ) es 10x10, 103 es 10x10x10 y as sucesivamente. 0001 en binario es
1 en decimal, 0010 en binario es 2 en decimal, 0011 en binario es 3, 0100 en binario
es 4, y as sucesivamente. As , 42 en decimal es 101010 en binario o (2 + 8 + 32 o
21 + 23 + 25). En vez de usar el binario para representar numeros en los programas
de computadora, otra base, la hexadecimal, es la que se usa normalmente. En esta
base, cada d gito representa una potencia de 16. Como los numeros decimales van
solo de 0 a 9, los numeros del 10 al 15 se representan con un unico d gito usando las
letras A, B, C, D, E y F. Por ejemplo, E en hexadecimal es 14 en decimal y 2A en
hexadecimal es 42 en decimal ((dos veces 16) + 10). Usando la notacion del lenguaje
de programacion C (como hago a lo largo de este libro) los numeros hexadecimales
llevan el pre jo 0x" el hexadecimal 2A se escribe como 0x2A .
Los microprocesadores pueden realizar operaciones aritmeticas como sumar, multi-
plicar y dividir, y operaciones logicas como >es X mayor que Y?".
La ejecucion del procesador viene gobernada por un reloj externo. Este reloj, el reloj
del sistema, env a pulsos de reloj regulares al procesador y, a cada pulso de reloj,
el procesador hace algun trabajo. Por ejemplo, un procesador podr a ejecutar una
instruccion a cada pulso de reloj. La velocidad del procesador se describe en terminos
de la frecuencia de pulsos del reloj del sistema. Un procesador de 100Mhz recibira 100
000 000 pulsos de reloj cada segundo. Puede llevar a confusion describir la potencia de
una CPU por su frecuencia de reloj ya que diferentes procesadores realizan diferentes
cantidades de trabajo a cada pulso de reloj. De todos modos, si el resto de las
caracter sticas son iguales, una mayor velocidad de reloj signi ca un procesador mas
potente. Las instrucciones ejecutadas por el procesador son muy simples por ejemplo
copia en el registro Y el contenido de la posicion X de la memoria". Los registros
son el almacen interno del microprocesador, se usan para almacenar datos y realizar
operaciones sobre ellos. Las operaciones realizadas pueden hacer que el procesador
deje de hacer los que estaba haciendo y salte a otra instruccion en otra parte de la
memoria. Estos peque~os ladrillos dan al microprocesador moderno un poder casi
n
ilimitado ya que puede ejecutar millones o incluso miles de millones de instrucciones
por segundo.
Las instrucciones deben ser obtenidas de la memoria para irlas ejecutando. Las

propias instrucciones pueden hacer referencia a datos en la memoria, y esos datos
deben ser obtenidos de la memoria y guardados en ella cuando se requiera.
El tama~o, numero y tipo de registros dentro de un microprocesador depende ente-
n
ramente de su tipo. Un procesador Intel 486 tiene un conjunto diferente de registros
que un procesador Alpha AXP para empezar, los del Intel son de 32 bits de ancho,
y los del Alpha AXPson de 64 bits. En general, sin embargo, cualquier procesador
tendra un numero de registros de proposito general y un numero menor de registros
dedicados. La mayor a de los procesadores tiene los siguientes registros de proposito
espec co o dedicados:
Contador de Programa (Program Counter - PC) Este registro contiene la di-
reccion de la siguiente instruccion a ejecutar. Los contenidos del PC se incre-
mentan automaticamente cada vez que se obtiene una instruccion.
Puntero de Pila (Stack Pointer - SP) Los procesadores deben tener acceso a
grandes cantidades de memoria de acceso aleatorio (random access memory -
RAM) externa para lectura y escritura, que facilite el almacenamiento tempo-
ral de datos. La pila es una manera de guardar y recuperar facilmente valores
temporales en la memoria externa. Normalmente, los procesadores tienen ins-
trucciones especiales que permiten introducir (push) valores en la pila y extra-
erlos (pop) de nuevo mas tarde. La pila funciona en un regimen de ultimo en
entrar, primero en salir" (last in rst out - LIFO). En otras palabras, si uno
introduce dos valores, x e y, en una pila, y luego extrae un valor de dicha pila,
obtendra el valor y.
Las pilas de algunos procesadores crecen hacia el nal de la memoria mientras
que las de otros crecen hacia el principio, o base, de la memoria. Algunos
procesadores permiten los dos tipos, como por ejemplo los ARM.
Estado del Procesador (Processor Status - PS) Las instrucciones pueden dar
lugar a resultados por ejemplo es el contenido del registro X mayor que el
contenido del registro Y?" dara como resultado verdadero o falso. El registro
PS mantiene esa y otra informacion sobre el estado del procesador. Por ejemplo,
la mayor a de los procesadores tienen al menos dos modos de operacion, nucleo
(o supervisor) y usuario. El registro PS mantendra informacion que identi que
el modo en uso.

1.2 Memoria
Todos los sistemas tienen una jerarqu a de memoria, con memoria de diferentes ve-
locidades y tama~os en diferentes puntos de la jerarqu a. La memoria mas rapida
n
se conoce como memoria cache (o tampon) y es una memoria que se usa para alma-
cenar temporalmente contenidos de la memoria principal. Este tipo de memoria es
muy rapida pero cara, por tanto la mayor a de los procesadores tienen una peque~an
cantidad de memoria cache en el chip y mas memoria cache en el sistema (en la
placa). Algunos procesadores tienen una cache para contener instrucciones y datos,
pero otros tienen dos, una para instrucciones y la otra para datos. El procesador
Alpha AXP tiene dos memorias cache internas una para datos (la Cache-D) y otra
para instrucciones (la Cache-I). La cache externa (o Cache-B) mezcla los dos juntos.
Finalmente esta la memoria principal, que comparada con la memoria cache externa
es muy lenta. Comparada con la cache en la CPU, la memoria principal se arrastra.

Las memorias cache y principal deben mantenerse sincronizadas (coherentes). En
otras palabras, si una palabra de memoria principal se almacena en una o mas posi-
ciones de la cache, el sistema debe asegurarse de que los contenidos de la cache y de
la memoria sean los mismos. El trabajo de coherencia de la cache es llevado a cabo
parcialmente por el hardware y parcialmente por el sistema operativo. Esto es cierto
tambien para un numero de tareas principales del sistema, donde el hardware y el
software deben cooperar ntimamente para alcanzar sus objetivos.

1.3 Buses
Los componentes individuales de la placa del sistema estan conectados entre s por
sistemas de conexion multiple conocidos como buses. El bus de sistema esta dividido
en tres funciones logicas el bus de direcciones, el bus de datos y el bus de control.
El bus de direcciones especi ca las posiciones de memoria (direcciones) para las
transferencias de datos. El bus de datos contiene los datos transferidos El bus de
datos es bidireccional permite escribir datos en la CPU y leerlos desde la CPU. El
bus de control contiene varias lineas que se usan para dirigir se~ales de sincronismo
n
y control a traves del sistema. Existen muchos tipos de bus, por ejemplo los buses
ISA y PCI son formas populares de conectar perifericos al sistema.

1.4 Controladores y perifericos
Los perifericos son dispositivos reales, como tarjetas gra cas o discos controlados por
chips controladores que se encuentran en la placa del sistema, o en tarjetas conectadas
a ella. Los discos IDE son controlados por el chip controlador IDE, y los discos SCSI
por los chips controladores de disco SCSI, y as sucesivamente. Estos controladores
estan conectados a la CPU y entre ellos por una variedad de buses. La mayor a de
los sistemas construidos actualmente usan buses PCI e ISA para conectar entre s
los principales componentes del sistema. Los controladores son procesadores como
la propia CPU, se pueden ver como asistentes inteligentes de la CPU. La CPU tiene
el control sobre todo el sistema.
Todos los controladores son diferentes, pero usualmente tienen registros que los con-
trolan. El software que se ejecute en la CPU debe ser capaz de leer y escribir en
esos registros de control. Un registro puede contener un estado que describa un error.
Otro puede ser usado para propositos de control cambiando el modo del controlador.
Cada controlador en un bus puede ser accedido individualmente por la CPU, esto es
as para que el software gestor de dispositivos pueda escribir en sus registros y as
controlarlo, La banda IDE es un buen ejemplo, ya que ofrece la posibilidad de acceder
a cada unidad en el bus por separado. Otro buen ejemplo es el bus PCI, que permite
acceder a cada dispositivo (por ejemplo una tarjeta gra ca) independientemente.

1.5 Espacios de direcciones
El bus del sistema conecta la CPU con la memoria principal y esta separado de los
buses que conectan la CPU con los perifericos. El espacio de memoria en el que
existen los perifericos hardware se conoce colectivamente como espacio de I/O (por
Input/Output, Entrada/Salida). El espacio de I/O puede estar subdividido a su

vez, pero no nos preocuparemos demasiado sobre eso de momento. La CPU puede
acceder a la memoria en el espacio del sistema y a la memoria en el espacio de I/O,
mientras que los controladores solo pueden acceder a la memoria en el espacio del
sistema indirectamente, y solo con la ayuda de la CPU. Desde el punto de vista del
dispositivo, digamos un controlador de disquetes, vera solo el espacio de direcciones
en el que se encuentran sus registros de control (ISA) y no la memoria del sistema.
T picamente, una CPU tendra instrucciones separadas para acceder al espacio de
memoria y al espacio de I/O. Por ejemplo, puede haber una instruccion que signi que
lee un byte de la direccion de I/O 0x3f0 y ponlo en el registro X". As es exactamente
como controla la CPU a los perifericos hardware del sistema, leyendo y escribiendo
en sus registros en el espacio de I/O. En que lugar del espacio I/O tienen sus registros
los perifericos comunes (controlador IDE, puerta serie, controlador de disco exible, y
demas) ha sido de nido por convenio a lo largo de los a~os conforme la arquitectura
n
del PC se ha desarrollado. Sucede que la direccion 0x3f0 del espacio I/O es la
direccion de uno de los registros de control de la puerta serie (COM1).
Existen ocasiones en las que los controladores necesitan leer o escribir grandes canti-
dades de datos directamente desde o a la memoria del sistema. Por ejemplo, cuando
se escriben datos del usuario al disco duro. En este caso, se usan controladores de
Acceso Directo a Memoria (Direct Memory Access - DMA) para permitir que los pe-
rifericos hardware accedan directamente a la memoria del sistema, pero este acceso
esta bajo el estricto control y supervision de la CPU.

1.6 Cronometros
Todos los sistemas operativos necesitan saber la hora, y as , el PC moderno incluye un
periferico especial llamado el Reloj de Tiempo Real (Real Time Clock - RTC). Este
dispositivo suministra dos cosas: una hora del d a able y un cronometro preciso.
El RTC tiene su propia bater a, de forma que siga funcionado incluso cuando el PC
no este encendido, as es como el PC sabe" siempre la fecha y hora correctas. El
cronometro permite que el sistema operativo plani que de manera precisa el trabajo
esencial.

Cap tulo 2
Aspectos basicos del software
Un programa es un conjunto de instrucciones de computadora que reali-
zan una tarea particular. Puede estar escrito en ensamblador, un lengua-
je de muy bajo nivel, o en un lenguaje de alto nivel, independiente de la
maquina, como el lenguaje de programacion C. Un sistema operativo es
un programa especial que permite al usuario ejecutar aplicaciones como
hojas de calculo y procesadores de texto. Este cap tulo introduce los prin-
cipios basicos de la programacion y da una idea general de los objetivos
y funciones de un sistema operativo.

2.1 Lenguajes de computadora
2.1.1 Lenguajes ensambladores
Las instrucciones que una CPU lee desde la memoria y despues ejecuta no son com-
prensibles para los seres humanos son codigos de maquina que dicen al ordenador
que hacer precisamente. El numero hexadecimal 0x89E5 es una instruccion de Intel
80486 que copia el contenido del registro ESP al registro EBP. Una de las primeras
herramientas de software inventadas para los primeros ordenadores fue un ensambla-
dor, un programa que toma un chero fuente le ble por los humanos y lo ensambla
en codigo maquina. Los lenguajes ensambladores se ocupan expl citamente de los
registros y las operaciones sobre los datos y son espec cos de un microprocesador
particular. El lenguaje ensamblador para un microprocesador X86 es muy diferente
del ensamblador de un microprocesador Alpha AXP. El codigo ensamblador siguien-
te, para Alpha AXP, muestra el tipo de operaciones que un programa puede realizar:
ldr r16, (r15) L nea 1
ldr r17, 4(r15) L nea 2
beq r16,r17,100 L nea 3
str r17, (r15) L nea 4
100: L nea 5

La primera sentencia (en la l nea 1) carga el valor del registro 16 de la direccion
guardada en el registro 15. La siguiente instruccion carga el valor del registro 17
desde la siguiente posicion en la memoria. La l nea 3 compara el contenido del

7

registro 16 con el del 17 y, si son iguales, salta a la etiqueta 100. Si los registros
no contienen el mismo valor, el programa sigue por la l nea 4 donde el contenido
de r17 es salvado en la memoria. Si los registros contienen el mismo valor entonces
ningun dato necesita ser salvado. Los programas en ensamblador son muy tediosos y
dif ciles de escribir, y sujetos a errores. Muy poco en el nucleo de Linux esta escrito
en lenguaje ensamblador, y aquellas partes que lo estan han sido escritas solo por
e ciencia y son espec cas de un procesador particular.

2.1.2 El Lenguaje de Programacion C y su Compilador
Escribir programas grandes en lenguaje ensamblador es una tarea dif cil y larga. Es
propensa a errores y el programa resultante no es portable, al estar atado a una
familia de procesadores particular. Es mucho mejor usar un lenguaje independiente
de la maquina, como C 7, The C Programming Language]. C le permite describir
los programas en terminos de sus algoritmos logicos y de los datos con los que ope-
ran. Unos programas especiales llamados compiladores leen el programa en C y lo
traducen a lenguaje ensamblador, generando el codigo espec co de la maquina a
partir de este. Un buen compilador puede generar instrucciones en ensamblador casi
tan e cientes como la escritas por un buen programador de ensamblador. La mayor
parte del nucleo de Linux esta escrita en lenguaje C. El fragmento de C siguiente
if (x != y)
x = y

hace exactamente las mismas operaciones que el ejemplo anterior de codigo ensam-
blador. Si el contenido de la variable x no es el mismo que el de la variable y el
contenido de y es copiado a x. El codigo en C esta organizado en rutinas, de las
cuales cada una cumple una funcion. Las rutinas pueden devolver cualquier valor
o tipo de dato soportado por C. Los programas grandes, como el nucleo de Linux,
contienen muchos modulos separados de codigo C, cada uno con sus propias rutinas
y estructuras de datos. Estos modulos de codigo fuente en C se agrupan en funciones
logicas, como el codigo para el manejo del sistemas de cheros.
C soporta muchos tipos de variables una variable es una posicion en la memoria que
puede ser referenciada por un nombre simbolico. En el fragmento anterior de C, x e
y hacen referencia a las posiciones en la memoria. El programador no se preocupa de
donde son guardadas las variables, es el enlazador (vease abajo) quien se preocupa
de esto. Las variables contienen diferentes tipos de datos enteros o numeros de coma
otante, as como punteros.
Los punteros son variables que contienen la direccion, es decir la posicion en memoria,
de otro dato. Considere una variable llamada x que reside en la memoria en la
direccion 0x80010000. Podr a tener un puntero, llamado px, que apunta a x. px podia
residir en la direccion 0x80010030. El valor de px ser a 0x80010000: la direccion de
la variable x.
C le permite unir variables relacionadas en estructuras de datos. Por ejemplo,
struct {
int i
char b
} mi_estruc

es una estructura llamada miestruc que contiene dos elementos, un entero (32 bits
de almacenamiento de datos) llamado i y un caracter (8 bits de datos) llamado b.

2.1.3 Enlazadores
Los enlazadores son programas que enlazan varios modulos objeto y las bibliotecas
para formar un unico programa coherente. Los modulos objeto son la salida en codigo
maquina del ensamblador o del compilador y contienen codigo maquina ejecutable
y datos junto a informacion que permite al enlazador combinar los modulos para
formar un programa. Por ejemplo, un modulo puede contener todas las funciones
de base de datos de un programa, y otro las funciones de manejo de los argumentos
de la l nea de comandos. Los enlazadores arreglan las referencias entre esto modulos
objeto, donde una rutina o estructura de datos referenciados por un modulo esta
realmente en otro. El nucleo de Linux es un programa unico y grande, enlazado a
partir de sus numerosos modulos objeto constituyentes.

2.2 >Que es un sistema operativo?
Sin el software la computadora es solo una monta~a de componentes electronicos
n
que disipa calor. Si el hardware es el corazon de una computadora, el software es su
alma. Un sistema operativo es una coleccion de programas del sistema que permiten
al usuario ejecutar aplicaciones. El sistema operativo hace abstraccion del hardware
del sistema y presenta a los usuarios del sistema y a sus aplicaciones una maquina
virtual. En un sentido muy autentico, el software da el caracter del sistema. La mayor
parte de los PCs pueden ejecutar uno o varios sistemas operativos y cada uno puede
tener una apariencia y comportamiento muy diferentes. Linux esta hecho de varias
piezas funcionales diferentes que, combinadas, forman el sistema operativo. Una
parte obvia del Linux es el nucleo en s pero incluso este ser a inutil sin bibliotecas
o interpretes de comandos.
Para empezar a entender que es un sistema operativo, considere lo que ocurre cuando
teclea el comando aparentemente simple:

$ ls
Mail c images perl
docs tcl
$

El $ es un inductor puesto por el shell (en este caso bash). Esto signi ca que
esta esperando que usted, el usuario, teclee algun comando. Escribir ls hace que el
controlador del teclado reconozca que teclas han sido pulsadas. El controlador de
teclado las pasa al shell que procesa el comando, buscando un ejecutable del mismo
nombre. Lo encuentra en /bin/ls. Los servicios del nucleo son usados para cargar la
imagen ejecutable de ls en memoria y empezar a ejecutarla. Esta realiza llamadas al
subsistema de cheros del kernel para ver que cheros estan disponibles. El sistema de
cheros puede hacer uso de la informacion retenida en la cache, o usar el controlador
de la unidad de disco para leer esta informacion desde disco. Puede incluso hacer
que un controlador de red intercambie informacion con una maquina remota a la

que tiene acceso (los sistemas de cheros pueden ser montados remotamente con el
Networked File System o NFS (Sistema de Ficheros en Red)). Independientemente
de donde este la informacion, ls la escribe y el controlador de v deo la visualiza en la
pantalla.
Todo lo anterior parece bastante complicado, pero muestra que incluso los comandos
mas sencillos revelan que un sistema operativo esta de hecho cooperando con un
conjunto de funciones que juntas le dan a usted, el usuario, una vision coherente del
sistema.

2.2.1 Gestion de memoria
Si los recursos fuesen in nitos, como por ejemplo la memoria, muchas de las cosas
que hace un sistema operativo ser an redundantes. Uno de los trucos basicos de
un sistema operativo es la capacidad de hacer que una memoria f sica limitada se
comporte como mas memoria. Esta memoriaaparentemente amplia es conocida como
memoria virtual. La idea es que el software ejecutandose en el sistema sea inducido a
creer que esta ejecutandose en un monton de memoria. El sistema divide la memoria
en paginas facilmente gestionadas e intercambia estas paginas con el disco mientras
el sistema funciona. El software no lo nota gracias a otro truco, el multi-proceso.

2.2.2 Procesos
Se puede pensar en un proceso como en un programa en accion cada proceso es
una entidad separada que esta ejecutando un programa en particular. Si se ja en
los procesos de su sistema Linux, vera que son bastantes. Por ejemplo, escribir ps
muestra los procesos siguientes en mi sistema:
$ ps
PID TTY STAT TIME COMMAND
158 pRe 1 0:00 -bash
174 pRe 1 0:00 sh /usr/X11R6/bin/startx
175 pRe 1 0:00 xinit /usr/X11R6/lib/X11/xinit/xinitrc --
178 pRe 1 N 0:00 bowman
182 pRe 1 N 0:01 rxvt -geometry 120x35 -fg white -bg black
184 pRe 1 < 0:00 xclock -bg grey -geometry -1500-1500 -padding 0
185 pRe 1 < 0:00 xload -bg grey -geometry -0-0 -label xload
187 pp6 1 9:26 /bin/bash
203 ppc 2 0:00 /bin/bash
1797 v06 1 0:00 /bin/bash
3056 pp6 3 < 0:02 emacs intro/introduction.tex
3270 pp6 3 0:00 ps
$

Si mi equipo tuviera varias CPUs, cada proceso podr a (al menos teoricamente)
ejecutarse en una CPU distinta. Desafortunadamente, solo hay una, as que el sistema
operativo usa el truco de ejecutar cada proceso en orden durante un corto per odo
de tiempo. Este periodo de tiempo es conocido como fraccion de tiempo. Este truco

es conocido como multiproceso o plani cacion y enga~a a cada proceso, haciendole
n
creer que es el unico. Los procesos son protegidos el uno del otro para que si uno
se cuelga o funciona incorrectamente no afecte a los demas. El sistema operativo
consigue esto dando a cada proceso un espacio de direccionamiento unico, al que
solo el tiene acceso.

2.2.3 Controladores de unidad
Los controladores de unidad forman la mayor parte del nucleo de Linux. Como otras
partes del sistema operativo, operan en un entorno muy privilegiado y pueden causar
desastres si hacen las cosas mal. El controlador de la unidad supervisa la interaccion
entre el sistema operativo y la unidad de hardware que controla. Por ejemplo, el
sistema de cheros usa la interfaz general de unidades por bloques cuando escribe
datos a un disco IDE. El controlador se ocupa de los detalles y hace que las cosas
espec cas de la unidad ocurran. Los controladores de unidad son espec cos del chip
controlador que estan usando por eso necesita, por ejemplo, un controlador NCR810
SCSI cuando su sistema tiene una controladora NCR810 SCSI.

2.2.4 El Sistema de Ficheros
En Linux, al igual que en UnixTM , no se accede a los diferentes sistemas de cheros
que el sistema puede usar mediante indenti cadores de unidad (como el numero de
la unidad o su nombre), sino que son combinados en un unico arbol jerarquico que
representa el sistema de cheros como una entidad individual. Linux a~ade cada
n
sistema de cheros en su arbol unico cuando es montado en un directorio, como
por ejemplo /mnt/cdrom. Una de las caracter sticas mas importante de Linux es su
soporte para muchos sistemas de cheros diferentes. Esto lo hace muiy exible y
capaz de coexistir con otros sistemas operativos. El sistema de cheros mas popular
de Linux es el EXT2, y este es el soportado por la mayor parte de las distribuciones
de Linux.
Un sistema de cheros da al usuario una vision ordenada de los cheros y directorios
guardados en los discos duros del sistema, independientemente del tipo de su sistema
y de las caracter sticas de la unidad f sica subyacente. Linux soporta transparente-
mente muchos sistemas diferentes (por ejemplo MS-DOS y EXT2) y presenta todos los
cheros y sistemas de cheros montados como un unico arbol virtual. Por esto, los
usuarios y los procesos no necesitan generalmente saber en que tipo de sistema de
cheros esta algun chero, tan solo lo usan.
Los controladores de unidades por bloques diferencian entre los tipos de unidad f sica
(por ejemplo, IDE y SCSU) y, al menos en lo que concierne al sistema de cheros, las
unidades f sicas son solo colecciones lineales de bloques de datos. El tama~o de
n
bloque var a entre las unidades por ejemplo, 512 bytes es una medida comun en
los oppy disc", mientras que 1024 son mas corrientes en las unidades IDE, y, en
general, esto es ocultado a los usuarios del sistema. Un sistema de cheros EXT2
tiene el mismo aspecto, independientemente de la unidad que lo contenga.

2.3 Estructuras de datos del nucleo
El sistema operativo debe guardar mucha informacion referente al estado actual del
sistema. A medida que las cosas van pasando dentro del sistema, estas estructuras
de datos deben ser modi cadas para ajustarse a la realidad. Por ejemplo, un proceso
puede ser creado cuando el usuario entra en el sistema. El nucleo debe crear una
estructura de datos que represente al nuevo proceso y enlazarlo a las estructuras de
datos que representan a los otro procesos del sistema.
Estas estructuras se guardan sobre todo en la memoria f sica y son accesibles solo por
el nucleo y sus subsistemas. Las estructuras de datos contienen datos y punteros, es
decir la direccion de otras estructuras de datos o de rutinas. Tomadas en su conjunto,
las estructuras de datos usadas por el nucleo de Linux pueden parecer muy confusas.
Cada estructura de datos tiene su interes y a pesar de que algunas son usadas por
varios subsistemas del nucleo, son mas sencillas de lo que parecen a primera vista.
Comprender el nucleo de Linux se basa en la comprension de las estructuras de
datos y del uso que las distintas funciones del nucleo hacen de ellos. Este libro
basa su descripcion del nucleo de Linux en sus estructuras de datos. Habla de cada
subsistema del nucleo en terminos de sus algoritmos, sus metodos, y su uso de las
estructuras de datos del nucleo.

2.3.1 Lista Enlazadas
Linux usa cierto numero de tecnicas de ingenier a de software para enlazar entre s
las estructuras de datos. Si cada estructura describe una unica instancia u ocurrencia
de algo, por ejemplo un proceso o una unidad de red, el nucleo debe ser capaz de
encontrar el resto. En una lista enlazada un puntero raiz contiene la direccion de
la primera estructura de datos, o elemento de la lista, y cada estructura de datos
contiene un puntero al siguiente elemento de la lista. El puntero del ultimo elemento
contiene 0 o NULL para mostrar que es el nal de la lista. En una lista doblemente
enlazada, cada elemento contiene a la vez un puntero al siguiente elemento y al
anterior de la lista. El uso de listas doblemente enlazadas facilita la adicion o el
borrado de elementos en el medio de la lista, aunque necesita mas accesos a memoria.
Esta es una eleccion a la que se enfrenta a menudo un sistema operativo: accesos a
memoria frente a ciclos de CPU.

2.3.2 Tablas Hash
Las listas enlazadas son una manera util de unir estructuras de datos entre s , pero
recorrerlas puede ser ine ciente. Si estuviese buscando un elemento en particular,
podr a facilmente tener que buscar por toda la lista antes de encontrar el que necesita.
Linux usa otras tecnicas, llamadas tecnicas hash, para evitar estos problemas. Una
tabla hash es un array o vector de punteros. Un array es simplemente un conjunto
de cosas que vienen una detras de otra en la memoria. Se podr a decir que una
estanter a es un array de libros. Se accede a los arrays por un ndice este es el
desplazamiento (o set) dentro del array. Llevando la analog a de la estanter a de
biblioteca mas lejos, podr amos describir cada libro por su posicion en la estanter a
se puede pedir el quinto libro.
Una tabla hash es una array de punteros a estructuras de datos cuyo ndice deriva de

la informacion contenida en estas. Si tuviese estructuras de datos sobre la poblacion
de un pueblo, podr a usar la edad de cada persona como ndice. Para encontrar los
datos de una persona en particular, podr a usar su edad como ndice de la tabla
hash, para seguir a continuacion el puntero a la estructura de datos con los detalles
de la persona. Desafortunadamente, mucha gente puede tener la misma edad en un
pueblo, y el puntero de la tabla hash se puede transformar en un puntero a una lista
de estructuras con los datos de personas de la misma edad. Sin embargo, la busqueda
sigue siendo mas rapida en estas listas cortas que mirar por todas las estructuras de
datos en orden secuencial.
Una tabla hash acelera el acceso a estructuras accedidas con frecuencia Linux usa
frecuentemente las tablas hash para implementar caches. Los caches son informacion
util a la que necesita tener un acceso rapido, y son habitualmente una peque~a parte
n
de toda la informacion disponible. Los datos son almacenados en el cache porque
el nucleo accede a ellos con frecuencia. Un inconveniente de los caches es que son
mas dif ciles de usar y de mantener que las listas enlazadas o las tablas hash. Si
una estructura de datos puede ser encontrada en el cache (esto es conocido como un
acierto de cache), todo va bien. Si no, debe buscarse por todas las estructuras, y
si existe, debe ser a~adida al cache. Al a~adir nuevos datos al cache, otros datos
n n
del cache pueden ser descartados. Linux debe decidir cuales el peligro es que el
descartado sea el siguiente en ser necesitado.

2.3.3 Interfaces Abstractos
El nucleo de Linux hace a menudo abstraccion de sus interfaces. Una interfaz es una
coleccion de rutinas y estructuras de datos que operan de una forma determinada.
Por ejemplo, todos los controladores de unidades de red deben proporcionar ciertas
rutinas que operan sobre las estructuras de datos. De esta forma las partes genericas
del codigo pueden usar los servicios (interfaces) de las partes especi cas. La parte de
red, por ejemplo, es generica y la soporta el codigo espec co de la unidad conforme
a la interfaz estandar.
A menudo estos niveles inferiores se registran en los superiores durante el arranque.
Este registro normalmente consiste en a~adir una estructura de datos a una lista
n
enlazada. Por ejemplo cada sistema de cheros del nucleo se registra durante el
arranque, o, si usa modulos, cuando es usado por primera vez. Puede ver que sistemas
de cheros se han registrado viendo el chero /proc/filesystems. El registro de
estructuras de datos incluye a menudo punteros a funciones. Estos representan las
direcciones de las funciones que hacen tareas espec cas. Tomando de nuevo el
sistema de cheros como ejemplo, la estructura de datos que cada sistema de cheros
pasa al nucleo de Linux cuando se registra incluye la direccion de una rutina espec ca
que debe ser llamada cada vez que este sistema de cheros es montado.

Cap tulo 3
Gestion de memoria
El subsistema de gestion de memoria es una de las partes mas importantes
del sistema operativo. Ya desde los tiempos de los primeros ordenadores,
existio la necesidad de disponer de mas memoria de la que f sicamente
exist a en el sistema. Entre las varias estrategias desarrolladas para resol-
ver este problema, la de mas exito ha sido la memoria virtual. La memoria
virtual hace que que sistema parezca disponer de mas memoria de la que
realmente tiene compartiendola entre los distintos procesos conforme la
necesitan.
La memoria virtual hace mas cosas aparte de ampliar la memoria del ordenador. El
subsistema de gestion de memoria ofrece:
Espacio de direcciones grande El sistema operativo hace que el sistema parezca
tener una gran cantidad de memoria. La memoria virtual puede ser muchas
veces mayor que la memoria f sica del sistema,
Proteccion Cada proceso del sistema tiene su propio espacio de direcciones virtua-
les. Este espacio de direcciones esta completamente aislado de otros procesos,
de forma que un proceso no puede interferir con otro. Tambien, el mecanismo
de memoria virtual ofrecido por el hardware permite proteger determinadas
areas de memoria contra operaciones de escritura. Esto protege el codigo y los
datos de ser sobre-escritos por aplicaciones perversas.
Proyeccion de Memoria (Memory Mapping) La proyeccion de memoria se uti-
liza para asignar un chero sobre el espacio de direcciones de un proceso. En
la proyeccion de memoria, el contenido del chero se engancha" directamente
sobre el espacio de direcciones virtual del proceso.
Asignacion Equitativa de Memoria F sica El subsistema de gestion de memo-
ria permite que cada proceso del sistema se ejecute con una cantidad de memo-
ria justa de toda la memoria f sica disponible, de forma que todos los procesos
dispongan de los recursos que necesitan.
Memoria virtual compartida Aunque la memoria virtual permite que cada pro-
ceso tenga un espacio de memoria separado (virtual), hay veces que es necesario
que varios procesos compartan memoria. Por ejemplo pueden haber varios pro-
cesos del sistema ejecutando el interprete de ordenes bash. En lugar de tener
varias copias del bash, una en cada memoria virtual de cada proceso, es mejor

15

Process X Process Y

VPFN 7 VPFN 7

VPFN 6 Process X Process Y VPFN 6
Page Tables Page Tables

VPFN 5 VPFN 5

VPFN 4 PFN 4 VPFN 4

VPFN 3 PFN 3 VPFN 3

VPFN 2 PFN 2 VPFN 2

VPFN 1 PFN 1 VPFN 1

VPFN 0 PFN 0 VPFN 0

VIRTUAL MEMORY PHYSICAL MEMORY VIRTUAL MEMORY

Figura 3.1: Modelo abstracto de traduccion de memoria virtual a f sica.

solo tener una sola copia en memoria f sica y que todos los procesos que eje-
cuten bash la compartan. Las bibliotecas dinamicas son otro ejemplo t pico de
codigo ejecutable compartido por varios procesos.
Por otra parte, la memoria compartida se puede utilizar como un mecanismo
de comunicacion entre procesos (Inter Process Communication IPC), donde
dos o mas procesos intercambian informacion v a memoria comun a todos ellos.
Linux ofrece el sistema de comunicacion entre procesos de memoria compartida
de Unix TM System V.

3.1 Modelo Abstracto de Memoria Virtual
Antes de considerar los metodos que Linux utiliza para implementar la memoria
virtual, es interesante estudiar un modelo abstracto que no este plagado de peque~os
n
detalles de implementacion.
Conforme el procesador va ejecutando un programa lee instrucciones de la memoria
y las decodi ca. Durante la decodi cacion de la instruccion puede necesitar cargar
o guardar el contenido de una posicion de memoria. El procesador ejecuta la ins-
truccion y pasa a la siguiente instruccion del programa. De esta forma el procesador
esta siempre accediendo a memoria tanto para leer instrucciones como para cargar o
guardar datos.
En un sistema con memoria virtual, todas estas direcciones son direcciones virtuales
y no direcciones f sicas. Estas direcciones virtuales son convertidas en direcciones
f sicas por el procesador utilizando para ello informacion guardada en un conjunto
de tablas mantenidas por el sistema operativo.
Para hacer la traduccion mas facil, tanto la memoria virtual como la f sica estan
divididas en trozos de un tama~o manejable llamados paginas. Estas paginas son
n
todas del mismo tama~o, en principio no necesitar an serlo pero de no serlo la admi-
n
nistracion del sistema se complicar a much simo. Linux en un sistema Alpha AXP
utiliza paginas de 8 Kbytes, y en un sistema Intel x86 utiliza paginas de 4 Kbytes.

Cada una de estas paginas tiene asociado un unico numero el numero de marco de
pagina (PFN). En este modelo de paginacion, una direccion virtual esta compuesta
de dos partes: un desplazamiento y un numero de pagina virtual. Si el tama~o den
pagina es de 4Kbytes, los bits 11:0 de la direccion de memoria virtual contienen el
desplazamiento y los restantes bits desde el bit 12 son el numero de marco de pagina
virtual. Cada vez que el procesador encuentra una direccion virtual ha de extraer el
desplazamiento y el numero de marco de pagina. El procesador tiene que traducir
el numero de marco de la pagina virtual a la f sica y luego acceder a la posicion
correcta dentro de la pagina f sica. Para hacer todo esto, el procesador utiliza la
tabla de paginas.
En la Figura 3.1 se muestra el espacio de direcciones virtuales de dos procesos,
proceso X y proceso Y, cada uno con su propia tabla de paginas. Estas tablas de
paginas asocian las paginas de memoria virtual de cada proceso sobre paginas f sicas.
Se puede ver que el numero 0 de marco de pagina virtual del proceso X se asocia al
numero de marco de pagina f sico 1 y que el numero de marco de pagina virtual 1
de proceso Y esta asociado en el numero de marco de pagina f sico 4. La tabla de
paginas teorica contienen la siguiente informacion:

>Flag de Valido. Este indica si la estrada de la tabla de paginas es valida o no,
El numero de marco de pagina f sico que describe esta entrada,
Informacion de control de acceso. Describe como se puede utilizar la pagina
>Se puede leer? >Contiene codigo ejecutable?

A la tabla de paginas se accede utilizando el numero de marco de pagina virtual como
desplazamiento. El marco de pagina virtual 5 sera el sexto elemento de la tabla (el
primer elemento es el 0).
Para traducir una direccion virtual a una f sica, el procesador tiene que extraer de
la direccion virtual el numero de marco de pagina y el desplazamiento dentro de la
pagina virtual. Si hacemos que el tama~o de pagina sea potencia de 2, entonces esta
n
operacion se puede hacer facilmente mediante una mascara y un desplazamiento.
Volviendo a las Figuras 3.1 y suponiendo un tama~o de pagina de 0x2000 bytes (lo
n
que en decimal es 8192) y una direccion virtual de 0x2194 del proceso Y, entonces el
procesador descompondra esta direccion en un desplazamiento de 0x194 dentro del
numero de maco de pagina virtual 1.
El procesador utiliza el numero de marco de pagina virtual como ndice a la tabla de
paginas del proceso para obtener la entrada de la tabla de pagina correspondiente.
Si la entrada en la tabla de paginas de ese ndice es valida, el procesador coge el
numero de marco de pagina f sico de esta entrada. Si por el contrario la entrada
no es valida, entonces el proceso ha accedido a una area de memoria virtual que no
existe. En este caso, el procesador no puede resolver la direccion y debera pasar el
control al sistema operativo para que este solucione el problema.
La forma en la que el procesador informa al sistema operativo que un proceso con-
creto ha intentado realizar un acceso a una direccion virtual que no se ha podido
traducir, es espec co del procesador. Independientemente del mecanismo empleado
por el procesador, a esto se le conoce como fallo de pagina y el sistema operativo
es informado de la direccion virtual que lo ha producido y la razon por la que se
produjo.

Suponiendo que esta sea una entrada valida en la tabla de paginas, el procesador
toma el numero de marco de pagina f sico y lo multiplica por el tama~o pagina para
n
obtener la direccion base de la pagina f sica en memoria. Finalmente, el procesador
le suma el desplazamiento a la instruccion o dato que necesita, y esta es la direccion
f sica con la que accede a memoria.
Siguiendo en el ejemplo anterior, el numero de marco de pagina virtual 1 del proceso
Y esta asociado al numero de marco de pagina f sico 4 que comienza en la direccion
0x8000 (4 x 0x2000). Sumandole el desplazamiento de 0x194 nos da una direccion
f sica de 0x8194.
Asignando direcciones virtuales a direcciones f sicas de esta forma, la memoria virtual
se puede asociar sobre las paginas f sicas en cualquier orden. Por ejemplo, en la
Figura 3.1 el numero de marco de pagina 0 del proceso X esta asociado sobre el
numero de marco de pagina f sica 1, mientras que el numero de marco 7 esta asociado
con el marco f sico numero 0, a pesar de ser una direccion de memoria virtual mayor
que la del marco de pagina 0. Esto demuestra un interesante efecto lateral de la
memoria virtual: las paginas de memoria virtual no tienen que estar necesariamente
presentes en memoria f sica en un orden determinado.

3.1.1 Paginacion por Demanda
Puesto que hay mucha menos memoria f sica que memoria virtual, el sistema ope-
rativo ha de tener especial cuidado de no hacer un mal uso de la memoria f sica.
Una forma de conservar memoria f sica es cargar solo las paginas que estan siendo
utilizadas por un programa. Por ejemplo, un programa de bases de datos puede ser
ejecutado para realizar una consulta a una base de datos. En este caso no es nece-
sario cargar en memoria toda la base de datos, sino solo aquellos registros que que
son examinados. Si la consulta consiste en realizar una busqueda, entonces no tiene
sentido cargar el fragmento de programa que se ocupa de a~adir nuevos registros.
n
Esta tecnica de solo cargar paginas virtuales en memoria conforme son accedidas es
conocida como paginacion por demanda.
Cuando un proceso intenta acceder a una direccion virtual que no esta en esos mo-
mentos en memoria, el procesador no puede encontrar la entrada en la tabla de
paginas de la pagina virtual referenciada. Por ejemplo, en la Figura 3.1 no existe
una entrada en la tabla de paginas del proceso X para el marco numero 2, por lo
que si el proceso X intenta leer de una direccion perteneciente al marco de pagina
virtual 2 no podra traducirla a una direccion f sica. Es en este momento cuando el
procesador informa al sistema operativo que se a producido un fallo de pagina.
Si direccion virtual que ha fallado es invalida, signi ca que el proceso ha intentado
acceder a una direccion que no deber a. Puede ser que la aplicacion haya hecho
algo erroneo, por ejemplo escribir en una posicion aleatoria de memoria. En este
caso, el sistema operativo ha de terminarlo, protegiendo as a otros procesos de este
perverso" proceso.
Si la direccion virtual que ha producido el fallo era valida pero la pagina que referencia
no esta en memoria en ese momento, el sistema operativo tiene que traer la pagina
apropiada a memoria desde el disco. Los accesos a disco requieren mucho tiempo,
en terminos relativos, y por tanto el proceso tiene que esperar cierto tiempo hasta
que la pagina se haya le do. Si hay otros procesos que pueden ejecutarse entonces el
sistema operativo elegira alguno de estos para ejecutar. La pagina pedida se escribe

en una pagina f sica libre y se a~ade una entrada a la tabla de paginas del proceso
n
para esta pagina. El proceso en entonces puesto otra vez en ejecucion justo en la
instruccion donde se produjo el fallo de pagina. Esta vez s que se realizara con exito
el acceso a la direccion de memoria virtual, el procesador puede hacer la traduccion
de direccion virtual a f sica y el proceso continua normalmente.
Linux utiliza la paginacion por demanda para cargar imagenes ejecutables en la
memoria virtual de un proceso. Siempre que se ejecuta un proceso, se abre el chero
que la contiene y su contenido se asocia en la memoria virtual del proceso. Esto
se hace modi cando las estructuras de datos que describen el mapa de memoria del
proceso y se conoce como asociacion de memoria. Sin embargo, solo la primera parte
de la imagen se copia realmente en memoria f sica. El resto de la imagen se deja
en disco. Conforme se va ejecutando, se generan fallos de pagina y Linux utiliza el
mapa de memoria del proceso para determinar que partes de la imagen ha de traer
a memoria para ser ejecutadas.

3.1.2 Intercambio (swapping)
Si un proceso necesita cargar una pagina de memoria virtual a memoria f sica y
no hay ninguna pagina de memoria f sica libre, el sistema operativo tiene que crear
espacio para la nueva pagina eliminando alguna otra pagina de memoria f sica.
Si la pagina que se va a eliminar de memoria f sica proven a de una chero imagen o
de un chero de datos sobre el que no se ha realizado ninguna escritura, entonces la
pagina no necesita ser guardada. Tan solo se tiene que desechar y si el proceso que
la estaba utilizando la vuelve a necesitar simplemente se carga nuevamente desde el
chero imagen o de datos.
Por otra parte, si la pagina hab a sido modi cada, el sistema operativo debe pre-
servar su contenido para que pueda volver a ser accedido. Este tipo de pagina se
conoce como pagina sucia (dirty page) y para poderla eliminar de memoria se ha de
guardar en un chero especial llamado chero de intercambio (swap le). El tiempo
de acceso al chero de intercambio es muy grande en relacion a la velocidad del pro-
cesador y la memoria f sica y el sistema operativo tiene que conjugar la necesidad de
escribir paginas al disco con la necesidad de retenerlas en memoria para ser usadas
posteriormente.
Si el algoritmo utilizado para decidir que paginas se descartan o se env an a disco (el
algoritmo de intercambio) no es e ciente, entonces se produce una situacion llamada
hiper-paginacion (thrashing). En este estado, las paginas son continuamente copiadas
a disco y luego le das, con lo que el sistema operativo esta demasiado ocupado para
hacer trabajo util. Si, por ejemplo, el numero de marco de pagina 1 de la Figura 3.1
se accede constantemente entonces no es un buen candidato para intercambiarlo a
disco. El conjunto de paginas que en el instante actual esta siendo utilizado por
un proceso se llama Paginas activas (working set). Un algoritmo de intercambio
e ciente ha de asegurarse de tener en memoria f sica las paginas activas de todos los
procesos.
Linux utiliza la tecnica de paginacion por antiguedad (LRU Last Redently Used) para
escoger de forma equitativa y justa las paginas a ser intercambiadas o descartadas
del sistema. Este esquema implica que cada pagina del sistema ha de tener una
antiguedad que ha de actualizarse conforme la pagina es accedida. Cuanto mas se
accede a una pagina mas joven es por el contrario cuanto menos se utiliza mas vieja

Cómo funciona el núcleo de Linux

Cómo funciona el núcleo de Linux

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (16)

Destacado

Destacado (7)

Similar a Cómo funciona el núcleo de Linux

Similar a Cómo funciona el núcleo de Linux (20)

Más de 1 2d

Más de 1 2d (20)

Último

Último (20)

Cómo funciona el núcleo de Linux