Sistema Operativo Linux

UNIVERSIDAD DE ORIENTE
NÚCLEO DE MONAGAS
COORDINACIÓN DE POSTGRADO
MAESTRÍA EN INFORMÁTICA GERENCIAL
MATURÍN / MONAGAS / VENEZUELA
SISTEMA OPERATIVO LINUX
FACILITADOR: MAESTRANTES:
PROF. GERARDO GUACARÁN ZURITA ENRIQUE MARTÍNEZ
PETHAIDIS GAITÁN
WILMEN RONDÓN
SEMINARIO:
SISTEMAS OPERATIVOS MODERNOS
MATURÍN, FEBRERO 2019

ii
ÍNDICE GENERAL
ÍNDICE DE FIGURAS .......................................................................................................vi
ÍNDICE DE TABLAS ........................................................................................................vii
INTRODUCIÓN...................................................................................................................1
PARTE 1. ESTRUCTURA DEL HARDWARE................................................................2
CAPÍTULO 1.- DIAGRAMA DE BLOQUES DE LA ESTRUCTURA DE
HARDWARE DE UNA COMPUADORA REAL, SUSCEPTIBLE DE SOPORTAR
LA IMPLANTACIÓN DEL SISTEMA OPERATIVO LINUX......................................3
1.1 Diagrama de Bloques de la Estructura del Hardware..................................................4
1.2 Descripción del Bloque Procesador.............................................................................4
1.3 Descripción del Bloque de memoria y jerarquía .........................................................6
PARTE 2. ESTRUCTURA DEL SISTEMA OPERATIVO LINUX...............................8
CAPÍTULO II.- SISTEMA OPERATIVO LINUX ..........................................................8
2.1 Objetivo de Diseño ......................................................................................................8
2.2 Evolución Histórica del Sistema Operativo.................................................................8
2.2.1 Sistema Operativo Unix.......................................................................................8
2.2.2 Sistema Operativo Linux ...................................................................................10
2.3 Características del Sistema Operativo Linux.............................................................11
2.4 Diagrama de bloque del Sistema operativo LINUX..................................................12
2.5 Descripción de Cada Bloque......................................................................................14
CAPÍTULO 3.- CONCEPTUALIZACIÓN DE PROCESOS Y/O HILOS ..................15
3.1 Conceptos de Procesos y/o hilos...............................................................................15
3.1.1 Procesos .............................................................................................................15
3.1.2 Hilos...................................................................................................................17
3.2 Diagrama de estado de Procesos y/o hilos................................................................20
3.2.1 Estados de un proceso........................................................................................20
3.2.2 Procesos e hilos..................................................................................................21

iii
CAPÍTULO 4.- PLANIFICACIÓN DE PROCESOS.....................................................22
4.1 Sincronización de procesos.......................................................................................22
4.2 Planificación de sistemas en ambiente Multiprogramación .....................................28
4.3 Planificación de sistemas en ambiente Multiprocesamiento ....................................32
4.4 Estrategia real de Planificación de Procesos de LINUX ..........................................35
CAPÍTULO 5.- Gestión de memoria principal................................................................41
5.1 Memoria Física y memoria virtual............................................................................41
5.1.1 Memoria Física...................................................................................................41
5.1.2 Memoria Virtual.................................................................................................43
5.2 Jerarquía de memoria................................................................................................44
5.3 Partición, Segmentación, Paginación.........................................................................47
5.3.1 Particionamiento de la memoria.........................................................................48
5.3.2 Segmentación.....................................................................................................49
5.3.3 Paginación..........................................................................................................50
CAPÍTULO 6.- Gestión de almacenamiento en LINUX...............................................52
6.1 Planificación y gestión de dispositivos de almacenamiento secundario (Discos).....52
6.2 Sistema de Archivos VFS.........................................................................................56
6.3 Sistemas de archivos manejados por LINUX (NFS, ext2fs) .....................................59
6.3.1 NFS: El sistema de archivos de red ...................................................................59
6.3.2 El sistema de archivos Linux ext2fs...................................................................61
CAPÍTULO 7.- GESTIÓN DE E/S...................................................................................63
7.1 Manejo de Periféricos a través del Sistema de Archivos...........................................63
7.2 Administración de Archivos de Entrada, Salida........................................................65
7.2.1 Entrada Estándar, Salida Estándar y Error Estándar..........................................65
7.2.2 Redirección de Entrada/Salida ...........................................................................65
7.3 Comandos Simples. ...................................................................................................66
7.4 Los Tubos en Linux ...................................................................................................69

iv
CAPÍTULO 8.- CONSIDERACIONES SOBRE SEGURIDAD Y PROTECCIÓN
OFRECIDAS POR EL SISTEMA OPERATIVO LINUX.............................................70
8.1 Seguridad a través del Hardware ...............................................................................72
8.2 Seguridad a través del Software.................................................................................72
8.3 Descripción de algunos fallos de seguridad y protección en LINUX........................73
8.4 Comparación de algunos fallos de seguridad y protección con GNU/LINUX y otros
Sistemas Operativos.........................................................................................................75
CAPÍTULO 9.- DISCUSIÓN SOBRE LAS TENDENCIAS..........................................76
9.1 Tendencias ―free‖ u ―Open‖ de LINUX....................................................................76
9.2 Base instalada del Sistema Operativo LINUX ..........................................................78
9.3 Windows vs Mac vs Linux ........................................................................................79
9.3.1 Mac OS ..............................................................................................................79
9.3.2 Windows ............................................................................................................81
9.3.3 Linux ..................................................................................................................83
PARTE 3. DISTRIBUCIONES DE LINUX ....................................................................85
CAPÍTULO 10.- DISTRIBUCIÓN CANAIMA ..............................................................85
10.1 Distribución Canaima ..............................................................................................85
10.1.1 Origen...............................................................................................................86
10.1.2 Ciclo de Desarrollo ..........................................................................................87
10.1.3 Lanzamientos de la Distribución CANAIMA..................................................87
10.1.4 Usos de la Distribución Canaima.....................................................................89
CAPÍTULO 11 DISTRIBUCIÓN DE LINUX MAS UTILIZADA ...............................90
11.1 Distribución Ubuntu ................................................................................................90
11.1.1 Descripción. .....................................................................................................90
11.1.2 Historia.............................................................................................................91
11.1.3 Características de Ubuntu ................................................................................92
11.1.4 Organización de paquetes. ...............................................................................94

v
11.1.5 Variantes ..........................................................................................................95
11.1.6 Diferencia entre Ubuntu Server y Escritorio....................................................96
CONCLUSIÓN...................................................................................................................99
REFERENCIAS BIBLIOGRÁFICAS ...........................................................................100

vi
ÍNDICE DE FIGURAS
Figura 1. Diagrama de Bloque de la Estructura del Hardware VIT .......................................4
Figura 2. Nivel de la Jerarquía de Memoria ...........................................................................6
Figura 3. Diagrama de Bloque del Sistema Operativo LINUX............................................12
Figura 4. Creación de procesos en Linux. (Tanenbaum, 2009, pág. 741)............................16
Figura 5. Pasos para ejecutar el comando ls que se escribe en el Shell................................17
Figura 6. Diagrama de transición entre los estados de un proceso.......................................21
Figura 7. Comunicación indirecta de procesos.....................................................................24
Figura 8. Ejemplo de utilización del sistema........................................................................29
Figura 9. Ejemplo de Multiprogramación ............................................................................30
Figura 10. Elementos claves de un sistema operativo para multiprogramación ..................31
Figura 11. Arquitectura procesamiento paralelo ..................................................................34
Figura 12. Tomada de Stalligs, 2005, pág. 476....................................................................38
Figura 13. Estructura de datos para le planificación en Linux por cada procesador............40
Figura 14. División de memoria en un montículo de compañeras. ......................................42
Figura 15. Jerarquía de memoria entre diversos medios de almacenamiento. .....................46
Figura 16. Ejemplo de particionamiento fijo de una memoria de 64 Mbytes. (Stalligs, 2005,
pág. 313)...............................................................................................................................48
Figura 17. Ejemplo de Segmentación...................................................................................50
Figura 18. Esquema del proceso de paginación, ilustrando el papel de la MMU...............52
Figura 19. El planificador de E/S basado en plazos de Linux..............................................54
Figura 20. Directorios y nodos-i UNIX................................................................................58
Figura 21. Ejemplos del montaje de sistemas de archivos remotos. Los directorios se
muestran como cuadros y los archivos como círculos. ........................................................61
Figura 22. Políticas de asignación de bloques ext2fs ...........................................................63
Figura 23. Esquema de Entrada, Salida y Error Estándar. ...................................................65
Figura 24. Tuberías en línea en LINUX...............................................................................69
Figura 25. Distribuciones más populares de LINUX ...........................................................79

vii
ÍNDICE DE TABLAS
Tabla 1. Características equipo VIT modelo 2220-03............................................................3
Tabla 2. Especificaciones del Procesador IntelCore i7. Ivy Bridge.......................................5
Tabla 3. Llamadas al sistema relacionadas con los procesos. ..............................................17
Tabla 4. Técnicas de sincronización usadas por el kernel Linux .........................................25
Tabla 5. Técnicas de gestión de memoria ............................................................................47
Tabla 6. Mejora de rendimiento del disco............................................................................56
Tabla 7. Lanzamientos CANAIMA GNU/LINUX ..............................................................87

1
INTRODUCIÓN
Un sistema de computadora es un dispositivo electrónico programable que puede
almacenar, recuperar, y procesar datos. Ejecuta un conjunto de instrucciones llamado
programas. El sistema operativo se encarga de los componentes de hardware de una
computadora, además asegura el inicio y la ejecución de otros programas y de los datos
almacenados en los dispositivos de almacenamiento.
El sistema operativo controla todo el trabajo de la computadora, sin él, la
computadora solo es un montón de circuitos electrónicos. Linux es un sistema operativo
multiusuario y multitarea, donde múltiples usuarios pueden ejecutar múltiples aplicaciones
en forma simultanea es una única computadora centralizada. Cuenta con herramientas muy
poderosas basadas en UNIX el padre de la mayoría de los sistemas operativos hoy en día.
La diferencia con los demás sistemas operativos radica en la filosofía de desarrollo y
distribución del producto de la colaboración de miles de personas en todo el mundo.

2
PARTE 1. ESTRUCTURA DEL HARDWARE
GNU/Linux tiene requisitos de Hardware poco exigentes. La computadora necesaria es una
386 o compatible. 1 MB de RAM es el mínimo estricto, aunque se requieren 2 MB para arrancar a
una velocidad aceptable, 4 MB para correr aplicaciones, u 8 MB si se va a usar la interfaz gráfica.
Si se requieren tareas intensivas (como procesamiento de gráficos, servidores, etc.), es aconsejable
tener 16 MB. Puede usarse cualquier dispositivo de vídeo, aunque si se va a trabajar en X (la
interfaz gráfica) obviamente se aconseja una SVGA de 1 MB.
Algunas distribuciones ocupan solo un diskette, principalmente para uso como Router o
Firewall. Para instalar los utilitarios básicos, se requieren de 15 a 25 MB en disco. Si se instalan
algunas aplicaciones, el espacio ocupado llega de 80 a 100 MB, y si se instala X de 150 a 200 MB.
A esto se le debe agregar el espacio para usuarios, y de 10 a 40 MB para espacio de swap. Todo esto
es teniendo en cuenta aplicaciones elementales; para extender el sistema se requerirá más espacio.
(GrULiC, 2011)
LINUX ha sido trasladado a la gran mayoría de las plataformas actuales desde computadoras
de mano hasta las maquinas más grandes del planeta (supercomputadoras). Así que, prácticamente
todos los procesadores basados en x86 (IA-32) utilizados en ordenadores personales son
compatibles, incluyendo todas las variedades de la serie «Pentium» de Intel, los procesadores AMD
y VIA (anteriormente Cyrix). Y por supuesto, procesadores como Athlon XP e Intel P4 Xeon
(Equipo Debian GNU/Linux, 2013). Esto ha sido posible gracias a que su núcleo ha sido codificado
en lenguaje de alto nivel.
Existen algunos fabricantes que entregan sus sistemas con alguna distribución de GNU/Linux
preinstalada, lo que garantiza una cierta tranquilidad puesto que puede estar seguro de que su
hardware está bien soportado por GNU/Linux. Es importante siempre comprobar que su hardware
está soportado por el núcleo Linux, ya sea si está adquiriendo un sistema con Linux preinstalado o
no.

3
CAPÍTULO 1.- DIAGRAMA DE BLOQUES DE LA ESTRUCTURA DE
HARDWARE DE UNA COMPUADORA REAL, SUSCEPTIBLE DE SOPORTAR
LA IMPLANTACIÓN DEL SISTEMA OPERATIVO LINUX
Para detallar los componentes de los bloques del procesador, la memoria y los
periféricos, se delimitó a la utilización de una computadora de escritorio marca VIT modelo
E2220-09, con las siguientes características reflejadas en la tabla 1:
Tabla 1. Características equipo VIT modelo 2220-03
CPU
Core i7-3770 / 3.4Ghz a 3.9Ghz -
8Mb de caché
TARJETA MADRE Intel H77
RAM DDR3 DE 8Gb (16gb máx)
DISCO DURO 1Tb / 7200RPM
VIDEO nVidia Gt630
AUDIO Realtek HD 7.1
TARJETA INALÁMBRICA Wifi 802.11 b / g / n
LECTOR ÓPTICO DVD-RW
ETHERNET Gigabit
MISCELÁNEO
 8 puertos USB 2.0
 4 puertos USB 3.0
 Sonido 7.0
 Combo PS / 2
Fuente: Adaptado del Blog personal de Sgr (2016).

4
1.1 Diagrama de Bloques de la Estructura del Hardware
En este se encuentran los bloques de cómo está compuesta, y la forma de su conexión
hacia sus otros dispositivos tanto como de su funcionamiento. En la Figura 1 se muestra el
diagrama de Bloques de la estructura de hardware seleccionado.
Figura 1. Diagrama de Bloque de la Estructura del Hardware VIT
1.2 Descripción del Bloque Procesador
El procesador Intel Core i7 es un microprocesador de dos, de cuatro o de seis núcleos.
Esto significa que se compone de dos, cuatro o seis unidades de procesamiento. Cada chip
tiene cuatro, ocho o doce hilos que el sistema operativo puede asignar para procesar.
Aunque Intel utiliza el proceso de fabricación de 32 nanómetros en la mayoría de los chips
Core i7, algunos de ellos utilizan el método de 45 nm en la fabricación de semiconductores
en su lugar, lo que resulta en componentes más grandes.
Cada microprocesador tiene una velocidad de procesamiento y una velocidad de
transferencia de datos. Para el procesador Intel Core i7, el rango de velocidad de
Dispositivos de Entrada
Teclado Ratón
CPU
Microprocesador
IntelCore i7
ROM
Memoria Caché
RAM
DDR3 DE 8Gb

5
procesamiento es de 1.6 a 3.46 GHz. Sin embargo, cada chip tiene la tecnología Turbo
Boost que puede aumentar el rendimiento operativo máximo. Por ejemplo, la velocidad de
procesamiento base de los Core i7-2820QM es 2.3GHz, pero Turbo Boost le permite
alcanzar una tasa máxima de 3.4 GHz., que es la velocidad con la que trabaja la
computadora de escritorio VIT, descrita anteriormente. En cuanto a la velocidad de
transferencia de datos, el rango es de 4.8 a 6.4 gigatransfers por segundo, lo que equivale a
4.8 hasta 6.4 mil millones de transferencias por segundo.
La mayoría de los CPU con Core i7 tienen un controlador integrado Intel HD
Graphics. A pesar de que su velocidad de operación es diferente de un chip a otro, Intel HD
Graphics proporciona características tales como InTru3D para la visualización
estereoscópica tridimensional, soporte de pantalla dual e inalámbricas e Intel Quick Sync
Video para compartir y editar video. Cada chip Core i7 es compatible con la memoria del
sistema informático basado en SDRAM DDR3 (por su sigla en inglés, Velocidad doble de
datos - Sincronización de memoria dinámica de acceso aleatorio) de 1.066, 1.333 y/o 1.600
MHz de tercera generación. (Josiah, 2016)
En cuanto a especificaciones exactas del procesador i7 – 3770, Ivy Bridge, como se
citó en (Marcano y Yendiz, 2015) se puede ver en la tabla 2:
Tabla 2. Especificaciones del Procesador IntelCore i7. Ivy Bridge
Velocidad
Cache L2
Cache L3
Socket
Microarquitectura
Núcleos
Gráficos Integrados
Frecuencia de Gráficos
Tecnología de Fabricación
Soporta 64 bits
TDP
Disipador
3.4GHz (3.9GHz Turbo)
4 x 256 KB
8MB
Socket 1155
Ivy Bridge
4 Núcleos
Intel HD Graphics 4000
650MHz
22 nm
SI
77 Watts
Incluido

6
En Ivy Bridge cada núcleo (core) posee una caché interna L2 de 256 kB.
Luego, los 4 núcleos comparten una gran caché L3, que es de de 8 MB en el Core i7.
1.3 Descripción del Bloque de memoria y jerarquía
A diferencia de la mayoría de los procesadores, que tienen dos cachés, el
microprocesador Intel Core i7 tiene tres memorias caché: un caché Nivel 1 (L1), Nivel 2
(L2) y Nivel 3 (L3). Estos son los pequeños bancos de memoria en los que los procesadores
se basan para un acceso más rápido a los datos de uso más frecuente de la computadora de
la memoria del sistema. Si el chip no registra en la memoria caché L1, va a la caché L2, y si
eso no funciona recurre a la memoria caché L3. En cuanto al consumo de potencia máxima,
varía mucho: desde los 18 W de los chips de doble núcleo para PC portátiles hasta los 130
W de los procesadores de seis núcleos de PC de escritorio. (Josiah, 2016)
Figura 2. Nivel de la Jerarquía de Memoria
La memoria caché con una nueva arquitectura de tres niveles: la caché L1 con 32 Kb.
de caché para instrucciones y otros 32 Kb para caché de datos; caché L2 por núcleo de
latencia muy baja con 256 Kb por núcleo para datos e instrucciones; y caché L3 compartida
por todos los núcleos y con diferentes configuraciones en Mb. según el tipo de procesador,
8 Mb en el caso de un Core i7 con cuatro núcleos, aunque con el tiempo se irá ampliando
esta memoria caché compartida.

7
La memoria Cache de nivel 3 (L3) es una memoria compartida por cada uno de los
núcleos del procesador, esto trae la ventaja de que se simplifica el diseño de la arquitectura
interna del procesador, pero hay que ser cuidadosos en la forma en al que cada uno de los
cores intenta acceder a la memoria para que no se produzcan conflictos en los accesos,
quizás con un switch interno que administre las peticiones. Esto por que siempre será mas
optimo que cada core tenga su propio cache y que acceda a el exclusivamente a que tener
un solo Gran cache en que dos, cuatro o mas núcleos intenten acceder a el provocando,
colas o latencias demasiado altas en los accesos, lo que provoca un contrasentido en la
razón de ser de la memoria Cache de un procesador, la cual es ahorrarse tiempos al tener un
cache externo o tratar de acceder a la memoria principal en tareas críticas.

8
PARTE 2. ESTRUCTURA DEL SISTEMA OPERATIVO LINUX
CAPÍTULO II.- SISTEMA OPERATIVO LINUX
2.1 Objetivo de Diseño
El objetivo de Linux y del software libre es darle al usuario el mejor soporte y por lo
tanto mejor software. Que exista "competencia" entre el software libre y el propietario no
significa que uno quiera destronar al otro. En fin, LINUX es un sistema operativo y al
mismo tiempo una filosofía; y su fin que la comunidad de usuarios de computadoras
crezcan en conocimiento y cooperativismo.
2.2 Evolución Histórica del Sistema Operativo
2.2.1 Sistema Operativo Unix
El sistema operativo UNIX tiene una historia muy interesando. Algunos de los
aspectos de su evolución son:
• Bell Telephone Laboratories (BTL), GE y MIT se unieron intentando crear un
sistema operativo que permita trabajar simultáneamente hasta mil usuarios. Ken
Thompson y Dennis Ritchie de BTL trabajaron en esto y crearon un sistema
operativo, llamado MULTICS, un acrónimo de MULTplexed Information and
Computer Servicie (Servicio de Información Multiplexada y Cálculo).
• BTL se retiró del proyecto durante el desarrollo del trabajo.
• En 1969-1970, Thompsom y Ritchie rescribieron el sistema operativo para jugar
un juego de guerra espacial con otra máquina pequeña.
• Este sistema operativo fue llamado UNiplexed Information and Computing
Service (UNICS), un juego de palabras del MULTICS original.
• El nombre UNICS luego fue transformado en UNIX.

9
• En 1972-1973, el sistema UNIX fue reescrito usando el lenguaje de
programación C.
• El sistema operativo UNIX e4s uno de los sistemas operativos más poderosos,
versátiles, y flexible en el mundo de hoy en día.
El sistema operativo UNIX corre en un rango de computadoras desde
microcomputadoras hasta mainframe. Algunas de las características son:
• Es conocido como un sistema operativo ‗abierto‘ dado que puede ser llevado e
instalado en cualquier clase de sistema de computadora y plataforma de
hardware.
• Normalmente, los sistemas operativos son escrito en lenguaje ensamblador. Sin
embargo, UNIX está escrito en un lenguaje de alto nivel y su código fuente está
disponible fácilmente. Esto es una ventaja para los programadores cuando
incorporan cambios para ajustarse a sus necesidades.
• Es un sistema multiusuario y multitarea. Multitarea significa que el sistema
operativo puede coordinar múltiples tareas o trabajos en forma simultánea.
Mientras un usuario está compilando un programa C, otro puede crear un
documento usando un editor, cada uno ignorando la presencia del otro.
• UNIX es uno de los sistemas operativos más poderosos existentes por el hecho
de poder compartir recursos en tiempo real.
• A pesar que UNIX está desarrollado para programadores, proporciona un
entorno tan flexible que también es usado en negocios, ciencia, educación e
industria.
• Los interruptores de telecomunicaciones y sistemas de transmisión son algunos
de los ejemplos del uso del sistema operativo UNIX.

10
2.2.2 Sistema Operativo Linux
Linux es un sistema operativo distribuido gratuitamente basado en el sistema
operativo UNIX. Fue desarrollado originalmente por Linus Torvalds, quien empezó a
trabajar en Linux en 1991 siendo estudiante de la universidad de Helsinki en Finlandia.
Luego, miles de programadores contribuyeron a su desarrollo y fue distribuido
gratuitamente en internet. Por los 1980s, los sistemas operativos eran básicamente
propietarios, lo que significaba que uno tenía que usar solo sistema operativo
proporcionado para una plataforma especifica.
El Proyecto GNU fue fundada por Richard Stallman. Stallman fue fundador de Fre
Sotfware Fundation (FSF), autor del GNU GPL (General Public License) y el desarrollador
original de algunos programas de software GNU.
Los principales Proyectos GNU incluyen lo siguiente:
• Desarrollar un sistema operativo compatible con UNIX.
• Soportar diferentes arquitecturas de hardware.
• Hacer que el sistema operativo estuviese disponible libre de costo para asegurar
que los usuarios pudrieran retribuir todo el sistema y cambiar o contribuir a
alguna parte de él.
Por 1990, la mayoría de piezas de software del sistema operativo basado en GNU se
habían escrito, excepto la más importante, el kemel. El kemel es el núcleo del sistema
operativo. Más tarde, el kemel gratuito basado en UNIX desarrollado por Linus Torvalds
fue combinado con el sistema GNU. Así nació un sistema operativo, el sistema GNU
basado en Linux.
Las etapas significativas en la evolución de Linux son:

11
• En 1991, Linus Torvals desarrollo Linux con soporte de desarrolladores a lo
largo del mundo y lo llamo Linux.
• Él lanzo la Versión 0.02 de Linux en 1991.
• En 1994, fue lanzada la Versión 1.0 de Linux.
• La versión 2.6 fue lanzada en Diciembre 2003.
Los siguientes son algunos de los hechos básicos acerca del sistema operativo Linux:
• Es desarrollado, escrito, distribuido, y respaldado bajo el GPL de GNU. Como
resultado, su código fuente puede ser distribuido gratuitamente y disponible para
el público general.
• Los sistemas Linux se usan para redes, desarrollo de software, soluciones de
alojamiento web, y como plataforma de usuario final.
• La mascota oficial, que Linus eligió para su sistema operativo, es el pingüino
Linux llamado Tux (Torvals Unix).
• Linux no es un derivado del código fuente de UNIX. Sin embargo, la interfaz de
Linux es intencionalmente como la de UNIX. Así, las lecciones aprendidas
acerca de UNIX, incluyendo información sobre seguridad son aplicadas tanto a
UNIX como a Linux.
• Proporciona un sólido entorno gráfico, paquetes fáciles de instalar, y
aplicaciones de alto nivel.
2.3 Características del Sistema Operativo Linux
• Estabilidad: Tiene protección de memoria entre procesos, de manera que uno
de ellos no puede colgar al siguiente.
• Multitarea: Varios programas o procesos ejecutándose al mismo tiempo.
• Multiplataforma: Se ejecuta en muchos tipos de CPU, no solo Intel.
• Manejo de la Memoria: La memoria se gestiona como un recurso unificado
para los programas de usuarios y para el cache de disco, de tal forma que toda la
memoria libre puede ser usada para cache y este puede a su vez ser reducido
cuando se ejecuten grandes programas.
• Interfaz Gráfica de Usuario: KDE, GNOME.

12
• Desarrollo de Software: KDevelop (Lenguaje C, C++, Java, PHP, Perl, Phyton
entre otros).
• Trabajo de redes: TCP/IP, Incluyendo FTP, telnet, NFS, Wireless, etc.
• Disponibilidad de Código Fuente: Todo el código fuente está disponible,
incluyendo en núcleo completo, todos los drivers, las herramientas de desarrollo
y todos los programas de usuario; además está disponible libremente.
2.4 Diagrama de bloque del Sistema operativo LINUX.
En la siguiente figura muestro un diagrama de bloques del kernel, mostrando varios
módulos y las relaciones entre ellos. En particular, se muestra el subsistema de archivos en
la parte izquierda y el subsistemas de control de procesos en la parte derecha, los dos
mayores componentes del Kernel.
Programa de Usuario
Librería
Nivel de Usuario
Nivel de Kernel
Interfaz de llamadas internas
Sistema de Archivos
Sistema de
control de
procesos
Comunicación
Inter-Procesos
Planificador
Administración de
memoria
Buffer Cache
carácter block
Drivers de dispositivo
Control de hardware
Figura 3. Diagrama de Bloque del Sistema Operativo LINUX

13
La figura 3, muestra tres niveles: usuario, Kernel y hardware. Las llamadas al sistema
y las librerías representan entre los programas de usuario y el Kernel. Las llamadas al
sistema son parecidas a las funciones en los programas en C y las librerías transforman
estas funciones a las primitivas necesarias para entrar en el sistema operativo. Los
programas en lenguaje ensamblador deben invocar a las llamadas al sistema directamente
sin las librerías de las llamadas al sistema.
Las llamadas interactúan con el subsistema de archivos y con el subsistema de control
de procesos. El subsistema de archivos controla los archivos, asigna espacio a los archivos,
administra el espacio libre, controla el acceso a los archivos, etc. Los procesos interactúan
con el subsistema de archivos mediante un especifico conjunto de llamadas al sistema.
El subsistema de archivos accede a los archivos de datos usando un mecanismo de
búffer que regula el flujo de datos entre el Kernel y los dispositivos de almacenamiento
secundario. El mecanismo de búffer interactúa con los controladores de dispositivos de E/S
de tipo de bloque para iniciar la transferencia de datos desde y hacia el Kernel.
El subsistema de procesos es el responsable de la sincronización de los procesos, la
comunicación entre procesos, administración de memoria principal y la planificación de
procesos. Tanto el subsistema de archivos y el subsistema de procesos interactúan cuando
se carga un archivo en memoria para su ejecución.
El módulo de administración de memoria controla la asignación de memoria. Si en
algún momento no hay suficiente memoria física para todos los procesos, el Kernel los
mueve entre la memoria principal y la secundaria.
El módulo de planificador o sheduler asigna la CPU a los procesos. Planifica los
procesos para ser ejecutados por turno hasta que voluntariamente liberen la CPU mientras
esperan un recurso o hasta que el Kernel los saca cuando su tiempo de ejecución supera el
tiempo cuantum.

14
Finalmente, el control de hardware es el responsable de las interrupciones y de las
comunicaciones con la máquina. Los dispositivos como los discos o terminales pueden
interrumpir a la CPU mientras un proceso se está ejecutando. Así, el Kernel debe
restablecer la ejecución del proceso interrumpido después de servir a la interrupción.
2.5 Descripción de Cada Bloque
Bloque de Arranque
• Consiste de un bloque de disco que contiene el código para iniciar ña
computadora.
• Ocupa el primer bloque de un sistema de archivo.
• Un sistema solo requiere de un bloque de arranque para iniciar el sistema. En el
resto de los sistemas de archivos, este permanece vació.
Superbloque
• Está a continuación del bloque de arranque en el sistema de archivos.
• Consiste de un bloque de disco, que contiene información acerca del sistema de
archivo.
• Contiene información acerca del número de bloques asignado para inodos y el
número de bloques que están actualmente libres.
Bloque Inodo
• Es el tercer grupo de bloque en un sistema de archivos.
• Contiene más de un bloque de disco para mantener información acerca de los
archivos en el sistema de archivos.
Bloque de Datos
• Almacena el contenido de archivo.
• Sigue a los bloques de disco asignados para inodos.
• Un sistema de archivos contiene cierto número de bloques de datos.

15
Los inodos mantienen información acerca del propietario del archivo, los bloques de
disco usados por los archivos, etc. Los archivos por otro lado, contienen los datos de los
archivos.
CAPÍTULO 3.- CONCEPTUALIZACIÓN DE PROCESOS Y/O HILOS
3.1 Conceptos de Procesos y/o hilos.
3.1.1 Procesos
Las entidades activas principales en un sistema Linux son los procesos. Éstos son
muy similares a los procesos secuenciales clásicos. Cada proceso ejecuta un solo programa,
y al principio tiene un solo hilo de control. En otras palabras, tiene un contador del
programa que lleva la cuenta de la siguiente instrucción a ejecutar. Linux permite que un
proceso cree hilos adicionales, una vez que empieza a ejecutarse. Linux es un sistema de
multiprogramación, por lo que puede haber varios procesos independientes en ejecución al
mismo tiempo. De hecho, cada usuario puede tener varios procesos activos a la vez, por lo
que en un sistema grande puede haber cientos, o incluso miles de procesos en ejecución. De
hecho, en la mayoría de las estaciones de trabajo de un solo usuario, incluso cuando el
usuario está ausente, hay docenas de procesos ejecutándose en segundo plano; a estos
procesos se les llama demonios. Estos procesos se inician mediante una secuencia de
comandos de shell cuando se inicia el sistema.
En Linux, los procesos se crean de una forma especialmente simple. La llamada al
sistema fork crea una copia exacta del proceso original. El proceso que va a realizar la
bifurcación es el proceso padre. Al nuevo proceso se le conoce como proceso hijo. El padre
y el hijo tienen cada uno sus propias imágenes de memoria privadas. Si el padre cambia
después una de sus variables, los cambios no son visibles para el hijo, y viceversa.

16
Los archivos abiertos se comparten entre el padre y el hijo. Es decir, si se abrió cierto
archivo en el padre antes de fork, seguirá abierto tanto en el padre como en el hijo de ahí en
adelante. Los cambios que realice cualquiera de los dos procesos serán visibles para el otro.
Este comportamiento es razonable, ya que estos cambios también son visibles para
cualquier proceso no relacionado que abra el archivo.
Figura 4. Creación de procesos en Linux. (Tanenbaum, 2009, pág. 741)
En Linux, los procesos se pueden comunicar entre sí mediante el uso de una forma de
paso de mensajes. Es posible crear un canal entre dos procesos donde un proceso puede
escribir un flujo de bytes para que el otro los lea. Estos canales se conocen como tuberías.
La sincronización es posible debido a que, cuando un proceso trata de leer de una
canalización vacía, se bloquea hasta que haya datos disponibles. Las tuberías en línea del
shell se implementan con símbolos de tubería. Cuando el shell ve una línea como:
sort <f | head
Crea dos procesos, sort y head, y establece una tubería de canalización entre ellos, de
tal forma que la salida estándar de sort se conecta con la entrada estándar de head. De esta
forma, todos los datos que escribe sort van directamente a head en vez de ir a un archivo. Si
la tubería se llena, el sistema deja de ejecutar sort hasta que head haya eliminado ciertos
datos de ella.

17
Tabla 3. Llamadas al sistema relacionadas con los procesos.
(Tanenbaum, 2009, pág. 743)
3.1.2 Hilos
Para comprender mejor las capacidades únicas que nos ofrece el modelo de Linux,
empezaremos con un análisis de algunas de las decisiones desafiantes presentes en los
sistemas multihilo.
Figura 5. Pasos para ejecutar el comando ls que se escribe en el Shell.
(Tanenbaum, 2009, pág. 749)

18
La cuestión principal al introducir hilos es mantener la semántica tradicional correcta
de UNIX. Primero consideremos a fork. Suponga que un proceso con varios hilos (del
kernel) realiza una llamada al sistema fork. ¿Se deben crear los otros hilos en el nuevo
proceso? Por el momento, vamos a responder esa pregunta en forma afirmativa. Suponga
que uno de los otros hilos se bloqueó al leer del teclado. ¿Se debe bloquear también el hilo
correspondiente en el nuevo proceso al leer del teclado? De ser así, ¿cuál hilo obtiene la
siguiente línea que se escriba? En caso contrario, ¿qué debe hacer ese hilo en el nuevo
proceso? El mismo problema se aplica a muchas otras cosas que pueden hacer los hilos.
En un proceso con un solo hilo no se produce este problema, ya que el único hilo no
se puede bloquear al llamar a fork. Ahora considere el caso en el que los otros hilos no se
crean en el proceso hijo. Suponga que uno de los hilos no creados contiene un mutex que el
único hilo en el nuevo proceso trata de adquirir después de la llamada a fork. El mutex
nunca se liberará y ese hilo único esperará para siempre. También existen muchos otros
problemas. No hay una solución simple. La E/S de archivos es otra área problemática.
Suponga que un hilo se bloquea al leer de un archivo y otro hilo cierra ese archivo o realiza
una operación lseek para cambiar el apuntador de archivo actual. ¿Qué ocurre después?
¿Quién lo sabe?
El manejo de señales es otra de las cuestiones espinosas. ¿Se deben dirigir las señales
a un hilo específico, o al proceso en general? Tal vez una señal SIGFPE (excepción de
punto flotante) debería ser atrapada por el hilo que la produjo. ¿Qué pasa si no la atrapa?
¿Se debe eliminar solo ese hilo, o todos los hilos? Ahora considere la señal SIGINT, que el
usuario genera mediante el teclado. ¿Qué hilo debe atrapar esa señal? ¿Deben compartir
todos los hilos un conjunto común de máscaras de señales? Por lo general, todas las
soluciones a éstos y otros problemas hacen que se descomponga algo en otra parte. Obtener
la semántica correcta de los hilos (sin mencionar el código) no carece de importancia.
Linux acepta los hilos del kernel de una manera interesante, que vale la pena analizar.
La implementación se basa en la idea de 4.4BSD, pero los hilos del kernel no se habilitaron

19
en esa distribución debido a que Berkeley se quedó sin dinero antes de poder reescribir la
biblioteca de C para resolver los problemas antes descritos. Históricamente, los procesos
eran contenedores de recursos y los hilos eran las unidades de ejecución. Un proceso
contenía uno o más hilos que compartían el espacio de direcciones, los archivos abiertos,
los manejadores de señales, las alarmas y todo lo demás. Todo era claro y simple, como se
describió antes.
En el 2000, Linux introdujo una nueva y poderosa llamada al sistema: clone, que
disolvió la distinción entre procesos e hilos, y posiblemente hasta invirtió la primacía de los
dos conceptos. Clone no está presente en ninguna otra versión de UNIX. Tradicionalmente,
cuando se creaba un hilo, el (los) hilo(s) original(es) compartía(n) todo con el nuevo,
excepto sus registros. En especial, los descriptores de los archivos abiertos, los manejadores
de señales, las alarmas y otras propiedades globales eran para cada proceso, no para cada
hilo. La llamada a clone hizo posible que cada uno de estos y otros aspectos fueran
específicos para cada proceso o cada hilo. La llamada se hace de la siguiente manera:
pid = clone(función, pila_ptr, banderas_compart, arg);
La llamada crea un hilo, ya sea en el proceso actual o en un nuevo proceso,
dependiendo de banderas_compart. Si el nuevo hilo está en el proceso actual, comparte el
espacio de direcciones con los hilos existentes, y cada escritura subsiguiente en cualquier
byte del espacio de direcciones que realice cualquier hilo estará visible para los demás hilos
en el proceso. Por otra parte, si el espacio de direcciones no es compartido, entonces el
nuevo hilo obtiene una copia exacta del espacio de direcciones, pero las subsiguientes
escrituras que realice el nuevo hilo no estarán visibles para los hilos anteriores. Esta
semántica es la misma que en la llamada a fork de POSIX. En ambos casos, el nuevo hilo
empieza su ejecución en función, cuya llamada se realiza con arg como su único parámetro.
Además, en ambos casos el nuevo hilo obtiene su propia pila privada, donde el apuntador
de la pila se inicializa con pila_ptr. El parámetro banderas_compart es un mapa de bits que
permite un detalle más fino de compartición que los sistemas UNIX tradicionales. Cada uno

20
de los bits se puede establecer en forma independiente a los demás, y cada uno de ellos
determina si el nuevo hilo va a copiar cierta estructura de datos, o si la va a compartir con el
hilo que hizo la llamada.
El bit CLONE_VM determina si se va a compartir o a copiar la memoria virtual (es
decir, el espacio de direcciones) con los hilos anteriores. Si está activado, el nuevo hilo pasa
a estar con los hilos existentes, por lo que la llamada a clone crea en efecto un nuevo hilo
en un proceso existente. Si el bit está desactivado, el nuevo hilo obtiene su propio espacio
de direcciones privado. Esto significa que el efecto de sus instrucciones STORE no estará
visible para los hilos existentes. Este comportamiento es similar a fork, excepto como se
indica a continuación. La creación de un espacio de direcciones es en efecto la definición
de un nuevo proceso. (Tanenbaum, 2009)
3.2 Diagrama de estado de Procesos y/o hilos
3.2.1 Estados de un proceso
Un proceso, a lo largo de su vida, alterna entre diferentes estados de ejecución:
• Nuevo: Se solicitó al sistema operativo la creación de un proceso, y sus recursos
y estructuras están siendo creadas.
• Listo: Está listo para iniciar o continuar su ejecución pero el sistema no le ha
asignado un procesador.
• En ejecución: El proceso está siendo ejecutado en este momento. Sus
instrucciones están siendo procesadas en algún procesador.
• Bloqueado: En espera de algún evento para poder continuar su ejecución (aun si
hubiera un procesador disponible, no podría avanzar).
• Zombie: El proceso ha finalizado su ejecución, pero el sistema operativo debe
realizar ciertas operaciones de limpieza para poder eliminarlo de la lista.

21
• Terminado: El proceso terminó de ejecutarse; sus estructuras están a la espera
de ser limpiadas por el sistema operativo.
Figura 6. Diagrama de transición entre los estados de un proceso.
(Wolf, Ruiz, Bergero, & Meza, 2015, pág. 70)
3.2.2 Procesos e hilos
• Estado del proceso El estado actual del proceso.
• Contador de programa Cuál es la siguiente instrucción a ser ejecutada por el
proceso.
• Registros del CPU La información específica del estado del CPU mientras el
proceso está en ejecución (debe ser respaldada y restaurada cuando se registra
un cambio de estado).
• Información de planificación (scheduling) La prioridad del proceso, la cola en
que está agendado, y demás información que puede ayudar al sistema operativo
a planificar los procesos.

22
• Información de administración de memoria La información de mapeo de
memoria (páginas o segmentos, dependiendo del sistema operativo), incluyendo
la pila (stack) de llamadas.
• Información de contabilidad Información de la utilización de recursos que ha
tenido este proceso —puede incluir el tiempo total empleado y otros (de usuario,
cuando el procesador va avanzando sobre las instrucciones del programa
propiamente, de sistema cuando el sistema operativo está atendiendo las
solicitudes del proceso), uso acumulado de memoria y dispositivos, etcétera.
CAPÍTULO 4.- PLANIFICACIÓN DE PROCESOS
El objetivo de la planificación de procesos es asignar procesos a ser ejecutados por el
procesador o procesadores a lo largo del tiempo, de forma que se cumplan los objetivos del
sistema tales como el tiempo de respuesta, el rendimiento y la eficiencia del procesador. En
muchos sistemas, esta actividad de planificación se divide en tres funciones independientes:
planificación a largo-, medio-, y corto-plazo. Los nombres sugieren las escalas de tiempo
relativas con que se ejecutan estas funciones.
4.1 Sincronización de procesos
La comunicación de un mensaje entre dos procesos implica cierto nivel de
sincronización entre los dos: el receptor no puede recibir un mensaje hasta que no lo haya
enviado otro proceso. En suma, tenemos que especificar qué le sucede a un proceso después
de haber realizado una primitiva send o receive. Considérese primero la primitiva send.
Cuando una primitiva send se ejecuta en un proceso, hay dos posibilidades: o el proceso
que envía se bloquea hasta que el mensaje se recibe o no se bloquea. De igual modo,
cuando un proceso realiza la primitiva receive, hay dos posibilidades:

23
1. Si el mensaje fue enviado previamente, el mensaje será recibido y la ejecución
continúa.
2. Si no hay mensajes esperando, entonces: (a) el proceso se bloquea hasta que el
mensaje llega o (b) el proceso continúa ejecutando, abandonando el intento de
recepción.
Así, ambos emisor y receptor pueden ser bloqueantes o no bloqueantes. Tres son las
combinaciones típicas, si bien un sistema en concreto puede normalmente implementar sólo
una o dos de las combinaciones:
• Envío bloqueante, recepción bloqueante. Ambos emisor y receptor se
bloquean hasta que el mensaje se entrega; a esto también se le conoce
normalmente como rendezvous.
• Envío no bloqueante, recepción bloqueante. Aunque el emisor puede
continuar, el receptor se bloqueará hasta que el mensaje solicitado llegue. Esta
es probablemente la combinación más útil.
• Envío no bloqueante, recepción no bloqueante. Ninguna de las partes tiene
que esperar.
•
Para muchas tareas de programación concurrente es más natural el send no
bloqueante. Por ejemplo, si se utiliza para realizar una operación de salida, como imprimir,
permite que el proceso solicitante emita la petición en forma de un mensaje y luego
continúe. Un peligro potencial del send no bloqueante es que un error puede provocar una
situación en la cual los procesos generan mensajes repetidamente.
Dado que no hay bloqueo que castigue al proceso, los mensajes podrían consumir
recursos del sistema, incluyendo tiempo de procesador y espacio de almacenamiento, en
detrimento de otros procesos y del sistema operativo. También, el envío no bloqueante
pone sobre el programador la carga de determinar si un mensaje ha sido recibido: los
procesos deben emplear mensajes de respuesta para reconocer la recepción de un mensaje.

24
Para la primitiva receive, la versión bloqueante parece ser la más natural para muchas
tareas de programación concurrente. Generalmente, un proceso que quiere un mensaje
necesita esperar la información antes de continuar. No obstante, si un mensaje se pierde, lo
cual puede suceder en un sistema distribuido, o si un proceso falla antes de enviar un
mensaje que se espera, el proceso receptor puede quedar bloqueado indefinidamente. Este
problema puede resolverse utilizando el receive no bloqueante. Sin embargo, el peligro de
este enfoque es que si un mensaje se envía después de que un proceso haya realizado el
correspondiente receive, el mensaje puede perderse. Otras posibles soluciones son permitir
que el proceso receptor compruebe si hay un mensaje en espera antes de realizar el receive
y permitirle al proceso especificar más de un origen en la primitiva receive. La segunda
solución es útil si un proceso espera mensajes de más de un posible origen y puede
continuar si llega cualquiera de esos mensajes.
Figura 7. Comunicación indirecta de procesos
(Stalligs, 2005) pag 238
La tabla 4, lista las técnicas de sincronización usadas por el kernel Linux. La columna
―Alcance‖ indica si la técnica se aplica a todas las CPUs del sistema o a una CPU en
particular (en el caso de sistemas multiprocesador). Debe recordarse que la palabra
―softirq‖ se usará como sinónimo de función diferible, a no ser que se aclare otra cosa.

25
Tabla 4. Técnicas de sincronización usadas por el kernel Linux
Operaciones Atómicas: Existen varias instrucciones de lenguaje ensamblador del
tipo leer-modificar-escribir; acceden a una posición de memoria dos veces, la primera para
leer el valor antiguo y la segunda para escribir el nuevo. Estas operaciones deben ser
ejecutadas en una única instrucción sin ser interrumpidas y evitando accesos a la mismo
posición de memoria por otras CPUs. Los procesadores 80 x 86 nos ofrecen las siguientes
alternativas:
• Instrucciones del lenguaje ensamblador que hacen cero o un acceso alineado a
memoria. Un dato está alineado en memoria cuando su dirección es un múltiplo
de su tamaño en bytes. Por ejemplo, la dirección de un entero alineado debe ser
múltiplo de dos (en 80x86, un dato del tipo int ocupa 16 bits). En términos
generales, un acceso a memoria no alineado es no atómico.
• Las instrucciones leer-modificar-escribir como inc o dec son atómicas si otro
procesador no toma el bus despues de la lectura o antes de la escritura. El robo
del bus de memoria nunca sucede en un sistema monoprocesador.
• Las instrucciones leer-modificar-escribir cuyo código de operación es precedido
por el byte lock (0xf0) son atómicas incluso en sistemas multiprocesador.
Cuando la unidad de control detecta ese prefijo, bloquea el bus de memoria
hasta que la instrucción termine.

26
El kernel Linux proveé un tipo especial atomic_t (un contador de 24 bits accesible
atómicamente) y algunas funciones especiales (ver la siguiente tabla) que actúan sobre
variables de este tipo y que están implementadas como instrucciones atómicas escritas en
ensamblador. En sistemas multiprocesador, estas instrucciones son precedidas por el byte
lock.
Barreras de memoria: Cuando se utilizan compiladores con funciones de
optimización, nunca debería darse por supuesto que las instrucciones serán ejecutadas en el
orden exacto en el que aparecen en el código fuente. Un compilador podría reordenar las
instrucciones ensamblador para optimizar el uso de los registros, o podrían reordenarse los
accesos a memoria en el caso de las CPUs superescalares. Sin embargo, a los efectos de la
sincronización, la reordenación debería evitarse. Sería un problema que una instrucción
ubicada despues de una primitiva de sincronización se ejecutada antes de la primitiva
misma.
Una barrera de memoria asegura que las operaciones colocadas antes de la primitiva
sean terminadas antes de comenzar las operaciones colocadas despues de la primitiva. En
procesadores 80x86 los siguientes tipos de de instrucciones son llamados serializadores ya
que actuan como barreras de memoria:
• Instrucciones que operan en puertos I/O
• Instrucciones precedidas por el byte lock
• Instrucciones que escriben en registros de control, registros de sistema o
registros de depuración (por ejemplo, cli y sti).
• Algunas instrucciones especiales (por ejemplo iret).
Linux usa seis primitivas mostradas en la siguiente tabla. Las barreras de memoria de
Lectura actúan sólo en instrucciones que leen de la memoria, mientras que las barreras de
memoria de Escritura actúan en aquellas instrucciones que escriben en memoria.

27
SpinLocks: Los spinlocks son tipos especiales de locks diseñados para trabajar en
entornos multiprocesador. Si el KCP encuentra el lock abierto, lo toma y continua su
ejecución. Por el contrario, si el KCP encuentra el lock cerrado, se queda ejecutando un
bucle hasta que el lock es liberado. Aunque representan una ―busy wait‖, generalmente los
spinlocks son convenientes ya que muchos recursos del kernel son bloqueados por sólo una
fracción de milisegundo y consumiría más tiempo que un proceso esperando por uno de
esos recursos ceda la CPU y tenga que conseguirla más tarde. Por supuesto, los spinlocks
no sirven en un sistema monoprocesador, ya que el KCP que espera seguirá ejecutandose y
el KCP que mantiene el lock no tendrá oportunidad de liberarlo.
En Linux, un spinlock se representa por una estructura spinlock_t, que consiste en un
único campo lock. El valor 1 corresponde a un estado liberado, mientras que cualquier
valor igual o menor a cero indica un estado de cerrado. Las cinco funciones mostradas en la
siguiente tabla son utilizadas para inicializar, testear y setear los spinlocks. En sistemas
monoprocesador, ninguna de estas funciones hace algo, excepto spin_trylock (), que
siempre devuelve 1. Todas estas funciones se basan en operaciones atómicas; esto asegura
que el acceso concurrente a la estructura se hará correctamente.
Semáforos: Linux ofrece dos tipos de semáforos, aunque en este informe interesan
sólo los primeros: • Semáforos del kernel, usados por los KCP. • Semáforos ―System V
IPC‖, usados por los procesos en modo usuario. Cuando un KCP intenta obtener un recurso
ocupado protegido por un semáforo del kernel, el proceso correspondiente es suspendido.
El proceso volverá al estado RUNNABLE cuando el recurso sea liberado.
Un semáforo del kernel es un objeto de tipo struct semaphore, conteniendo los
campos mostrados en la siguiente lista: count Almacena un contador atomic_t. Si es mayor
que 0, entonces el recurso está libre. Si es igual a 0, el recurso está ocupado pero ningún
otro proceso está esperando. Finalmente si count es negativo, el recurso no está disponible
y al menos un proceso está esperando para usarlo. Wait Almacena la dirección de una cola
de espera (wait queue) que incluye a todos los procesos dormidos que están esperando por

28
el recurso. Si count es mayor o igual a 0, la cola está vacía. sleepers Guarda un flag que
indica si algún proceso está bloqueado en el semáforo.
Las macros init_MUTEX e init_MUTEX_LOCKED pueden ser utilizadas para
inicializar un semaforo para acceso exclusivo: setean el campo count a 1(recurso libre) y 0
(recurso no disponible con acceso exclusivo cedido al proceso que inicializa el semaforo)
respectivamente. Un semáforo podría se inicializado con cualquier valor positivo en count
para permitir el acceso concurrente de más de un proceso al recurso. Cuando un proceso
desea liberar un semáforo, invoca la función up( ). Por el contrario, cuando un proceso
desea acceder a un recurso protegido, invoca a la función down( ). Sólo manejadores de
excepciones y algunas rutinas de servicio de llamadas al sistema pueden usar la función
down( ).
Los manejadores de interrupciones o funciones diferibles no deben invocar down ( )
ya que esta función suspende al proceso cuando el semáforo está ocupado. Por esta razón,
linux ofrece la función down_trylock ( ) que puede ser utilizada sin problemas por las
funciones asincrónicas mencionadas anteriormente. Esta función es idéntica a down ( )
excepto que cuando el recurso está ocupado, la función retorna inmediatamente en lugar de
poner al proceso a dormir. Otra variación es down_interruptible ( ). Ésta es ampliamente
utilizada por drivers ya que permite que los procesos dormidos en un semáforo reciban una
señal para desbloquearse, en cuyo caso el driver podría abortar la operación I/O.
(Zabaljáuregui, 2011) pag.13
4.2 Planificación de sistemas en ambiente Multiprogramación
El procesador se encuentra frecuentemente ocioso, incluso con el secuenciamiento de
trabajos automático que proporciona un sistema operativo en lotes simple. El problema
consiste en que los dispositivos de E/S son lentos comparados con el procesador. La Figura
8, detalla un cálculo representativo de este hecho, que corresponde a un programa que
procesa un fichero con registros y. realiza de media 100 instrucciones máquina por registro.

29
En este ejemplo, el computador malgasta aproximadamente el 96% de su tiempo esperando
a que los dispositivos de E/S terminen de transferir datos a y desde el fichero. La Figura 9,
muestra esta situación, donde existe un único programa, lo que se denomina mono
programación. El procesador ejecuta durante cierto tiempo hasta que alcanza una
instrucción de E/S. Entonces debe esperar que la instrucción de E/S concluya antes de
continuar.
Figura 8. Ejemplo de utilización del sistema.
(Stalligs, 2005, pág.62)

30
Figura 9. Ejemplo de Multiprogramación
(Stalligs, 2005, 62)
Los sistemas operativos multiprogramados son bastante sofisticados, comparados con
los sistemas monoprogramados. Para tener varios trabajos listos para ejecutar, éstos deben
guardarse en memoria principal, requiriendo alguna forma de gestión de memoria.
Adicionalmente, si varios trabajos están listos para su ejecución, el procesador debe decidir
cuál de ellos ejecutar; esta decisión requiere un algoritmo para planificación.

31
Figura 10. Elementos claves de un sistema operativo para multiprogramación
(Stalligs, 2005)
A lo largo de su ejecución, un programa normalmente pasa por etapas con muy
distintas características: durante un ciclo fuertemente dedicado al cálculo numérico, el
sistema opera limitado por el CPU (CPU-bound), mientras que al leer o escribir resultados
a medios externos (incluso mediante spools) el límite es impuesto por los dispositivos, esto
es, opera limitado por entrada-salida (I-O bound). La programación multitareas o los
sistemas multiprogramados buscaban maximizar el tiempo de uso efectivo del procesador
ejecutando varios procesos al mismo tiempo. El hardware requerido cambió fuertemente. Si
bien se esperaba que cada usuario fuera responsable con el uso de recursos, resultó
necesario que apareciera la infraestructura de protección de recursos: un proceso no debe
sobreescribir el espacio de memoria de otro (ni el código, ni los datos), mucho menos el
espacio del monitor. Esta protección se encuentra en la Unidad de Manejo de Memoria

32
(MMU), presente en todas las computadoras de uso genérico desde los años noventa.
Ciertos dispositivos requieren bloqueo para ofrecer acceso exclusivo/único: cintas e
impresoras, por ejemplo, son de acceso estrictamente secuencial, y si dos usuarios
intentaran usarlas al mismo tiempo, el resultado para ambos se corrompería. Para estos
dispositivos, el sistema debe implementar otros spools y mecanismos de bloqueo. (Wolf,
Ruiz, Bergero, & Meza, 2015, pág. 21)
4.3 Planificación de sistemas en ambiente Multiprocesamiento
Tradicionalmente, el computador ha sido visto como una máquina secuencial. La
mayor parte de los lenguajes de programación requieren que el programador especifique
algoritmos como una secuencia de instrucciones. Un procesador ejecuta programas a través
de la ejecución de instrucciones máquina en secuencia y de una en una. Cada instrucción se
ejecuta como una secuencia de operaciones (ir a buscar la instrucción, ir a buscar los
operandos, realizar la operación, almacenar resultados).
Esta visión del computador nunca ha sido totalmente cierta. A nivel de micro-
operación, se generan múltiples señales de control al mismo tiempo. El pipeline de
instrucciones, al menos en lo relativo a la búsqueda y ejecución de operaciones, ha estado
presente durante mucho tiempo. Éstos son dos ejemplos de realización de funciones en
paralelo.
A medida que ha evolucionado la tecnología de los computadores y el coste del
hardware ha descendido, los diseñadores han visto cada vez más oportunidades para el
paralelismo, normalmente para mejorar el rendimiento y, en algunos casos, para mejorar la
fiabilidad. Examinamos los dos enfoques más populares para proporcionar paralelismo a
través de la réplica de procesadores: multiprocesamiento simétricos (SMP) y clusters.

33
Arquitectura Smp
Es útil ver donde encaja la arquitectura SMP dentro de las categorías de
procesamiento paralelo. La forma más común de categorizar estos sistemas es la taxonomía
de sistemas de procesamiento paralelo introducida por Flynn [FLYN72]. Flynn propone las
siguientes categorías de sistemas de computadores:
 Única instrucción, único flujo de datos – Single instruction single data
(SISD) stream. Un solo procesador ejecuta una única instrucción que opera
sobre datos almacenados en una sola memoria.
 Única instrucción, múltiples flujos de datos – Single instruction multiple
data (SIMD) stream. Una única instrucción de máquina controla la ejecución
simultánea de un número de elementos de proceso. Cada elemento de proceso
tiene una memoria de datos asociada, de forma que cada instrucción se ejecuta
en un conjunto de datos diferente a través de los diferentes procesadores. Los
procesadores vectoriales y matriciales entran dentro de esta categoría.
 Múltiples instrucciones, único flujo de datos – Multiple instruction single
data (MISD) stream. Se transmite una secuencia de datos a un conjunto de
procesadores, cada uno de los cuales ejecuta una secuencia de instrucciones
diferente. Esta estructura nunca se ha implementado.
 Múltiples instrucciones, múltiples flujos de datos – Multiple instruction
multiple data (MIMD) stream. Un conjunto de procesadores ejecuta
simultáneamente diferentes secuencias de instrucciones en diferentes conjuntos
de datos.

34
Figura 11. Arquitectura procesamiento paralelo
(Stalligs, 2005, pag.173)
Consideraciones De Diseño De Sistemas Operativos Multiprocesador
Un sistema operativo SMP gestiona los procesadores y otros recursos del
computador, de manera que el usuario puede ver al sistema de la misma forma que si fuera
un sistema uniprocesador multiprogramado. Un usuario puede desarrollar aplicaciones que
utilicen múltiples procesos o múltiples hilos dentro de procesos sin preocuparse de si estará
disponible un único procesador o múltiples procesadores. De esta forma, un sistema
operativo multiprocesador debe proporcionar toda la funcionalidad de un sistema
multiprogramado, además de características adicionales para adecuarse a múltiples
procesadores. Las principales claves de diseño incluyen las siguientes características:
• Procesos o hilos simultáneos concurrentes. Las rutinas del núcleo necesitan ser
reentrantes para permitir que varios procesadores ejecuten el mismo código del
núcleo simultáneamente. Debido a que múltiples procesadores pueden ejecutar
la misma o diferentes partes del código del núcleo, las tablas y la gestión de las
estructuras del núcleo deben ser gestionas apropiadamente para impedir
interbloqueos u operaciones inválidas.

35
• Planificación. La planificación se puede realizar por cualquier procesador, por lo
que se deben evitar los conflictos. Si se utiliza multihilo a nivel de núcleo, existe
la posibilidad de planificar múltiples hilos del mismo proceso simultáneamente
en múltiples procesadores.
• Sincronización. Con múltiples procesos activos, que pueden acceder a espacios
de direcciones compartidas o recursos compartidos de E/S, se debe tener
cuidado en proporcionar una sincronización eficaz. La sincronización es un
servicio que fuerza la exclusión mutua y el orden de los eventos. Un mecanismo
común de sincronización que se utiliza en los sistemas operativos
multiprocesador son los cerrojos.
• Gestión de memoria. La gestión de memoria en un multiprocesador debe tratar
con todos los aspectos encontrados en las máquinas uniprocesador, que se verán
en la Parte Tres. Además, el sistema operativo necesita explotar el paralelismo
hardware existente, como las memorias multipuerto, para lograr el mejor
rendimiento. Los mecanismos de paginación de los diferentes procesadores
deben estar coordinados para asegurar la consistencia cuando varios
procesadores comparten una página o segmento y para decidir sobre el
reemplazo de una página.
• Fiabilidad y tolerancia a fallos. El sistema operativo no se debe degradar en caso
de fallo de un procesador. El planificador y otras partes del sistema operativo
deben darse cuenta de la pérdida de un procesador y reestructurar las tablas de
gestión apropiadamente. (Stalligs, 2005) pag -175
•
4.4 Estrategia real de Planificación de Procesos de LINUX
La planificación de tiempo real es una de las áreas más activas de investigación en
informática. En un compendio de algoritmos de planificación de tiempo real, [RAMA94] se
observa que los distintos enfoques de la planificación dependen de (1) cuando el sistema
realiza análisis de planificabilidad; y si lo hace, de (2) si se realiza estática o
dinámicamente; y de (3) si el resultado del análisis produce un plan de planificación de

36
acuerdo al cual se desarrollarán las tareas en tiempo de ejecución. En base a estas
consideraciones los autores identifican las siguientes clases de algoritmos:
• Enfoques estáticos dirigidos por tabla. En éstos se realiza un análisis estático de
la factibilidad de la planificación. El resultado del análisis es una planificación
que determina cuando, en tiempo de ejecución, debe comenzar a ejecutarse cada
tarea.
• Enfoques estáticos expulsivos dirigidos por prioridad. También se realiza un
análisis estático, pero no se obtiene una planificación. En cambio, el análisis se
utiliza para asignar prioridades a las tareas, y así puede utilizarse un planificador
expulsivo tradicional basado en prioridades.
• Enfoques dinámicos basados en un plan. La factibilidad se determina en tiempo
de ejecución (dinámicamente) en vez de antes de comenzar la ejecución
(estáticamente). Una nueva tarea será aceptada como ejecutable sólo si es
posible satisfacer sus restricciones de tiempo. Uno de los resultados del análisis
de factibilidad es un plan que se usará para decidir cuándo poner en marcha la
tarea.
• Enfoques dinámicos de mejor esfuerzo. No se realiza análisis de factibilidad. El
sistema intenta cumplir todos los plazos y aborta la ejecución de cualquier
proceso cuyo plazo haya fallado.
La planificación estática dirigida por tabla es aplicable a tareas que son periódicas.
Los datos de entrada para el análisis son: tiempo periódico de llegada, tiempo de ejecución,
plazo periódico de finalización, y prioridad relativa de cada tarea. El planificador intenta
encontrar un plan que le permita cumplir todos los requisitos de todas las tareas periódicas.
Éste es un enfoque predecible pero no flexible, dado que un cambio en cualquiera de los
requisitos de las tareas requiere rehacer toda la planificación. El plazo más cercano
primero, y otras técnicas de plazos periódicos (expuestas posteriormente) son típicas de esta
categoría de algoritmos de planificación.

37
La planificación estática con expulsión dirigida por prioridad hace uso del mecanismo
de planificación expulsivo dirigido por prioridades común a la mayoría de los sistemas
multiprogramados que no son de tiempo real. En un sistema que no es de tiempo real,
pueden utilizarse en múltiples factores para determinar la prioridad. Por ejemplo, en un
sistema de tiempo compartido, la prioridad de un proceso puede cambiar dependiendo de
qué consume más, CPU o E/S. En un sistema de tiempo real, la asignación de prioridades
está relacionada con las restricciones de tiempo asociadas a cada tarea.
Un ejemplo de este enfoque es el algoritmo de tasa monótona (expuesto
posteriormente), que asigna prioridades estáticas a las tareas basándose en sus longitudes y
sus periodos.
Con la planificación dinámica basada en un plan, cuando llega una nueva tarea, pero
antes de que comience su ejecución, se intentará crear un plan que contenga las tareas
previamente planificadas así como la nueva. Si la tarea recién llegada puede ser planificada
de manera que se cumplan sus plazos sin que ninguna otra tarea planificada anteriormente
pierda un plazo, la nueva tarea será aceptada poniéndose en marcha el nuevo plan de
planificación.
La planificación dinámica de mejor esfuerzo es en enfoque utilizado en muchos
sistemas operativos de tiempo real disponible comercialmente hoy en día. Cuando llega una
tarea, el sistema le asigna una prioridad basada en las características de la misma. De forma
característica se utiliza algún tipo de planificación basada en plazos como la planificación
del plazo más cercano. Así, las tareas no son periódicas y por tanto no es posible realizar un
análisis estático de planificabilidad. Con este tipo de planificación, no sabremos si una
determinada restricción de tiempo será satisfecha hasta que venza su plazo o la tarea se
complete. Esta es la principal desventaja de esta forma de planificación. La ventaja es que
es fácil de implementar. (Stalligs, 2005)

38
Figura 12. Tomada de Stalligs, 2005, pág. 476
En Linux 2.4 y anteriores, Linux tiene capacidad para la planificación de tiempo real
así como un planificador para procesos no de tiempo real que hace uso del algoritmo de
planificación tradicional de UNIX descrito en la Sección 9.3. Linux 2.6 incluye
esencialmente la misma capacidad de planificación de tiempo real que las ediciones previas
y un planificador sustancialmente modificado para procesos no de tiempo real.
Examinemos estas dos áreas por turno.

39
Las tres clases de planificación en Linux son las siguientes:
• SCHED_FIFO. Hilos de tiempo real planificados FIFO.
• SCHED_RR. Hilos de tiempo real planificados con turno circular.
• SCHED_OTHER. Otros hilos no de tiempo real.
Dentro de cada clase, pueden utilizarse múltiples prioridades, siendo las prioridades
de las clases de tiempo real mayores que las prioridades para la clase SCHED_OTHER.
Los valores por omisión son los siguientes: la prioridad de las clases de tiempo real van del
0 al 99 inclusive, y para la clase SCHED_OTHER van del 100 al 139. Un número menor
significa mayor prioridad. Para los hilos FIFO, se aplican las siguientes reglas:
1. El sistema no interrumpirá un hilo FIFO en ejecución excepto en los siguientes
casos:
• Otro hilo FIFO de mayor prioridad pasa a estado listo.
• El hilo FIFO en ejecución pasa a estar bloqueado en espera por algún
evento, como E/S.
• El hilo FIFO en ejecución cede voluntariamente el procesador realizando
una llamada a la primitiva sched_yield.
2. Cuando un hilo FIFO en ejecución es interrumpido, se le sitúa en una cola
asociada con su prioridad.
3. Cuando un hilo FIFO pasa a estar listo y ese hilo es de mayor prioridad que el
hilo actualmente en ejecución, entonces el hilo actualmente en ejecución es
expulsado y el hilo FIFO listo de mayor prioridad es ejecutado. Si hay más de
un hilo que tiene esa mayor prioridad, se escogerá el hilo que lleve más tiempo
esperando.

40
El planificador de Linux 2.4 para la clase SCHED_OTHER no escalaba bien con un
número creciente de procesadores y un número creciente de procesos. Para atacar este
problema, Linux 2.6 usa un planificador completamente nuevo conocido como el
planificador O(1). El planificador ha sido diseñado para que el tiempo de seleccionar el
proceso adecuado y asignarlo a un procesador sea constante, sin importar la carga del
sistema y el número de procesadores.
El núcleo mantiene dos estructuras de datos para la planificación por cada procesador
del sistema, con la siguiente forma:
Figura 13. Estructura de datos para le planificación en Linux por cada
procesador.
Relación con las tareas de tiempo real Las tareas de tiempo-real se manipulan de
manera distinta que las tareas no de tiempo real en las colas de prioridad. Se aplican las
siguientes consideraciones:

41
1. Todas las tareas de tiempo real tienen solamente prioridad estática; no se
realizaron cálculos de prioridad dinámica.
2. Las tareas SCHED_FIFO no tienen asignadas rodajas de tiempo. Estas tareas se
planifican siguiendo la disciplina FIFO. Si una de estas tareas se bloquea,
cuando se desbloquee volverá a la misma cola de prioridad en la lista de colas
activas.
3. Aunque las tareas SCHED_RR tienen asignadas rodajas de tiempo, tampoco se
les traslada nunca a la lista de colas vencidas. Cuando una de estas tareas
consume toda su rodaja de tiempo, se le devuelve a su cola de prioridad con el
mismo valor de rodaja de tiempo. Los valores de rodaja de tiempo nunca se
cambian.
El efecto de estas reglas es que el cambio entre la lista de colas activas y la lista de
colas vencidas sólo sucede cuando no hay tareas de tiempo real listas esperando para
ejecutar. (Stalligs, 2005, pág. 480)
CAPÍTULO 5.- Gestión de memoria principal
5.1 Memoria Física y memoria virtual
5.1.1 Memoria Física
El administrador primario de memoria física del núcleo de Linux es el asignador de
páginas, el cual se encarga de asignar y liberar todas las páginas físicas, además de que
puede asignar intervalos de páginas contiguas físicamente si se le solicitan. El asignador
usa un algoritmo de montículo de compañeras para seguir el rastro a las páginas
disponibles. Un asignador de montículo de compañeras aparea unidades adyacentes de
memoria asignable; de ahí su nombre. Cada región de memoria asignable tiene una
compañera adyacente, y siempre que dos regiones compañeras asignadas quedan libres, se

42
combinan para formar una región más grande. Esa región mayor también tiene una
compañera con la que puede combinarse para formar una región todavía mayor. Como
alternativa, si una solicitud de memoria pequeña no puede satisfacerse asignando una
región libre pequeña existente, una región libre mayor se subdividirá en dos compañeras
para satisfacer la solicitud. Se usan listas enlazadas individuales para registrar las regiones
de memoria libre de cada tamaño permitido; bajo Linux, el tamaño más pequeño que se
puede asignar con este mecanismo es una sola página física.
Figura 14. División de memoria en un montículo de compañeras.
(Silberschatz y Galvin, 1999, pág. 718)
En última instancia, todas las asignaciones de memoria en el núcleo de Linux ocurren
estáticamente, mediante controladores que reservan un área contigua de la memoria durante
el arranque del sistema, o bien dinámicamente, por medio del asignador de páginas. No
obstante, las funciones del núcleo no tienen que usar el asignador básico para reservar
memoria; existen varios subsistemas de gestión de memoria especializados que usan el
asignador de páginas subyacente para administrar su propia reserva de memoria. Los
subsistemas de memoria más importantes son el de memoria virtual (que se describirá en la
sección 22.6.2), el asignador de longitud variable kmalloc y los dos cachés de datos
persistentes del núcleo (el caché de buffers y el caché de páginas). (Silberschatz y Galvin,
1999)

43
5.1.2 Memoria Virtual
El sistema de memoria virtual de Linux se encarga de mantener el espacio de
direcciones visible para cada proceso. Este sistema crea páginas de memoria virtual por
solicitud y gestiona la carga de dichas páginas de disco o su intercambio a disco si es
necesario. Bajo Linux, el administrador de memoria virtual mantiene dos vistas distintas del
espacio de direcciones de un proceso: como un conjunto de regiones individuales y como
un conjunto de páginas.
La primera vista de un espacio de direcciones es la lógica, que describe las
instrucciones que el sistema de memoria virtual ha recibido acerca de la organización del
espacio de direcciones. En esta vista, el espacio de direcciones consiste en un conjunto de
regiones que no se traslapan, cada una de las cuales representa un subconjunto continuo,
alineado por páginas, del espacio de direcciones. Cada región se describe internamente con
una sola estructura vm_area_struct, que define las propiedades de la región, incluidos los
permisos de lectura, escritura y ejecución del proceso en la región, e información acerca de
cualesquier archivos asociados a la región. Las regiones de cada espacio de direcciones se
enlazan en un árbol binario balanceado para poder realizar búsquedas rápidas en la región
correspondiente a cualquier dirección virtual.
El núcleo también mantiene una segunda vista (física) de cada espacio de direcciones.
Esta vista se almacena en las tablas de páginas en hardware para el proceso. Las entradas de
la tabla de páginas determinan la ubicación actual exacta de cada página de memoria
virtual, esté en disco o en la memoria física. La vista física se maneja con un conjunto de
rutinas que se invocan desde los manejadores de interrupciones de software del núcleo cada
vez que un proceso trata de acceder a una página que no está actualmente presente en las
tablas de páginas. Cada vm_area_struct de la descripción de un espacio de direcciones
contiene un campo que apunta a una tabla de funciones que implementan las tareas de
gestión de páginas clave para cualquier región de memoria virtual dada. Todas las
solicitudes para leer o escribir una página no disponible tarde o temprano se despachan al

44
manejador apropiado de la tabla de vm_area_struct, para que las rutinas de gestión de
memoria centrales no tengan que conocer los detalles de cómo administrar cada posible
tipo de región de memoria. (Silberschatz y Galvin, 1999)
5.2 Jerarquía de memoria
Las restricciones de diseño en la memoria de un computador se pueden resumir en
tres preguntas:
• ¿Cuál es su capacidad?
• ¿Cuál es su velocidad?
• ¿Cuál es su coste?
•
La pregunta sobre cuánta debe ser su capacidad es algo que no tiene límite. Si se
dispone de una determinada capacidad, probablemente se desarrollarán aplicaciones que la
usarán. La cuestión acerca de la velocidad tiene, hasta cierto tiempo, una respuesta más
fácil. Para alcanzar un rendimiento máximo, la memoria debe ser capaz de mantener el
ritmo del procesador. Es decir, según el procesador va ejecutando instrucciones, no debería
haber pausas esperando que estén disponibles las instrucciones o los operandos. Se debe
considerar también la última pregunta. Para un sistema práctico, el coste de la memoria
debe ser razonable en relación con los otros componentes.
Como se podría esperar, hay un compromiso entre las tres características
fundamentales de la memoria: a saber, coste, capacidad y tiempo de acceso. En cualquier
momento dado, se utilizan diversas tecnologías para implementar los sistemas de memoria.
En todo este espectro de tecnologías, se cumplen las siguientes relaciones:
• Cuanto menor tiempo de acceso, mayor coste por bit.
• Cuanto mayor capacidad, menor coste por bit.
• Cuanto mayor capacidad, menor velocidad de acceso.

45
Queda claro el dilema al que se enfrenta el diseñador. A él le gustaría utilizar
tecnologías que proporcionen una memoria de gran capacidad, tanto porque se necesita esa
capacidad como porque su coste por bit es bajo. Sin embargo, para cumplir con los
requisitos de rendimiento, el diseñador necesita utilizar memorias de capacidad
relativamente baja con tiempos de acceso rápidos. La solución a este dilema consiste en no
basarse en un único componente de memoria o en una sola tecnología, sino emplear una
jerarquía de memoria. Según se desciende en la jerarquía, ocurre lo siguiente:
a) Disminución del coste por bit.
b) Aumento de la capacidad.
c) Aumento del tiempo de acceso.
d) Disminución de la frecuencia de acceso a la memoria por parte del procesador.
Por tanto, las memorias más rápidas, caras y pequeñas se complementan con
memorias más lentas, baratas y grandes. La clave para el éxito de esta organización es el
último aspecto: la disminución de la frecuencia de acceso. Este concepto se examinará con
mayor detalle más adelante en este mismo capítulo, cuando se estudie la cache, y en
posteriores capítulos del libro, cuando se presente la memoria virtual. De todos modos, se
proporcionará una breve explicación en ese momento.
Supóngase que el procesador tiene acceso a dos niveles de memoria. El nivel 1
contiene 1.000 bytes y tiene un tiempo de acceso de 0.1 ms; el nivel 2 contiene 100.000
bytes y tiene un tiempo de acceso de 1ms. Asuma que si un byte que se va a acceder está en
el nivel 1, el procesador lo hace directamente. Sin embargo, si está en el nivel 2, primero se
transfiere el byte al nivel 1 y, a continuación, el procesador lo accede. Para simplificar, se
ignorará el tiempo requerido por el procesador para determinar si el byte está en el nivel 1 o
en el 2. En el ejemplo, se supone que el 95% de los accesos a memoria se encuentran en la
cache (A = 0,95). Por tanto, el tiempo medio para acceder a un byte se puede expresar
como:
(0,95)(0,1 ms) + (0,05)(0,1 ms + 1 ms) = 0,095 + 0,055 = 0,15 ms

46
El resultado está próximo al tiempo de acceso de la memoria más rápida. Por tanto,
en principio, la estrategia de utilizar dos niveles de memoria funciona, pero sólo si se
cumplen las condiciones de la (a) a la (d). Mediante el empleo de diversas tecnologías,
existe un rango de sistemas de memoria que satisfacen las condiciones de la (a) a la (c).
Afortunadamente, la condición (d) también es generalmente válida. La validez de la
condición (d) está basada en un principio conocido como la proximidad de referencias
[DENN68].
Durante el curso de ejecución de un programa, las referencias de memoria del
procesador, tanto a instrucciones como a datos, tienden a agruparse. Los programas
contienen habitualmente diversos bucles iterativos y subrutinas. Una vez que se inicia un
bucle o una subrutina, hay referencias repetidas a un pequeño conjunto de instrucciones.
Del mismo modo, las operaciones con tablas y vectores involucran accesos a conjuntos
agrupados de bytes de datos. (Stalligs, 2005, pág. 28)
Figura 15. Jerarquía de memoria entre diversos medios de almacenamiento.

47
5.3 Partición, Segmentación, Paginación
Tabla 5. Técnicas de gestión de memoria
Fuente: (Stalligs, 2005, pág. 312)

48
5.3.1 Particionamiento de la memoria
La operación principal de la gestión de la memoria es traer los procesos a la memoria
principal para que el procesador los pueda ejecutar. En casi todos los sistemas
multiprogramados modernos, esto implica el uso de un esquema sofisticado denominado
memoria virtual. Por su parte, la memoria virtual se basa en una o ambas de las siguientes
técnicas básicas: segmentación y paginación. Antes de fijarse en estas técnicas de memoria
virtual, se debe preparar el camino, analizando técnicas más sencillas que no utilizan
memoria virtual (Tabla 7.1). Una de estas técnicas, el particionamiento, se ha utilizado en
algunas variantes de ciertos sistemas operativos ahora obsoletos. Las otras dos técnicas,
paginación sencilla y segmentación sencilla, no son utilizadas de forma aislada. Sin
embargo, quedará más clara la discusión de la memoria virtual si se analizan primero estas
dos técnicas sin tener en cuenta consideraciones de memoria virtual.
Particionamiento fijo
En la mayoría de los esquemas para gestión de la memoria, se puede asumir que el
sistema operativo ocupa alguna porción fija de la memoria principal y que el resto de la
memoria principal está disponible para múltiples procesos. El esquema más simple para
gestionar la memoria disponible es repartirla en regiones con límites fijos.
Figura 16. Ejemplo de particionamiento fijo de una memoria de 64 Mbytes.
(Stalligs, 2005, pág. 313)

49
5.3.2 Segmentación
Al desarrollar un programa en un lenguaje de alto nivel, el programador usualmente
no se preocupa por la ubicación en la memoria física de los diferentes elementos que lo
componen. Esto se debe a que en estos lenguajes las variables y funciones son
referenciadas por sus nombres, no por su ubicación6. No obstante, cuando se compila el
programa para una arquitectura que soporte segmentación, el compilador ubicará a cada
una de las secciones presentadas en la sección 5.1.4 en un segmento diferente. Esto permite
activar los mecanismos que evitan la escritura accidental de las secciones de memoria del
proceso que no se deberían modificar (aquellas que contienen código o de sólo lectura), y
permitir la escritura de aquellas que sí (en las cuales se encuentran las variables globales, la
pila o stack y el espacio de asignación dinámica o heap).
Así, los elementos que conforman un programa se organizan en secciones: una
sección contiene el espacio para las variables globales, otra sección contiene el código
compilado, otra sección contiene la tabla de símbolos, etc.
Luego, cuando el sistema operativo crea un proceso a partir del programa, debe
organizar el contenido del archivo ejecutable en memoria. Para ello carga en memoria
algunas secciones del archivo ejecutable (como mínimo la sección para las variables
globales y la sección de código) y puede configurar otras secciones como la pila o la
sección de libres. Para garantizar la protección de cada una de estas secciones en la
memoria del proceso, el sistema puede definir que cada sección del programa se encuentra
en un segmento diferente, con diferentes tipos de acceso.
La segmentación es un concepto que se aplica directamente a la arquitectura del
procesador. Permite separar las regiones de la memoria lineal en segmentos, cada uno de
los cuales puede tener diferentes permisos de acceso, como se explicará en la siguiente
sección. La segmentación también ayuda a incrementar la modularidad de un programa: es
muy común que las bibliotecas ligadas dinámicamente estén representadas en segmentos

50
independientes. Un código compilado para procesadores que implementen segmentación
siempre generará referencias a la memoria en un espacio segmentado. Este tipo de
referencias se denominan direcciones lógicas y están formadas por un selector de segmento
y un desplazamiento dentro del segmento. Para interpretar esta dirección, la MMU debe
tomar el selector, y usando alguna estructura de datos, obtiene la dirección base, el tamaño
del segmento y sus atributos de protección. Luego, aplicando el mecanismo explicado en
secciones anteriores, toma la dirección base del segmento y le suma el desplazamiento para
obtener una dirección lineal física.
Figura 17. Ejemplo de Segmentación
La traducción de una dirección lógica a una dirección lineal puede fallar por
diferentes razones: si el segmento no se encuentra en memoria, ocurrirá una excepción del
tipo segmento no presente. Por otro lado, si el desplazamiento especificado es mayor al
tamaño definido para el segmento, ocurrirá una excepción del tipo violación de segmento.
(Wolf, Ruiz, Bergero, & Meza, 2015, pag 178)
5.3.3 Paginación
La fragmentación externa y, por tanto, la necesidad de compactación pueden evitarse
por completo empleando la paginación. Ésta consiste en que cada proceso está dividio en

51
varios bloques de tamaño fijo (más pequeños que los segmentos) llamados páginas, dejando
de requerir que la asignación sea de un área contigua de memoria. Claro está, esto requiere
de mayor soporte por parte del hardware, y mayor información relacionada a cada uno de
los procesos: no basta sólo con indicar dónde inicia y termina el área de memoria de cada
proceso, sino que se debe establecer un mapeo entre la ubicación real (física) y la
presentada a cada uno de los procesos (lógica). La memoria se presentará a cada proceso
como si fuera de su uso exclusivo.
La memoria física se divide en una serie de marcos (frames), todos ellos del mismo
tamaño, y el espacio para cada proceso se divide en una serie de páginas (pages), del mismo
tamaño que los marcos. La MMU se encarga del mapeo entre páginas y marcos mediante
tablas de páginas. Cuando se trabaja bajo una arquitectura que maneja paginación, las
direcciones que maneja el CPU ya no son presentadas de forma absoluta. Los bits de cada
dirección se separan en un identificador de página y un desplazamiento, de forma similar a
lo presentado al hablar de resolución de instrucciones en tiempo de ejecución. La principal
diferencia con lo entonces abordado es que cada proceso tendrá ya no un único espacio en
memoria, sino una multitud de páginas.
El tamaño de los marcos (y, por tanto, las páginas) debe ser una potencia de dos, de
modo que la MMU pueda discernir fácilmente la porción de una dirección de memoria que
se refiere a la página del desplazamiento. El rango varía, según el hardware, entre los 512
bytes (29) y 16 MB (224); al ser una potencia de dos, la MMU puede separar la dirección
en memoria entre los primeros m bits (referentes a la página) y los últimos n bits (referentes
al desplazamiento).
Para poder realizar este mapeo, la MMU requiere de una estructura de datos
denominada tabla de páginas (page table), que resuelve la relación entre páginas y marcos,
convirtiendo una dirección lógica (en el espacio del proceso) en la dirección física (la
ubicación en que realmente se encuentra en la memoria del sistema). (Wolf, Ruiz, Bergero,
& Meza, 2015) pag- 182

52
Figura 18. Esquema del proceso de paginación, ilustrando el papel de la MMU.
(Wolf, Ruiz, Bergero, & Meza, 2015, pag 183)
CAPÍTULO 6.- Gestión de almacenamiento en LINUX
6.1 Planificación y gestión de dispositivos de almacenamiento secundario
(Discos)
En términos generales, el sistema de E/S del núcleo de Linux es muy similar al de
otras implementaciones de UNIX, como es el caso de SVR4. El núcleo de Linux asocia un
fichero especial con cada manejador de dispositivo de E/S, distinguiéndose entre
dispositivos de bloques, de caracteres y de red.

53
PLANIFICACIÓN DE DISCO
El planificador de disco por defecto en Linux 2.4 se le conoce con el nombre de
ascensor de Linus, que es una variación del algoritmo LOOK. En Linux 2.6, además del
algoritmo del ascensor, se han incluido dos algoritmos adicionales: el planificador de E/S
basado en plazos y el planificador de E/S previsor [LOVE04b]. A continuación, se
estudiará cada uno de ellos.
EL PLANIFICADOR DEL ASCENSOR
El planificador del ascensor mantiene una única cola con las peticiones de lectura y
escritura en el disco, realizando operaciones de ordenamiento y agrupamiento sobre la cola.
En términos generales, el planificador del ascensor mantiene la lista de peticiones
ordenadas por el número de bloque. De esta manera, cuando se manejan las peticiones de
disco, el dispositivo se mueve en una única dirección, satisfaciendo cada petición según la
encuentra. Esta estrategia general se mejora de la siguiente manera. Cuando se añade una
nueva petición a la cola, se consideran en este orden las siguientes cuatro operaciones:
1. Si existe una petición pendiente en la cola de tal manera que la nueva petición
corresponde con el mismo sector del disco o uno inmediatamente adyacente al
requerido por dicha petición previa, la petición existente y la nueva se mezclan
en una sola.
2. Si hay una petición en la cola que es suficientemente antigua, la nueva petición
se inserta al final de la cola.
3. Si hay una posición adecuada, la nueva petición se sitúa en el orden
correspondiente.
4. Si no hay una posición adecuada, la nueva petición se sitúa al final de la cola.
PLANIFICADOR BASADO EN PLAZOS
La segunda operación de la lista precedente intenta evitar la inanición de una
petición, pero no es muy efectiva [LOVE04a]. No intenta servir peticiones en un plazo de
tiempo determinado, sino que simplemente deja de insertar las peticiones en orden después

54
de un plazo conveniente. En el esquema del ascensor se manifiestan dos problemas. El
primer problema es que se puede retrasar una petición de un bloque distante durante un
tiempo considerable debido a que la cola se actualiza dinámicamente. Por ejemplo,
considere el siguiente flujo de peticiones de los bloques de disco: 20, 30, 700 y 25.
El planificador del ascensor modifica el orden de estas peticiones de manera que se
sitúan en la cola en el orden 20, 25, 30 y 700, estando la petición del bloque 20 en la cabeza
de la cola. Si llega una secuencia continua de peticiones que corresponden con bloques de
baja numeración, la petición del bloque 700 se retrasa indefinidamente. Un problema
incluso más serio es el de la distinción entre peticiones de lectura y de escritura.
Normalmente, una petición de escritura se realiza asíncronamente. Es decir, una vez que un
proceso solicita una petición de escritura, no necesita esperar hasta que realmente se lleve a
cabo la petición. Cuando una aplicación solicita una escritura, el núcleo copia los datos en
un buffer apropiado, que se escribirá cuando se considere oportuno.
Una vez que se copian los datos en el buffer del núcleo, la aplicación puede continuar.
Sin embargo, en muchas operaciones de lectura, el proceso, antes de continuar, debe
esperar hasta que se entreguen los datos pedidos a la aplicación. Por tanto, un flujo de
peticiones de escritura (por ejemplo, para escribir en el disco un fichero grande) puede
bloquear una petición de lectura durante un tiempo considerable y, con ello, bloquear
también al proceso. El esquema del planificador de E/S basado en plazos supera el
problema de la inanición y también el problema de las lecturas frente a las escrituras.
Figura 19. El planificador de E/S basado en plazos de Linux.
(Stalligs, 2005, pág. 528)

55
PLANIFICADOR DE E/S PREVISOR
El planificador del ascensor original y el basado en plazos están diseñados para servir
una nueva petición tan pronto como se completa la petición existente, manteniendo, por
tanto, el disco lo más ocupado que sea posible. Sin embargo, esta política puede ser
contraproducente si hay numerosas peticiones de lectura síncronas. Normalmente, una
aplicación esperará hasta que se complete una petición de lectura y estén los datos
disponibles antes de realizar la siguiente petición. El pequeño retardo que hay entre que se
reciben los datos de la última lectura y la solicitud de la siguiente lectura permite al
planificador dedicarse a otra petición pendiente y servir esa petición.
Gracias al principio de la proximidad, es probable que las lecturas sucesivas del
mismo proceso se encuentren en bloques de disco que estén los unos cerca de los otros. Si
el planificador tuviera un retardo de un breve periodo de tiempo después de servir una
petición de lectura, de manera que pudiera comprobar si se hace una nueva petición de
lectura cercana, el rendimiento global del sistema podría mejorarse. Ésta es la filosofía en la
que se basa el planificador previsor, propuesto en [IYER01], e implementado en Linux 2.6.
En Linux, el planificador previsor está superpuesto sobre el planificador basado en
plazos. Cuando se sirve una petición de lectura, el planificador previsor causa que el
sistema de planificación se retrase hasta 6 milisegundos, dependiendo de la configuración.
Durante este pequeño retardo, hay una oportunidad apreciable de que la aplicación que
solicitó la última petición de lectura genere otra petición de lectura en la misma región del
disco. En caso de que sea así, esa petición se servirá inmediatamente.
Si no se produce esa petición de lectura, el planificador continúa utilizando el
algoritmo de planificación basado en plazos. [LOVE04b] muestra los resultados de dos
pruebas del algoritmo de planificación de Linux. La primera prueba consistió en la lectura
de un fichero de 200 MB mientras se hace una larga escritura secuencial ejecutando en
segundo plano. En la segunda prueba se realizó una lectura de un fichero grande ejecutando

56
en segundo plano mientras que se leen todos los ficheros del árbol de código fuente del
núcleo. En la siguiente tabla se muestran los resultados de las pruebas:
Tabla 6. Mejora de rendimiento del disco
Fuente: (Stalligs, 2005, pág. 529)
6.2 Sistema de Archivos VFS
El núcleo de Linux maneja todos estos diferentes tipos de archivos ocultando los
detalles de implementación de cualquier tipo de archivo individual detrás de una capa de
software, el sistema de archivos virtual (VFS, virtual file system).
El VFS de Linux se diseñó según los principios de la orientación a objetos, y tiene
dos componentes: un conjunto de definiciones que definen el aspecto que puede tener un
objeto archivo y una capa de software para manipular dichos objetos. Los tres tipos
principales de objetos definidos por el VFS son las estructuras de objeto i-nodo y objeto
archivo, que representan archivos individuales, y el objeto sistema de archivos, que
representa todo un sistema de archivos.
Para cada uno de estos tres tipos de objetos, el VFS define un conjunto de
operaciones que esa estructura debe implementar. Cada objeto de uno de estos tipos
contiene un puntero a una tabla de funciones, la cual lista las direcciones de las funciones
reales que implementan esas operaciones para ese objeto específico. Así, la capa de
software del VFS puede efectuar una operación con uno de estos objetos invocando la
función apropiada de la tabla de funciones de ese objeto, sin tener que conocer con
antelación exactamente de qué clase de objeto se trata. El VFS no sabe, ni le importa, si un

57
i-nodo representa un archivo de red, un archivo de disco, un socket de red o un archivo de
directorio; la función apropiada para la operación leer datos de ese archivo siempre estará
en el mismo lugar en su tabla de funciones, y la capa de software del VFS invocará esa
función sin preocuparse cómo se leen realmente los datos.
El objeto sistema de archivos representa un conjunto conectado de archivos que
forma una jerarquía de directorios autónoma. El núcleo del sistema operativo mantiene un
solo objeto sistema de archivos para cada disco montado como sistema de archivos y para
cada sistema de archivos de red conectado actualmente. La principal obligación del objeto
sistema de archivos es proporcionar acceso a los i-nodos.
El VFS identifica cada i-nodo por un par (sistema de archivos-número de i-nodo)
único, y encuentra el i-nodo que corresponde a un número de i-nodo específico pidiendo al
objeto sistema de archivos que devuelva el i-nodo que tiene ese número.
Los objetos i-nodo y archivo son los mecanismos empleados para acceder a archivos.
Un objeto i-nodo representa el archivo como un todo, y un objeto archivo representa un
punto de acceso a los datos del archivo. Un proceso no puede acceder al contenido de datos
de un i-nodo sin obtener primero el objeto archivo que apunta al i-nodo. El objeto archivo
indica en qué lugar del archivo el proceso está leyendo o escribiendo actualmente, para
seguir la pista a la E/S secuencial. Este objeto también recuerda si el proceso pidió
permisos de escritura cuando abrió el archivo, y sigue la pista a las actividades del proceso
si es necesario para realizar lectura adelantada adaptativa (traer datos a la memoria antes de
que el proceso los solicite, para mejorar el desempeño).
Los archivos de directorio se manejan de forma un poco diferente de los demás
archivos. La interfaz de programación de UNIX define varias operaciones con directorios,
como crear, eliminar y cambiar el nombre de un archivo de un directorio. A diferencia de la
lectura y escritura de datos, para lo cual es necesario abrir primero el archivo, las llamadas
al sistema para estas operaciones de directorio no requieren que el usuario abra los archivos

58
en cuestión. Por tanto, el VFS define estas operaciones de directorio en el objeto i-nodo, no
en el objeto archivo. (Silberschatz y Galvin, 1999, pág. 726)
Figura 20. Directorios y nodos-i UNIX

59
6.3 Sistemas de archivos manejados por LINUX (NFS, ext2fs)
6.3.1 NFS: El sistema de archivos de red
Las redes han desempeñado un papel importante en LINUX y UNIX en general, justo
desde el inicio la primera red de UNIX se construyó para trasladar los nuevos kernels de la
PDP-11/70 a la Interdata 8/32 durante la creación del puerto de UNIX para esta última). En
esta sección examinaremos el NFS (Network File System, Sistema de archivos de red) de
Sun Microsystems, que se utiliza en todos los sistemas modernos de Linux para unir los
sistemas de archivos en computadoras separadas en un todo lógico. En la actualidad, la
implementación dominante del NFS es la versión 3, que se introdujo en 1994. El NSFv4 se
introdujo en el 2000 y provee ciertas mejoras sobre la arquitectura anterior del NFS. Hay
tres aspectos de interés en el NFS: la arquitectura, el protocolo y la implementación. Ahora
examinaremos cada uno de ellos en turno, primero en el contexto de la versión 3 del NFS
que es más simple, y después analizaremos con brevedad las mejoras que se incluyen en la
v4.
Arquitectura del NFS
La idea básica detrás del NFS es permitir que una colección arbitraria de clientes y
servidores compartan un sistema de archivos común. En muchos casos, todos los clientes y
servidores se encuentran en la misma LAN, pero esto no es obligatorio. También es posible
usar el NFS a través de una red de área amplia si el servidor está alejado del cliente. Por
cuestión de simplicidad, hablaremos sobre los clientes y servidores como si estuvieran en
distintas máquinas, pero de hecho, el NFS permite que cualquier máquina sea tanto cliente
como servidor al mismo tiempo.
Cada servidor del NFS exporta uno o más de sus directorios para que los clientes
remotos puedan utilizarlos. Cuando se comparte un directorio, también se comparten todos
sus subdirectorios, por lo que los árboles de directorios completos se exportan normalmente

60
como una unidad. La lista de directorios que exporta un servidor se mantiene en un archivo
(a menudo se llama /etc/exports), por lo que estos directorios se pueden exportar de manera
automática cada vez que se inicia el sistema.
Para acceder a los directorios exportados, los clientes tienen que montarlos. Cuando
un cliente monta un directorio (remoto), se convierte en parte de su jerarquía de directorios,
como se muestra en la figura 10-35.
En este ejemplo, el cliente 1 montó el directorio bin del servidor 1 en su propio
directorio bin, por lo que ahora se puede referir al shell como /bin/sh y obtener el shell en el
servidor 1. Las estaciones de trabajo sin discos a menudo tienen sólo un sistema de archivos
esqueleto (en la RAM) y obtienen todos sus archivos de los servidores remotos como éste.
De manera similar, el cliente 1 montó el directorio /proyectos del servidor 2 en su directorio
/usr/ast/trabajo, de manera que ahora puede acceder al archivo a como
/usr/ast/trabajo/proy1/a. Por último, el cliente 2 montó también el directorio proyectos y
puede acceder al archivo a, sólo que como /mnt/proy1/a. Como se puede ver aquí, el mismo
archivo puede tener distintos nombres en los distintos clientes, debido a que se monta en un
lugar distinto en los respectivos árboles. El punto de montaje es completamente local para
los clientes; el servidor no sabe en dónde está montado en cualquiera de sus clientes.
Protocolos del NFS
Como uno de los objetivos del NFS es proporcionar un sistema heterogéneo, donde
los clientes y servidores posiblemente ejecuten distintos sistemas operativos en hardware
distinto, es esencial que la interfaz entre los clientes y servidores esté bien definida. Sólo
así es posible que alguien pueda escribir una nueva implementación de un cliente y esperar
que funcione correctamente con los servidores existentes, y viceversa.

61
Figura 21. Ejemplos del montaje de sistemas de archivos remotos. Los
directorios se muestran como cuadros y los archivos como círculos.
Para lograr este objetivo, el NFS define dos protocolos cliente-servidor. El primer
protocolo del NFS se encarga del montaje. Un cliente puede enviar un nombre de ruta a un
servidor y solicitar permiso para montar ese directorio en alguna parte de su jerarquía de
directorios. El lugar en el que se va a montar no está contenido en el mensaje, ya que al
servidor no le importa en dónde se va a montar. Si el nombre de ruta es legal y se ha
exportado el directorio especificado, el servidor devuelve un manejador de archivo al
cliente. Este manejador contiene campos que identifican en forma única el tipo del sistema
de archivos, el disco, el número de nodo-i del directorio y la información de seguridad. Las
siguientes llamadas para leer y escribir en los archivos del directorio montado, o en
cualquiera de sus subdirectorios, utilizan el manejador del archivo. (Tanenbaum, 2009)
6.3.2 El sistema de archivos Linux ext2fs
El sistema de archivos de disco estándar que Linux emplea se denomina ext2fs por
razones históricas. Linux se programó originalmente con un sistema de archivos compatible
con Minix, a fin de facilitar el intercambio de datos con el sistema de desarrollo Minix,

62
pero ese sistema de archivos estaba muy restringido por los límites de 14 caracteres para los
nombres de archivo y de 64 megabytes para el sistema de archivos.
El sistema de archivos Minix fue reemplazado por uno nuevo, que se bautizó como
sistema de archivos extendido (extfs, extended file system). Un rediseño posterior de este
sistema de archivos para mejorar el desempeño y la escalabilidad y añadir unas cuantas
funciones que faltaban dio pie al segundo sistema de archivos extendido, extlfs. Ext2fs tiene
mucho en común con el Sistema de Archivos Rápido (ffs) de BSD que describimos en la
sección 21.7.7; utiliza un mecanismo similar para localizar los bloques de datos que
pertenecen a un archivo específico, almacenar punteros a los bloques de datos en bloques
indirectos dispersos por todo el sistema de archivos con hasta tres niveles de indirección. Al
igual que en el ffs, los archivos de directorio se almacenan en disco lo mismo que los
archivos normales, aunque su contenido se interpreta de diferente manera. Cada bloque de
un archivo de directorio consiste en una lista enlazada de entradas, donde cada entrada
contiene la longitud de la entrada, el nombre de un archivo y el número del i-nodo al que se
refiere la entrada.
Las diferencias principales entre ext2fs y ffs atañen las políticas de asignación de
disco. En ffs, el disco se asigna a los archivos en bloques de 8 kilobytes, y los bloques se
subdividen en fragmentos de 1 kilobyte para almacenar archivos pequeños o bloques
parcialmente llenos al final de un archivo. En contraste, ext2fs no usa fragmentos, sino que
realiza todas sus asignaciones en unidades más pequeñas. El tamaño de bloque por omisión
en ext2fs es de 1 kilobyte, aunque también se manejan bloques de 2 y 4 kilobytes.

63
Figura 22. Políticas de asignación de bloques ext2fs
(Silberschatz & Galvin, 1999, pág. 729)
CAPÍTULO 7.- GESTIÓN DE E/S
7.1 Manejo de Periféricos a través del Sistema de Archivos
Para acceder a otras particiones y dispositivos, GNU/Linux utiliza el proceso de
montaje. Este sistema a igual que Unix se basa en la metodología de uso:
1. Si el dispositivo es removible (CD), el usuario lo ingresa en la lectora.
2. Mediante el comando mount, asigna este dispositivo a un directorio
denominado punto de montaje.
3. Desde el punto de montaje, el usuario podrá leer y escribir los datos
almacenados en ese dispositivo.

64
4. Una vez que haya terminado de usar el dispositivo, el usuario debe eliminar el
enlace entre el dispositivo y el punto de montaje haciendo uso del comando
umount
Si un usuario quiere utilizar un disco floppy, entonces debe insertarlo en la disquetera
y ejecutar el siguiente comando:
mount /dev/floppy /mnt/floppy
El comando mount requiere dos parámetros. El primero de ellos es el dispositivo por
montar. Recuerden que el directorio /dev/ están todos los archivos que representan los
diferentes dispositivos básicos de nuestro sistema. Por consiguiente, /dev/floppy representa
nuestra primera disquera. El segundo parámetro que requiere el comando mount es el
punto de montaje, ósea el directorio que usaremos para acceder a ese disco flexible. El
directorio /mnt/floppy que pusimos en el ejemplo puede no existir. En tal caso, el usuario
puede crear su propio directorio o utilizar cualquier otro.
En el sistema de archivos todos los programas de usuario, documentos, herramientas,
aplicaciones, etc. son almacenados como archivos en un sistema de computadora. Todos los
archivos son almacenados en un dispositivo de almacenamiento secundario (usualmente
disco). Una porción del disco es separada para almacenar la información relacionada a los
archivos almacenaodos.
 El área de la superficie donde se almacenan los archivos se divide en pistas
circulares.
 Las pistas circulares están divididas en sectores o bloques de disco.
 Todos los bloques del disco son del mismo tamaño y tienen un número único
llamado el número de bloque de disco.
 El tamaño del bloque de disco varía dependiendo de la distribución de Linux.

65
7.2 Administración de Archivos de Entrada, Salida
7.2.1 Entrada Estándar, Salida Estándar y Error Estándar
Los Sistemas Operativos Linux trabajan con entrada, salida y errores. Los sistemas
Linux, cualquier programa incluyendo los comandos Linux están conectados
automáticamente a tres archivos:
 Entrada estándar.
 Salida estándar.
 Error estándar.
Comando Linux
Entrada Estándar
Salida Estándar
Mensajes de Error
Salida
Figura 23. Esquema de Entrada, Salida y Error Estándar.
Un programa obtiene su entrada de la entrada estándar, envía su salida a la salida
estándar y el mensaje de error estándar. Todos ellos por defecto en el terminar. En un
sistema Linux, todos los dispositivos son tratados como archivos.
7.2.2 Redirección de Entrada/Salida
Se puede hacer un programa que tome la entrada de un archivo y envié la salida hacia
un archivo a través de la redirección. La redirección es una manera a través de la cual se
puede cambiar tanto la entrada estándar como la salida estándar. Algunos puntos acerca de
la redirección se mencionan a continuación:

66
 Se usaran los operadores de redirección < y > para salidas y entradas
respectivamente.
 El operador > hace del archivo que sigue al operador la nueva salida estándar y
de manera similar, el operador < cambia la entrada estándar.
 El uso de los operadores > y < para redirección es temporal.
7.3 Comandos Simples.
Una de las mayores ventajas que le veo a GNU/Linux con respecto a otros sistemas
operativo es su terminal. Al principio puede intimidar, pero es una buena herramienta para
realizar fácilmente ciertas operaciones sin tener que andar navegando en los menús de la
interfaz gráfica.
cat: El comando cat , mostrará como salida el contenido del archivo que le pasemos
como argumento. Cuando definamos el archivo a mostrar, deberemos tener en cuenta el
escribir la ruta completa de este archivo. Aquí os dejo algunos ejemplos:
 cat /etc/issue mostrará el contenido del fichero issue, que normalmente
almacena el nombre de la distribución.
 cat /proc/version que en este caso nos da como salida el contenido del fichero
versión dentro de la carpeta /proc que como norma general contiene la versión
del Kernel de la distribución que estamos usando.
 cat --h nos mostrará todas las opciones que podemos usar para trabajar con este
comando.
cd: Con este comando podremos movernos por las diferentes carpetas. Vamos con los
ejemplos:
 cd /xxxx donde xxxx es el nombre del fichero al que queremos desplazarnos,
siempre escribiendo la ruta completa, es decir, si la carpeta está en el escritorio
del usuario1, por ejemplo, tendremos que poner cd
/home/usuario1/Escritorio/xxxx.
 cd .. Desde el directorio donde nos encontramos, retrocederemos un nivel en el
árbol de directorio. Usando el ejemplo anterior, si nos encontramos en cd

67
/home/usuario1/Escritorio/xxxx y usamos el comando cd .. Volveremos a
/home/usuario1/Escritorio.
 cd ../.. Con este otro no retrocederemos sólo un nivel si no dos, por lo que en el
caso que hemos usado anteriormente, nos situaríamos en /home/usuario1.

ls: El comando ls listará los ficheros y carpetas contenidas en el directorio donde nos
situamos. Aquí unos ejemplos:
 ls –l Mostrará los archivos y carpetas con un formato de lista. Incluye
información de permisos, tamaño (en el caso de los ficheros), etc…
 ls –a Mostrará todos los archivos y carpetas, incluidos los ocultos.
 ls –h Nos ―traducirá‖ el tamaño de los archivos a un método de lectura mucho
más fácil de entender (normalmente los muestra en bytes), por ejemplo, en lugar
de mostrar 1024bytes mostrará 1K.
rm: Con este comando podremos eliminar ficheros simplemente pasándole como
argumento el nombre del fichero deseado. Los ejemplos:
 rm –v hará que se nos muestre el nombre del fichero antes de borrarlo.
 rm –r borrará los subdirectorios de manera recursiva, por lo que deberemos
tener mucho cuidado de ver sobre qué ubicación lo aplicamos.
 rm –f fuerza el borrado de los archivos y directorios, omitiendo cualquier aviso
que el sistema pueda ofrecer, así como la confirmación del usuario para ejecutar
la eliminación.
 rm –rf el comando definitivo para la eliminación, mucho cuidado con este,
porque ejecutado en la raíz del sistema / causaría la eliminación inmediata de
todas las carpetas contenidas en /.
cp: Comando con el que copiaremos archivos o directorios de una ubicación a otra.
También es usado normalmente para renombrar ficheros o carpetas. Algunos ejemplos:
 cp archivo1 carpetadestino/ creará una copia del documento llamado archivo1
en la ubicación carpetadestino/.

68
 cp archivo1 fichero2 creará una copia de archivo1 pero con el nombre fichero2.
En el comando, si tras fichero2 especificamos una ruta, creará esa copia en la
ubicación que le pasemos.
 cp –u fichero1 /carpetadestino copiará el archivo fichero1 SÓLO si es más
reciente que el archivo del mismo nombre de la ubicación que le acabamos de
pasar. Muy útil para copias de seguridad.
pwd: Un comando muy simple, pero muy útil porque nos mostrará en caso de que
con tanto baile de directorios y ficheros nos hayamos desubicado, la ubicación actual donde
nos encontramos .
mkdir: Comando que creará directorios, bien dentro de la carpeta donde nos
encontremos, bien en una ruta que le especifiquemos. Vamos con los ejemplos:
 mkdir carpeta1 creará un directorio llamado carpeta1 dentro de la ubicación
donde nos hallemos.
 mkdir carpeta1 /etc/ creará el mismo directorio pero dentro de la carpeta /etc/
 mkdir –p /etc/carpeta1/carpeta2 creará la estructura de carpetas padre y
carpetas hijo que les especifiquemos y en la ruta que especifiquemos, como en
el ejemplo, donde en /etc/ se creará la carpeta llamada carpeta1 y dentro de esta
otra llamada carpeta2.
Rmdir: Antítesis del anterior, puesto que con este comando eliminaremos
directorios. Algunos ejemplos:
 rmdir /carpeta1 eliminará el directorio llamado carpeta1.
 rmdir –p /carpeta1 elimina la carpeta indicada e intenta eliminar también la
carpeta padre en caso de quedarse éstos vacíos. Si el directorio que contiene
carpeta1 fuese /carpeta0 y /carpeta0 se quedase vacío al no estar /carpeta1,
/carpeta0 también se eliminaría.
 rmdir –ignore-fail-on-non-empty /carpeta1 eliminará el directorio llamado
carpeta1 aunque éste contenga archivos en su interior.
init: Este complejo comando, se usa normalmente para indicar qué apagado
queremos realizar. Por ejemplo:

69
 init 0 equivale al comando poweroff y apagará el equipo.
 init 6 equivaldría al comando reboot y reiniciará el sistema.
man: Este comando es uno de los que más usaréis aquellos que os iniciéis en el
mundo Linux, puesto que seguido del comando del que queramos información, mostrará en
pantalla el manual de uso de dicho comando. Aunque no sólo puede mostrarlo en pantalla,
también podremos exportarlo a un fichero .pdf. Aquí algunos ejemplos de uso:
 man comando1 mostrará la página del manual que contiene la información del
comando que le pasemos como argumento.
 man –w comando1 mostrará la ruta donde encontraremos el archivo que
contiene la información del comando que le pasemos, por si en lugar de querer
usar este comando preferimos hacer uso de cat.
 man man (no se ha repetido por error ;D) mostrará la página del manual
referentes al comando man, lo que vendría siendo el manual donde podremos
ver todas las formas posibles en las que poder consultar la información de los
comando que queramos conocer mejor.
Una nota importante, es que casi todos los comandos seguidos de un –h, - - h o - -help
mostrarán una pequeña ayuda de uso, como os puse el ejemplo del comando cat.
7.4 Los Tubos en Linux
La redirección en Linux ayuda a conectar programas con archivos, mientras que las
tuberías ayudan a conectar un programa con otros programas. Las tuberías en línea es una
característica donde la salida de un programa es enviada como entrada para otro programa.
Programa 1 Programa 2 Programa 3
Salida SalidaSalida EntradaEntrada
Salida
Estándar
Figura 24. Tuberías en línea en LINUX

70
CAPÍTULO 8.- CONSIDERACIONES SOBRE SEGURIDAD Y PROTECCIÓN
OFRECIDAS POR EL SISTEMA OPERATIVO LINUX
Habitualmente los usuarios finales no tienen en consideración la seguridad cuando
hacen uso de un sistema, ya que, frecuentemente se ignoran los aspectos relacionados con
la seguridad. De igual forma, estos aspectos a veces pueden considerarse una molestia, ya
que la seguridad suele ir en el platillo opuesto de la comodidad y facilidad de uso en la
balanza del diseño de un sistema. Es por esto que los usuarios a veces puedan tener una
imagen negativa de la seguridad, por considerarlo algo molesto y que interrumpe su
capacidad de realización de un trabajo determinado. En un entorno seguro, un usuario se
encuentra con tareas que le pueden resultar incómodas (como por ejemplo, recordar
contraseñas, cambiarlas periódicamente, etc.) y que pueden limitar las operaciones que
puede realizar así como los recursos a los que se le permite acceder.
Sin embargo, la seguridad es fundamental a la hora de afrontar tareas que se realizan
en sistemas informáticos ya que son las únicas medidas que pueden garantizar que éstas se
realicen con una serie de garantías que se dan por sentado en el mundo físico. En el mundo
intangible de la informática, tan cerca de un servidor están sus usuarios legítimos como los
usuarios que hacen uso de la misma red de comunicaciones. Es más, estos usuarios, en el
caso de una red global, se cuentan por millones. Algunos serán ―buenos vecinos‖ pero otros
serán agentes hostiles.
Los mecanismos de protección de un sistema deben permitir controlar qué usuarios
tienen acceso a los recursos del sistema y qué tipo de operaciones pueden realizar sobre
esos recursos. (Ministerio de Educación Cultura y Deporte, 2008) afirma:
Todo mecanismo de protección debe manejar 2 conceptos:
1. Recursos: son las partes del sistema utilizadas por los procesos.

71
2. Dominios de protección: son el conjunto de recursos y operaciones sobre estos
recursos que podrán utilizar todos aquellos procesos que se ejecuten sobre él.
En general, en un sistema LINUX, el conjunto de recursos está formado por todos los
archivos del sistema, y el dominio será un usuario y los procesos que el ejecuta y que, por
tanto, tengan el mismo UID efectivo.
Para controlar el acceso de los dominios a los recursos se utilizan las Listas de
Control de Acceso por cada recurso. La Lista de Control de Acceso (ACL) especifica qué
dominios tienen acceso al recurso y qué operaciones asociadas al recurso pueden utilizar. El
problema que plantea la lista de control de acceso es su tamaño variable, ya que depende
del número de dominios que tengan acceso al recurso y de las operaciones que pueda
realizar cada uno de ellos.
En Linux, para conseguir Listas de tamaño constante, se utilizan 2 técnicas:
1. Reducir el numero de operaciones posibles sobre un recurso (archivo):
podemos controlar 3 operaciones sobre los archivos, que son la lectura (r),
escritura (w) y la ejecución (x).
2. Reducir el número de dominios que aparecen en la lista. Esto se consigue
mediante el concepto de grupos de usuarios.
Todos los usuarios de un sistema Linux deben pertenecer, al menos, a un grupo.
Existen 3 grupos o categorías en la relación entre un dominio (usuario) y un recurso
(archivo):
• Propietario: indica quién creó el archivo
• Grupo del propietario: reúne a todos los usuarios que pertenecen al grupo del
propietario.

72
• Resto de usuarios: los que no crearon el archivo y no pertenecen al grupo del
propietario.
•
Respecto a dónde se produzca el ataque (Hardware o Software), hemos de tener claro
qué puede hacerse o cual será el objetivo de los métodos.
8.1 Seguridad a través del Hardware
A nivel de hardware, la amenaza está directamente sobre la accesibilidad, ¿qué podrá
hacer alguien que tenga acceso al hardware? En este caso normalmente necesitaremos
medidas ―físicas‖, como controles de seguridad para acceder a los locales donde estén las
máquinas para evitar problemas de robo o rotura del equipo con el fin de eliminar su
servicio. También puede comprometerse la confidencialidad y la integridad si el acceso
físico a las máquinas permite utilizar algunos de sus dispositivos como las disqueteras, o el
arranque de las máquinas, o el acceso a cuentas de usuario que podrían estar abiertas.
(Jorba y Suppi, 2004)
8.2 Seguridad a través del Software
Si la accesibilidad se ve comprometida en un ataque, puede haber borrado o
inutilizados programas, denegando el acceso. En caso de confidencialidad, puede provocar
copias no autorizadas de software. En integridad podría alterarse el funcionamiento por
defecto del programa, para que éste fallase en algunas situaciones o bien para que realice
tareas que puedan ser interesantes de cara al atacante, o simplemente comprometer la
integridad de los datos de los programas: hacerlos públicos, alterarlos, o simplemente
robarlos. (Jorba y Suppi, 2004)
Los Datos, ya sean estructurados, como en los servicios de base de datos, o gestión
de versiones (como cvs), o simples archivos. Mediante ataques que amenacen la
accesibilidad, pueden ser destruidos o eliminados, denegando así el acceso a los mismos.

73
En el caso de la confidencialidad, estaríamos permitiendo lecturas no autorizadas y la
integridad se vería afectada cuando se produzcan modificaciones o creación de nuevos
datos.
Algunas de las herramientas usadas para mejorar la seguridad del sistema y datos,
(Isaac, 2017) son:
• CIRClean: herramienta para unidades de almacenamiento USB que nos puede
ayudar a limpiar documentos en este tipo de unidades.
• Buttercup: gestor de contraseñas multiplataforma que nos ayudará a mantener
nuestros password seguros y a no olvidarnos de ellos.
• KeePaasXC: se trata de otra herramienta que ya tratamos en LxA, para
gestionar las contraseñas como la anterior, por tanto es una buena alternativa…
• LMD: son las siglas de Linux Malware Detect y como su nombre indica es un
escáner para ayudarnos a detectar malware que se puede ejecutar en sistemas
basados en Linux.
• Loki: se trata de un escáner de archivos para comprobar los llamados COI.
• ClamAV: es el famoso antivirus multiplataforma que permite escanear malware
y también añadir nuestras propias firmas, algo que no permiten los antivirus más
famosos con los que compite. No olvides complementarlo con anti-rootkits.
• BleachBit: otra de las herramientas de las que hemos hablado en este blog, una
herramienta para limpiar el sistema y mantener la privacidad, ya que puede
eliminar cookies, historiales, etc.
8.3 Descripción de algunos fallos de seguridad y protección en LINUX
Según (Ferrer y Fernandez, 2010), de una forma simplista los fallos de seguridad se
pueden sividir en tres bloques:

74
1. fallos debidos a errores desconocidos en el software, o conocidos sólo por
terceras entidades hostiles.
2. fallos debidos a errores conocidos pero no arreglados en la copia en uso del
software.
3. fallos debidos a una mala configuración del software, que introduce
vulnerabilidades en el sistema.
El primero de ellos se puede achacar a la calidad del código, el segundo a la
capacidad y celeridad de arreglo de los errores descubiertos en el código por parte del
proveedor del mismo y a la capacidad del administrador de recibir e instalar nuevas copias
de este software actualizado. El tercer tipo de vulnerabilidades puede achacarse, sin
embargo, a una falta de documentación del software o una falta de formación adecuada de
los administradores para hacer una adaptación correcta del mismo a sus necesidades.
Los fallos pueden dar lugar a un mal funcionamiento del programa, siendo en el
ámbito de la seguridad preocupantes por cuanto:
• pueden implementarse algoritmos de forma incorrecta lo que puede llevar a una
pérdida de seguridad (por ejemplo, un algoritmo de generación de claves que no
se base en números totalmente aleatorios).
• pueden diseñarse servicios que, en contra de sus especificaciones, ofrezcan
funcionalidades no deseadas o que puedan vulnerar la seguridad del servidor
que los ofrezca.
• pueden no haberse tomado las medidas de precaución adecuadas para asegurar
el correcto tratamiento de los parámetros de entrada, lo que puede hacer que un
atacante externo abuse de ellos para obligar al programa a realizar operaciones
indeseadas.

75
8.4 Comparación de algunos fallos de seguridad y protección con GNU/LINUX y
otros Sistemas Operativos
Según (Rico, 2002), lista una serie de argumentos a favor de LINUX en cuanto a la
seguridad:
1. En Windows hay muchos más virus que en Linux.
2. Se descubren muchos más agujeros de seguridad en Windows; sobre todo en lo
referente a la seguridad cuando navegamos por Internet.
3. Microsoft no le concede a la seguridad toda la importancia que se merece
porque si hiciera sus Sistemas Operativos más robustos y fiables, serían más
difíciles de manejar para los que no tienen idea de Informática.
4. Si alguien descubre un agujero de seguridad en cualquier versión de Linux,
cualquier programador habilidoso lo puede subsanar puesto que es de código
abierto. En cambio, en Windows habría que esperar a que los trabajadores en la
nómina de Microsoft lo hicieran, con la consabida pérdida de tiempo que
pondría en riesgo millones de ordenadores de todo el mundo.
5. Linux jamás permitiría productos tan "frágiles" como Outlook o Internet
Explorer que han de estar continuamente parchados. La profesionalidad está
reñida con la carencia de seguridad.
6. La propia estructura lógica sobre la que funciona Linux es más segura que la de
Windows.
Todos estos argumentos son, en mayor o menor medida, ciertos. Es una verdad, que
en Windows hay más virus que en Linux, pero preguntado a varios programadores de virus
por la razón, me aseveraban que las posibilidades de éxito en la propagación de un virus en
Linux son mínimas.
En primer término (y esto lo entendemos todos) es una cuestión cuantitativa y
después, de ingeniería social. ¿Qué quiere decir esto último? Pues que los usuarios de

76
Linux no son precisamente principiantes. Cuando alguien empieza lo hace con Windows. A
Linux van generalmente los más doctos en informática. Es más fácil engañar a un usuario
de Windows por término medio que a uno de Linux, por la misma razón que es más
sencillo que un principiante sea engañado que un experto.
También es lógico que se descubran más agujeros de seguridad en un producto de
consumo mayoritario que en otro mucho menos usado.
Además, en Windows hay una cuestión adyacente a la propia dialéctica técnica que
no debemos obviar: cuando hablamos de una transnacional poderosísima como Microsoft y
de un señor tan rico y divinizado como Bill Gates, se crea un halo de misticismo alrededor
que resulta muy atractivo para aquellos transgresores que desean retos gigantes.
CAPÍTULO 9.- DISCUSIÓN SOBRE LAS TENDENCIAS
9.1 Tendencias “free” u “Open” de LINUX
Hablar de programas (software) libre significa hablar de libre uso, libre estudio, libre
distribución y libre mejora.
Libre Uso - Puedes usar el programa para lo que quieras incluso para algo para el que
no ha sido diseñado frente a las restricciones que impone en este sentido los programas (el
Software) propietario.
Libre Estudio - De cómo funciona el programa y adaptarlo a tus propias
necesidades, es obligatorio el acceso al Código Fuente para que se cumpla. Esta libertad te
permite tener programas que realmente hacen lo que necesitas, te desliga de posiciones
comerciales que pueda tomar la empresa que haga el software, etc. Pero sobretodo te hace
partícipe de la inteligencia colectiva, de la colaboración a un nivel que nunca habíamos

77
pensado, de la posibilidad de dirigir realmente nuestras necesidades, de escuchar y ser
escuchadas.
Libre Distribución - Cualquier programa que sea libre puede ser copiado y
distribuido sin límites. No tendrás que verte inmersa en el círculo vicioso al que obliga el
copyright lesivo para con las libertades individuales. Ayuda a tu pareja, comparte con tu
vecina, regala y recibe conocimiento, cultura, información, sin barreras ni fronteras.
Libre Mejora - Cualquiera puede mejorar el programa, no hay una organización
central que dice qué debe hacerse y qué no, además de hacer públicas las mejoras para que
el resto de la comunidad pueda disfrutar de las mismas. Pasarás a confiar en la gente, no en
las marcas, con software libre usarás programas que ha hecho otra gente, sencilla como tú,
que aporta lo que puede y a la que puedes ayudar de manera directa, sin pasos intermedios.
Además de sentirte dentro de una comunidad que se ayuda entre sí, sin importar condición
ni persona, cualquier mejora es adoptada al instante por toda la comunidad, realmente una
prueba de que el esfuerzo colaborativo nos libera.
Software Libre frente a Código Abierto - No son la misma cosa, aunque nacieron a
la par. El movimiento Código abierto (Open Source en inglés) se crea por una sencilla
razón, en inglés "free" significa libre y gratis a la vez, y mucha gente cuando veía "Free
Software" (que es la traduccion de Software Libre) lo confundía con "Software Gratis",
siendo cosas totalmente diferentes. Usaron el término "Open Source" que en inglés evitaba
la confusión. El problema surgió cuando el movimiento "Código Abierto" empezó a dar
más importancia a la existencia del Código fuente, sin importar el que se ayude a la
comunidad al crear programas (no obliga a que los programas derivados sigan siendo
libres), sobre todo de cara a que el software de estas características tenga mayor calado en
el mundo empresarial.
La riqueza del mundo del software libre es la variedad de gustos que hay, cualquier
persona puede crear su propio sistema y ser su propia dueña, ahí radica una de las mayores

78
importancias de este movimiento. Para empezar a usar Software Libre se aconseja tener
claras las ventajas, se deja de ser usuarios, receptores, y se pasa a ser parte activa del
proceso.
9.2 Base instalada del Sistema Operativo LINUX
Según Garcia (2017), en el año 2017, la adopción de Linux se mantuvo estable en
torno a un 2 y un 2,3%. Esto convierte a los sistemas operativos basados en Linux los
terceros más utilizados por consumidores, por detrás de Windows con un 91,5% y Mac con
un 6,12%.
Gracias a ser compatible cada vez con más hardware, a sus actualizaciones de
seguridad constante, a haber mejorado su rendimiento en juegos (y que haya aumentado el
número que hay disponible), y a ser una alternativa libre y gratuita en la mayoría de distros,
Linux es una gran opción si queremos controlar hasta el mínimo detalle de nuestro sistema
operativo, así como no gastar en software y que todo sea de manera legal.
Entre las distribuciones más populares de Linux, encontramos Ubuntu. El sistema
operativo ganó popularidad cuando fue lanzado gracias a que enviaban el sistema en CD, y
que se publicitaban como una versión asequible de Linux para usuarios poco
experimentados. Su gran compatibilidad con todo tipo de hardware gracias a drivers
propietarios también es un gran aliciente.
Por ello, no es de extrañar que el sistema operativo se sitúe con un 38,9%
de cuota, seguido de Arch Linux con un 27,1 %. Con un enfoque más abierto,
encontramos a Debian en tercera posición con un 15,3% de cuota. En cuarta y
quinta posición, encontramos a Fedora con un 14,8% y a Linux Mint con un
10,8%. A partir de ahí, la cuota empieza a caer con SUSE, Gentoo y CentOS.

79
Figura 25. Distribuciones más populares de LINUX
9.3 Windows vs Mac vs Linux
NitroPC (2017), es su artículo ―Windows vs Mac vs Linux, ¿cuál se adaptará más a lo
que necesitas?‖, reseña lo siguiente:
En primera instancia, algunos quizás hayan entrado pensando que este
artículo iba a ser una competición entre sistemas operativos. Aunque en la vida
real compiten entre sí por tener su porción del mercado, nosotros queremos ir
más allá. No se trata de cuál es mejor o peor, porque todos son diferentes.
9.3.1 Mac OS
En cuanto oímos o leemos la palabra ‗Mac‘ es inevitable no pensar en
Apple. La compañía más grande de la historia llegó hasta lo más alto gracias a

80
sus Macintosh mucho antes de que el ipod o el iphone se les pasara por la
cabeza. Actualmente se usa la versión MAC OS X con el sistema e interfaz
conocido como El Capitán.
Ventajas
• Apple diseña tanto su software como su hardware, o utiliza el hardware de otras
compañías punteras. Esto asegura la calidad del hardware y que el software (es
decir, su sistema operativo) tengan una funcionalidad y compatibilidad
absolutas.
• Desde 2007 Apple permite la posibilidad de poner Windows en sus sobremesas.
• La interfaz de Mac OS es más sencilla de entender a primera vista.
• Como solamente el 12% del mercado está integrado por PCs con MAC OS, no
suelen ser el objetivo de hackers y virus, por lo que resultan ser equipos más
seguros.
• Su sistema operativo es más estable y muy raramente produce fallos o crasheos.
• Tiene programas propios muy buenos. Algunos para trabajos de edición, diseño
y creación.
• Es una buena ventaja que en accesorios como bluetooth, wifi u otros, ya vienen
integrados en los equipos, mientras que en los PCs habituales hay que
comprarlos a parte.
• En el caso de sus portátiles, las baterías son más duraderas que los portátiles
convencionales.
Desventajas
• Quizás la más grande de todas. Sus equipos y productos en general son
exageradamente caros. Estudios independientes del mercado tecnológico han
estimado que del precio final que paga un consumidor por un producto de
Apple, entre un 30% y un 35% es simplemente pagar ―la marca‖.
• Como su hardware es exclusivo, resulta casi imposible encontrarse con
alternativas genéricas. Eso hace que si se te rompe cualquier cable, accesorio o

81
componente, tendrás que pagar mucho más para sustituirlo. Por ejemplo, un
cable de alimentación para el iMac te puede costar la friolera de 20-25 euros,
mientras que uno de un PC normal no pasará de los 5 o 6 euros.
• Aunque es posible poner Windows en PCs de Apple, hay que decir que no es
una idea muy buena, ya que el equipo ve bastante reducida su velocidad y
eficacia si se tienen instalados los dos sistemas operativos.
• La interfaz no posee de configuraciones muy complejas y es la que menos
personalización posee de las tres.
• Mientras que su sistema operativo para móviles (iOS) sí se renueva y actualiza
cada poco tiempo, el MAC OS roza casi la obsolescencia. Su MAC OS X data
de 1.999, y aunque la última versión es del 2015, muchos elementos de su
software tienen más de una década y causa una sensación de ausencia de
innovación.
• No tiene compatibilidad con la mayoría de juegos como Windows, pero sí
posee más que Linux.
9.3.2 Windows
Sin duda, el sistema operativo más conocido y usado a nivel mundial. Se
estima que el 80% de los ordenadores de todo el planeta usan alguna versión de
Windows. A diferencia de Apple, Microsoft, su creadora, solo se ha ceñido al
desarrollo de este software. No fabrica equipos y son otras las marcas y
empresas cuyos PCs se sustentan de su sistema operativo.
Ventajas
• Al copar el 80% del mercado actual con su sistema operativo, tienes
prácticamente todo a tu alcance. Gran variedad de equipos y aditamientos para
prácticamente cualquier uso imaginable.
• Siguiendo el punto uno, lo mismo sucede con otros programas y aplicaciones.
Tienes disponibilidad y compatibilidad con casi todo el software existente.

82
• Muy fácil encontrar soluciones a tus problemas a través de Internet (foros,
webs, etc.). Desde mantener tu PC, limpiarlo de malware o formatear y
reinstalar el sistema operativo hasta instalación de periféricos o juegos,
encontrarás de todo, cosa no posible con los otros dos casos donde el catálogo
no es tan extenso.
• Es el más cómodo de usar para diversas actividades.
• Posee el mayor catálogo de compatibilidad y por lo tanto de juegos que existe.
Muy pocos juegos del mundo para PC no tienen versión para Windows.
• Al no fabricar sus equipos y funcionar en tantos tipos de hardware, da mucha
libertad. Puedes tener un Intel o un Ryzen, una Nvidia o una RX, un tipo de
RAM u otro y así con todo. A diferencia de Apple, tienes libertad total de
componentes y modificación.
• Al igual que Linux y a diferencia de Mac OS, es posible usar de forma gratuita
Windows, aunque sea en versión con limitaciones. Esto no limita el poder
jugar, navegar por Internet o trabajar con él.
• Cada pocos años (entre 2 y 4) salen nuevos sistemas operativos de Windows.
Dentro de estos mismos, encuentras Service Packs (versiones actualizadas)
dando la sensación de avance constante.
Desventajas
• Tener casi todo el control del sector no es bueno para todo. Los hackers y
crackers, virus, troyanos, gusanos, espías y malware de cualquier tipo acechan
todo el tiempo a los equipos con Windows. Es el sistema operativo más atacado
y más peligroso.
• Aunque el antivirus ‗Essential‘ de Windows 10 es el mejor que ha tenido nunca
antes, sigue siendo muy vulnerable. Se necesitan de otros programas, gratuitos
o de pago, para poder proteger correctamente el equipo.
• Teniendo en cuenta que Mac Os va incluido ya en el precio del PC de Apple y
que Linux es gratuito (o como mucho pagar por el CD), la licencia de Windows

83
es considerablemente cara, llegando a ser ridícula en versiones como el Pro
(profesional) que llega a los 200 euros (y eso que ahora controlan los precios,
hace años veías Office o versiones Ultimate por 400 euros).
• El software es de corte degenerativo. Con esto queremos decir que aunque bien
mantenido puede durar años, al final se vuelve tan lento e insufrible que tienes
que formatear. Se sabe de gente que tiene Linux o Mac desde hace más de una
década y el PC les funciona casi como el primer día. Esto con Windows es
sumamente difícil.
• El constante avance está bien, aunque puede resultar molesto. Los cambios de
interfaz que hace Microsoft cada pocos años enfada a muchos usuarios. Además
te encuentras con que cada vez que saca un nuevo sistema operativo, tu
hardware se queda medio obsoleto (u obsoleto del todo) para poder disfrutarlo
correctamente.
• Tienes que saber mantenerlo y usar programas para ello. De no ser así el
ordenador ya no solo se ralentizará, si no que aparecerán mensajes de alerta o
de error con cada vez más frecuencia. Es el más inestable de los 3.
9.3.3 Linux
El más desconocido y menos usado de los tres. Creado por un finlandés
en la universidad de Helsinki en 1991, tiene muchos más años de lo que nos
creemos. Desde entonces muchas versiones y mejoras han salido al público.
No os engañéis porque las capacidades de este sistema operativo son
amplísimas. De hecho pegó un ‗boom‘ cuando titanes industriales comenzaron
a usar Linux en sus equipos y productos. El ejemplo más notorio podría ser el
de Sony con su Play Station. En los últimos años está copando cada vez más
cuota de mercado y eso se debe a que poco a poco se va simplificando su uso.
Si con el tiempo se convierte en un Windows con las bondades que ya tiene,
podría ser un duro competidor en el sector.

84
Ventajas
• Es el más barato, siendo prácticamente gratuito.
• Dispone de la mayor red de software libre existente. ¿Qué significa esto? Que
con Mac OS o Windows casi todas las aplicaciones, programas y todo el
software en general hay que pagarlo. Ya sea comprar la versión premium, pro,
senior, full o como le quieran llamar, tienes que pagar. Con Linux esto no se ve
muy a menudo, pudiendo descargar las cosas de forma gratuita.
• Bien programado y mantenido, es el más estable de los tres (por encima de Mac
OS).
• Es el sistema operativo que menos recursos consume y por lo tanto otorga
mayor rendimiento. Es por esto que muchas empresas lo utilizan para gestionar
y llevar servidores.
• Las vulnerabilidades son detectadas y corregidas más rápidamente que en
cualquier otro sistema operativo.
Desventajas
• No tiene casi nada de software comercial. El software libre está muy bien
aunque en la mayoría de los casos es muy simple.
• Casi el 90% de los juegos actuales no funcionan en Linux. Es de los tres, el
sistema operativo más incompatible en este aspecto.
• Muy difícil (prácticamente imposible) encontrar un soporte ante problemas.
Tendrás que arreglarlos por ti mismo y/o con ayuda de tutoriales creados por la
comunidad.
• Quizás la peor de todas, la necesidad de saber Unix. No es extraño ver a un
usuario de Linux ponerse a escribir líneas de códigos para poder acceder o usar
programas, cosa que para el común de los usuarios resulta de lo más engorroso.
Escoge la que más se adapte. Una vez vistas las ventajas y desventajas de cada sistema
operativo, ya puedes decidir. Al final la última palabra, la tienes tú. Una cosa está clara,
ningún sistema operativo es perfecto.

85
PARTE 3. DISTRIBUCIONES DE LINUX
CAPÍTULO 10.- DISTRIBUCIÓN CANAIMA
10.1 Distribución Canaima
Como lo cita el portal del Ministerio del Poder Popular para Educacion Universitaria,
Ciencia y Tecnologia (2016), CANAIMA, es una tecnología diseñada pensando en las
necesidades y realidades del servidor público venezolano, orientado a los procesos de la
Administración Pública, en apoyo a su automatización con Software Libre, siendo éste una
alternativa al modelo dependiente tradicional y haciendo frente a un mercado cercado por
las grandes corporaciones en su mayoría trasnacionales.
Canaima comprende herramientas y métodos para avanzar hacia la independencia
tecnológica al servir como plataforma de encuentro para desarrolladores y usuarios
envueltos en la gestión de tecnologías de información con pertinencia en nuestro Proyecto
Nacional. Canaima es Software Libre, lo cual implica una nueva ética de consumo,
producción y relacionamiento económico en torno a las tecnologías.
Desde sus inicios el 18 de octubre de 2007, mucha ha sido la evolución del Proyecto
CANAIMA y con él, el desarrollo de diversos sabores y versiones del sistema de operación,
enfocándose hoy en día en servir como herramienta desarrollada para la Administración
Publica.
Canaima es una distribución GNU/Linux venezolana basada en Debian, surgida como
consecuencia del Decreto presidencial N° 3.390 sobre el uso de Tecnologías de
Información Libres en la Administración Pública Nacional (APN) venezolana, promulgado
por el Presidente Hugo Chávez Frías.

86
El 14 de marzo de 2011 en la Gaceta Oficial N° 39.632 se establece como sistema
operativo para las estaciones de trabajo de la APN.
10.1.1 Origen
Según Aponte y Orteha (2008), La distribución Canaima nace gracias al artículo 7 del
decreto 3390, y es gracias a la resolución ministerial nro. 025 que convierte en la
distribución oficial de software libre de la administración pública venezolana. Antes de este
decreto Canaima no existía, por lo que para el momento en que sale en gaceta, y la fecha
tope en la que debía ser aplicada la migración al software libre se tenía que decidir qué
hacer; inicialmente se consideró crear una distribución nacional desde cero, pero esto, a
pesar de implicar una obtención tremenda de conocimientos, implicaba un esfuerzo
tremendo; en contraposición, si se usaba una distribución ya existente, no se obtendría
mucho conocimiento, pero el esfuerzo será mínimo. Analizando esta situación se decidió
tomar una distribución estable, de calidad, que no estuviese ligada a ninguna empresa, que
tuviese un buen contrato social y un compromiso con la libertad de software como base,
siendo esta Debian, y adaptarla a las necesidades de los venezolanos.
Es de esta forma cómo surge el proyecto Canaima, el encargado de la generación,
mantenimiento y evolución de la distribución, una forma de juntar a personas de todo el
territorio nacional, así como instituciones y empresas interesadas en colaborar con el
desarrollo del software. Buscando así la formación de una comunidad nacional solida y
numerosa, capaz de generar una distribución de calidad, adaptada a las necesidades
nacionales y son sabor venezolano. Canaima 1.0 es realizada como una remasterización de
Debian por un equipo de 6 personas del CNTI y el M.Cs. Ernesto Hernandéz-Novich en un
tiempo de menos de un mes, siendo finalmente liberada el 17 de octubre del año 2007.
Es necesario mencionar que no es considerada como software libre por la Free
Software Foundation, debido a que incluye cierto software privativo de ciertas compañías
desarrolladoras del hardware usado en la administración publica nacional, las cuales a pesar

87
de estar dispuestas a colaborar con el proyecto Canaima, no están dispuestas a dar su
código fuente.
10.1.2 Ciclo de Desarrollo
CANAIMA GNU/LINUX posee un modelo de desarrollo basado en Debian, con
algunas modificaciones para adaptarla a las necesidades propias de Venezuela.
• Comunidad socio-productiva: integrada por la comunidad de Software Libre
(SL), entes de la Administración Pública Nacional (APN), colectivos
organizados y universidades públicas.
• Herramientas de apoyo a productores, entre ellas: Sistema de Gestion de
Proyectos de Software Libre.
• Herramienta para la gestión de incidentes, centrada en el desarrollador Canaima
ubicada en: http://trac.canaima.softwarelibre.gob.ve/
• Etapa de consolidación y pruebas automatizadas: las cuales se basan en pruebas
de calidad al software y criterios de evaluación; esta etapa usa intensivamente
herramientas informáticas de Debian.
• Al finalizar el ciclo del producto se libera la versión estable de Canaima.
10.1.3 Lanzamientos de la Distribución CANAIMA
Tabla 7. Lanzamientos CANAIMA GNU/LINUX
Versión Nombre en clave Fecha de lanzamiento
1.0 Canaima 18 de octubre de 2007
2.0 Canaima 05 de febrero de 200917
2.0.1 RC1 Canaima 16 de abril de 200918
2.0.1 Canaima 15 de mayo de 200919

88
2.0.2 Canaima 22 de mayo de 2009
2.0.3 Canaima 03 de julio de 200920
2.0.4 Canaima 17 de octubre de 2009
2.1 RC Canaima 21 de mayo de 201021
3.0 RC Roraima 10 de febrero de 201122
3.0 RC2 Roraima 22 de febrero de 201123
3.0 Roraima 05 de mayo de 2011
3.1 VC1 Auyantepui 29 de diciembre de 201124
3.1 VC2 Auyantepui 06 de julio de 201225
3.1 VC3 Auyantepui 18 de julio de 201226
3.1 Auyantepui 14 de noviembre de 201227
4.0 Kerepakupai 4 de diciembre de 201328
4.1 Kukenán 4 de septiembre de 2014
5.0 Chimantá 19 de diciembre de 201629
5.1 Chimantá 7 de septiembre de 201730
6.0 Kavac 20 de marzo de 2018
Fuente: Ministerio del Poder Popular para Educacion Universitaria,
Ciencia y Tecnologia, 2016
Color Significado
Rojo Versión antigua; sin soporte
Amarillo Versión antigua; con soporte.
Verde Versión actual; con soporte.

89
10.1.4 Usos de la Distribución Canaima
Canaima Educativo
Es un proyecto iniciado en el año 2009 por el Ministerio del Poder Popular para la
Educación del gobierno de la República Bolivariana de Venezuela que consiste en proveer
gratuitamente a los estudiantes de educación básica de un computador, conocido
popularmente como Canaimita, que tiene como sistema operativo a Canaima GNU/Linux y
una serie de contenidos educativos creados por el Ministerio del Poder Popular para
Educación.
En el año 2011 se entregaron 1.314.091 computadoras. En septiembre de 2012 se
entregó la Canaimita número 2 millones. Hasta el 21 de marzo del año 2013 se han
entregado 2.452.337 Canaimitas a los niños que cursan Educación Primaria. Más
recientemente, el Gobierno de Venezuela inició la entrega 2,5 millones de computadoras a
estudiantes de las instituciones públicas de bachillerato. En abril de 2014 ya se han
entregado 3.300.000 computadoras Canaima a niños y jóvenes de educación básica y
media.
En resumen, desde el año 2009 hasta 2015 se han entregado 3.563.081 canaimitas.
Canaima en Organismos Publicos.
Citado por Gallegos (2011), ―los Organismos y entes de la administración pública
nacional de la República Bolivariana de Venezuela deberán utilizar Canaima GNU/Linux
como programa informático de sus estaciones de trabajo, tal y como lo estableció el
Ministerio del Poder Popular para Ciencia, Tecnología e Industrias Intermedias en Gaceta
Oficial Nº 39.633 de fecha lunes 14 de marzo.
Canaima GNU/Linux es un proyecto socio-tecnológico abierto centrado en el
desarrollo de herramientas y modelos productivos basados en las Tecnologías de
Información Libres (TIL) de software y sistemas operativos, que tienen como finalidad

90
generar capacidades nacionales, desarrollo endógeno, apropiación y promoción del libre
conocimiento, sin perder su motivo original: la construcción de una nación venezolana
tecnológicamente preparada.
La finalidad de esta resolución es homogenizar y fortalecer la plataforma tecnológica
del Estado venezolano, dando cumplimiento al marco legal vigente.
De acuerdo con el artículo cuatro de la referida Gaceta Oficial, los órganos y entes
públicos que hayan migrado total o parcialmente su sistema operativo de sus equipos
informáticos de computación a una distribución GNU/Linux distinta a la Canaima, deberán
consignar al Centro Nacional de Tecnologías de Información (CNTI), en un plazo no
superior a seis meses, un informe técnico que contenga un plan de convergencia con el
conjunto de paquetes mínimos de herramientas informáticas (Meta-distribución) para que el
software libre Canaima GNU/Linux pueda funcionar en sus estaciones de trabajo.
En la actualidad, Canaima impulsa grandes proyectos nacionales tanto en el ámbito
público como privado, entre los que se encuentran el Proyecto Canaima Educativo, el Plan
Internet equipado de CANTV, entre otros.‖
CAPÍTULO 11 DISTRIBUCIÓN DE LINUX MAS UTILIZADA
11.1 Distribución Ubuntu
11.1.1 Descripción.
Ubuntu es una distribución Linux que ofrece un sistema operativo
predominantemente enfocado a ordenadores de escritorio aunque también proporciona
soporte para servidores.

91
Basada en Debian GNU/Linux, Ubuntu concentra su objetivo en la facilidad de uso,
la libertad en la restricción de uso, los lanzamientos regulares (cada 6 meses) y la facilidad
en la instalación. Ubuntu es patrocinado por Canonical Ltd., una empresa privada fundada y
financiada por el empresario sudafricano Mark Shuttleworth.
El nombre de la distribución proviene del concepto zulú y xhosa de ubuntu, que
significa ―humanidad hacia otros‖ o ―yo soy porque nosotros somos‖. Ubuntu es un
movimiento sudafricano encabezado por el obispo Desmond Tutu, quien ganó el Premio
Nobel de la Paz en 1984 por sus luchas en contra del Apartheid en Sudáfrica. El
sudafricano Mark Shuttleworth, mecenas del proyecto, se encontraba muy familiarizado
con la corriente. Tras ver similitudes entre los ideales de los proyectos GNU, Debian y en
general con el movimiento del software libre, decidió aprovechar la ocasión para difundir
los ideales de Ubuntu. El eslogan de Ubuntu – ―Linux para seres humanos‖ (en inglés
―Linux for Human Beings‖) – resume una de sus metas principales: hacer de Linux un
sistema operativo más accesible y fácil de usar. La versión más reciente la versión 7.04
(Feisty Fawn) fue lanzada el 19 de abril de 2007.
11.1.2 Historia
Según Facundo Arena, en su libro ―La Biblia de LINUX‖:
Mark Shuttleworth de la Fundación Ubuntu en la WSIS 2005 de Túnez.
El 8 de julio de 2004, Mark Shuttleworth y la empresa Canonical Ltd. anunciaron la
creación de la distribución Ubuntu. Ésta tuvo una financiación inicial de 10 millones de
dólares (US$). El proyecto nació por iniciativa de algunos programadores de los proyectos
Debian, Gnome porque se encontraban decepcionados con la manera de operar del proyecto
Debian, la distribución Linux sin ánimo de lucro más popular del mundo.
De acuerdo con sus fundadores, Debian era un proyecto demasiado burocrático donde
no existían responsabilidades definidas y donde cualquier propuesta interesante se ahogaba
en un mar de discusiones. Asimismo, Debian no ponía énfasis en estabilizar el desarrollo de

92
sus versiones de prueba y sólo proporcionaba auditorías de seguridad a su versión estable,
la cual era utilizada sólo por una minoría debido a la poca o nula vigencia que poseía en
términos de la tecnología Linux actual.
Tras formar un grupo multidisciplinario, los programadores decidieron buscar el
apoyo económico de Mark Shuttleworth, un emprendedor sudafricano que vendió la
empresa Thawte a VeriSign, cuatro años después de fundarla en el garaje de su domicilio,
por 575 millones de dólares estadounidenses.
Shuttleworth vio con simpatía el proyecto y decidió convertirlo en una iniciativa
autosostenible, combinando su experiencia en la creación de nuevas empresas con el talento
y la experiencia de los programadores de la plataforma Linux. De esta forma nació la
empresa Canonical, la cual se encarga de sostener económicamente el proyecto mediante la
comercialización de servicios y soporte técnico a otras empresas. Mientras los
programadores armaban el sistema, Shuttleworth aprovechó la ocasión para aplicar una
pequeña campaña de mercadotecnia para despertar interés en la distribución sin nombre (en
inglés: the no-name-distro).
Tras varios meses de trabajo y un breve período de pruebas, la primera versión de
Ubuntu (Warty Warthog) fue lanzada el 20 de octubre de 2004.
11.1.3 Características de Ubuntu
• Basada en la distribución Debian.
• Disponible en 4 arquitecturas: Intel x86, AMD64, SPARC (para esta última sólo
existe la versión servidor).
• Los desarrolladores de Ubuntu se basan en gran medida en el trabajo de las
comunidades de Debian y GNOME.
• Las versiones estables se liberan cada 6 meses y se mantienen actualizadas en
materia de seguridad hasta 18 meses después de su lanzamiento.

93
• La nomenclatura de las versiones no obedece principalmente a un orden de
desarrollo, se compone del dígito del año de emisión y del mes en que esto
ocurre. La versión 4.10 es de octubre de 2004, la 5.04 es de abril de 2005, la
5.10 de octubre de 2005, la 6.06 es de junio de 2006, la 6.10 es de octubre de
2006 y la 7.04 es de abril de 2007.
• El entorno de escritorio oficial es Gnome y se sincronizan con sus liberaciones.
• Para centrarse en solucionar rápidamente los bugs, conflictos de paquetes, etc.
se decidió eliminar ciertos paquetes del componente main, ya que no son
populares o simplemente se escogieron de forma arbitraria por gusto o sus bases
de apoyo al software libre. Por tales motivos inicialmente KDE no se encontraba
con más soporte de lo que entregaban los mantenedores de Debian en sus
repositorios, razón por la que se sumó la comunidad de KDE distribuyendo la
distro llamada Kubuntu.
• De forma sincronizada a la versión 6.06 de Ubuntu, apareció por primera vez la
distribución Xubuntu, basada en el entorno de escritorio XFce.
• El navegador web oficial es Mozilla Firefox.
• El sistema incluye funciones avanzadas de seguridad y entre sus políticas se
encuentra el no activar, de forma predeterminada, procesos latentes al momento
de instalarse. Por eso mismo, no hay un firewall predeterminado, ya que no
existen servicios que puedan atentar a la seguridad del sistema.
• Para labores/tareas administrativas en terminal incluye una herramienta llamada
sudo (similar al Mac OS X), con la que se evita el uso del usuario root
(administrador).
• Mejora la accesibilidad y la internacionalización, de modo que el software está
disponible para tanta gente como sea posible. En la versión 5.04, el UTF-8 es la
codificación de caracteres en forma predeterminada.
• No sólo se relaciona con Debian por el uso del mismo formato de paquetes deb,
también tiene uniones muy fuertes con esa comunidad, contribuyendo con
cualquier cambio directa e inmediatamente, y no solo anunciándolos. Esto
sucede en los tiempos de lanzamiento. Muchos de los desarrolladores de Ubuntu

94
son también responsables de los paquetes importantes dentro de la distribución
de Debian.
• Todos los lanzamientos de Ubuntu se proporcionan sin costo alguno. Los CDs
de la distribución se envían de forma gratuita a cualquier persona que los
solicite mediante el servicio ShipIt (la versión 6.10 no se llegó a distribuir de
forma gratuita en CD, pero la versión 7.04 sí). También es posible descargar las
imágenes ISO de los discos por transferencia directa o bajo la tecnología
Bittorrent.
• Ubuntu no cobra honorarios por la suscripción de mejoras de la ―Edición
Enterprise‖.
11.1.4 Organización de paquetes.
Sistema de gestión de paquetes Synaptic.
Ubuntu divide todo el software en cuatro secciones, llamadas componentes, para
mostrar diferencias en licencias y la prioridad con la que se atienden los problemas que
informen los usuarios . Estos componentes son: main, restricted, universe y multiverse.
Por defecto, se instala una selección de paquetes que cubre las necesidades básicas de
la mayoría de los usuarios de computadoras. Los paquetes de Ubuntu generalmente se
basan en los paquetes de la rama inestable (Sid) de Debian.
El componente main
El componente main contiene solamente los paquetes que cumplen los requisitos de
la licencia de Ubuntu, y para los que hay soporte disponible por parte de su equipo. Éste
está pensado para que incluya todo lo necesario para la mayoría de los sistemas Linux de
uso general. Los paquetes de este componente poseen ayuda técnica garantizada y mejoras
de seguridad oportunas.

95
El componente restricted
El componente restricted contiene el programa soportado por los desarrolladores de
Ubuntu debido a su importancia, pero que no está disponible bajo ningún tipo de licencia
libre para incluir en main. En este lugar se incluyen los paquetes tales como los
controladores propietarios de algunas tarjetas gráficas, como por ejemplo, los de nVIDIA.
El nivel de la ayuda es más limitado que para main, puesto que los desarrolladores puede
que no tengan acceso al código fuente.
El componente universe
El componente universe contiene una amplia gama del programa, que puede o no
tener una licencia restringida, pero que no recibe apoyo por parte del equipo de Ubuntu.
Esto permite que los usuarios instalen toda clase de programas en el sistema guardándolos
en un lugar aparte de los paquetes soportados: main y restricted.
El componente commercial
Como lo indica su clasificación, contiene programas comerciales.
El componente multiverse
Finalmente, se encuentra el componente multiverse, que contiene los paquetes sin
soporte debido a que no cumplen los requisitos de Software Libre.
11.1.5 Variantes
Existen diversas variantes de Ubuntu disponibles, las cuales poseen lanzamientos
simultáneos con Ubuntu. Las más significativas son:
• Kubuntu, el cual utiliza KDE en vez de GNOME.
• Edubuntu, diseñado para entornos escolares.
• Xubuntu, el cual utiliza el entorno de escritorio Xfce.

96
Kubuntu, Edubuntu y Xubuntu son proyectos oficiales de la Ubuntu Foundation.
Kubuntu y Edubuntu se encuentran incluidos dentro del programa ShipIt.
Mark Shuttleworth también ha apoyado la creación de una distribución derivada de
Ubuntu que utilizaría sólo software aprobado por la Free Software Foundation.[12]
Hasta
ahora no ha sido lanzada ninguna versión oficial de ‗Ubuntu-Libre‘, debido a dificultades
en la gestión de paquetes de software. gNewSense, un proyecto algo similar al propuesto
‗Ubuntu-Libre‘, fue lanzado el 2 de noviembre de 2006. Sin embargo, no es una versión
oficial de Ubuntu.
 Kubuntu
 Edubuntu
 Xubuntu
 Ubuntu Studio
 Proyectos no oficiales para Familia Ubuntu
 GNU/Linux
 Software Libre
 Linux
 Debian GNU/Linux
11.1.6 Diferencia entre Ubuntu Server y Escritorio
Una de las distribuciones más usadas en ambientes Linux es sin lugar a dudas gracias
a su diseño, sencillez de uso, entornos y capacidad de gestión que logramos con ella. Como
la mayoría de los sistemas operativos han desarrollado una línea enfocada a las
organizaciones llamada Ubuntu Server y otra línea dedicada a los equipos cliente o usuarios
de hogar llamada Ubuntu Desktop.

97
Cada una de estas distribuciones ha sido desarrollada con funciones específicas y
existen diferencias entre ellas que marcan una pauta en su diseño así como existen
características que tienen ambos sistemas.
Analizaremos en detalle estas diferencias entre ambos sistemas operativos y
podremos comprobar porque Ubuntu es la distro más conocida de Linux. Para descargar
estas ediciones de Ubuntu podemos ir al siguiente enlace.
En primer lugar debemos conocer que Ubuntu no solo ha sido lanzado en dos
ediciones, Desktop y Server, sino que encontramos algunas otras distros como:
 Kubuntu basada en Kde.
 Xubuntu basada en Xfce.
 Edubuntu diseñada para entornos educativos.
 Ubuntu Studio enfocada en contenido multimedia.
Aparte de estas versiones contamos con dos tipos de soporte:
 Versiones estables las cuales cuentan con un soporte de hasta un año y medio.
 LTS (Long Term Service) con un soporte de hasta cinco años.
Recordemos que el soporte es el tiempo durante el cual seguiremos recibiendo
actualizaciones tanto del núcleo como del sistema operativo. Podemos resumir Ubuntu
Desktop y Ubuntu Server en lo siguiente:
Ubuntu Desktop es un sistema que por defecto viene con múltiples aplicaciones de oficina,
sistema, multimedia enfocadas en un entorno grafico que tras cada actualización presenta
mejoras

98
Ubuntu Server es un sistema que ofrece por defecto una interfaz de línea de
comandos mediante la cual podemos instalar aplicativos enfocados al desarrollo y
administración de una organización como MySQL, Apache, Python, entre muchos otros.
Es importante aclarar en este punto que mientras Ubuntu Server se instala con lo
mínimo debido a su interfaz en Ubuntu Desktop encontramos una serie de aplicaciones
preinstaladas como.
 Gedit: Editores de texto.
 Firefox: Navegador de Internet.
 LibreOffice: Suite ofimática.
 Empathy: Administrador de mensajería.
 Thunderbird: Cliente de correo.
Ya en Ubuntu Server podremos instalar aplicaciones como:
 DNS server: Gestor de DNS (Domain Name Server).
 LAMP server: Permute la instalación de Linux/ Apache/ MySQL o MariaDB/ PHP
 Servidor de correo: Esta opción permite que Ubuntu Server gestione los correos de
la organización
 Servidor OpenSSH: Permite que la comunicación SSH sea efectiva
 Base de datos PostgreSQL: Permite la configuración de clientes y servidores
PostgreSQL.
 Servidor de impresión: Gracias a este rol Ubuntu Server controlara todos los
servicios de impresión.
 Servidor Samba: Permite la transferencia de archivos entre diversos sistemas de
forma segura y compatible
 Podemos observar como cada edición tiene sus programas con un enfoque diferente.

99
CONCLUSIÓN
Linux es un producto estable, confiable y robusto, desafortunadamente aun así es
apartado o desplazado por otros sistemas por personas y profesionales más aun por
personas que toman decisiones. Aunque a pasar de los años su capacidad y mejora para las
funciones de servidores que son excelentes muchas distribuciones han avanzado en el
modelo de escritorio el cual es cada vez más amigable y versátil.
Linux existe la misma diversidad de aplicaciones que para Windows, e incluso, hay
programas como el Star Office u Openoffice que son capaces de leer documentos hechos en
Word. Mucha gente tiene la idea de que Linux es mucho más difícil de usar que Windows,
pero esto es un concepto totalmente erróneo, y si bien esto fueron cierto algunos años atrás,
ahora el panorama es totalmente distinto; Porque hoy en día existen múltiples aplicaciones
para este sistema operativo.
Cada vez somos más los que vemos las facilidades que nos brinda Linux el soporte de
varias distribuciones su estabilidad como servidor y ahora como escritorio de trabajo ha
ahorrado millones en soporte técnico, en desarrollo de software que aunque a bajo costo
son competitivos y algunos muchos mejores que sus similares en propietarios.
―Si compila está bien, si echa andar perfecto‖. Linus Torvalds

100
REFERENCIAS BIBLIOGRÁFICAS
Aponte, C., & Orteha, G. (2008). CANAIMA, GNU/LINUX. Caracas.
Equipo Debian GNU/Linux. (2013). Guía de instalación de Debian GNU/Linux.
Recuperado el 05 de Febrero de 2019, de Guía de instalación de Debian
GNU/Linux: https://www.debian.org/releases/wheezy/i386/index.html.es
Facundo Arena, H. (s.f.). La Biblia de LINUX. MP Ediciones.
Ferrer, J., & Fernandez, J. (2010). El Sistema Operativo GNU/LINUX y sus herramientas
libres en el mundo de la seguridad: Estudio del estado del arte.
Gallegos, I. (Noviembre de 2011). SISTEMA OPERATIVO CANAIMA EN ORGANISMOS
PUBLICOS. Recuperado el Febrero de 2019 de 15, de SISTEMA OPERATIVO
CANAIMA EN ORGANISMOS PUBLICOS.: 08
Garcia, A. (10 de Julio de 2017). Distros de LINUX más utilizados en 2017. Recuperado el
06 de Febrero de 2019, de Distros de LINUX más utilizados en 2017:
https://www.adslzone.net/2017/07/10/cuales-son-las-distros-de-linux-mas-
utilizadas-en-2017/
GrULiC. (2011). Grupo de Usuarios de Software Libre de Córdoba. Recuperado el 05 de
Febrero de 2019, de Grupo de Usuarios de Software Libre de Córdoba:
http://www.grulic.org.ar/node/11
Isaac. (10 de Octubre de 2017). Herramientas de seguridad para GNU/Linux para el día a
día. Recuperado el 06 de Febrero de 2019, de Herramientas de seguridad para
GNU/Linux para el día a día: https://www.linuxadictos.com/herramientas-
seguridad-gnulinux-dia-dia.html
Jorba, J., & Suppi, R. (2004). Administración avanzada de GNU/Linux. Barcelona.
Josiah, A. (09 de Noviembre de 2016). Características del procesador Intel Core i7.
Recuperado el 05 de Febrero de 2019, de Techlandia:
https://techlandia.com/caracteristicas-del-procesador-intel-core-i7-info_210058/
Marcano, Y., & Yendiz, N. (2015). Sistema Operativo GNU/LINUX. Barcelona.
Ministerio de Educación Cultura y Deporte. (25 de Febrero de 2008). Seguridad Básica en
LINUX. Recuperado el 06 de Febrero de 2019, de Seguridad Básica en LINUX:

101
http://recursostic.educacion.es/observatorio/web/en/software/software-general/562-
elvira-misfud-
Ministerio del Poder Popular para Educacion Universitaria, Ciencia y Tecnologia. (2016).
CANAIMA, Metadistribución GNU/LINUX. Recuperado el 08 de Febrero de 2019,
de CANAIMA, Metadistribución GNU/LINUX:
https://canaima.softwarelibre.gob.ve/canaima/que-es-canaima
NitroPC. (05 de Octubre de 2017). Windows vs Mac vs Linux, ¿cuál se adaptará más a lo
que necesitas? Recuperado el 06 de Febrero de 2019, de Windows vs Mac vs Linux,
¿cuál se adaptará más a lo que necesitas?: https://www.nitro-pc.es/blog/windows-
vs-mac-vs-linux/
Rico, M. (26 de Julio de 2002). ¿Es más seguro Linux que Windows? Recuperado el 06 de
Febrero de 2019, de http://www.vsantivirus.com/mr-linux-windows.htm
Sgr, T. (15 de Septiembre de 2016). Especificaciones VIT. Recuperado el 05 de Febrero de
2019, de Especificaciones VIT: http://vitspecs.blogspot.com/2016/09/equipo-de-
escritorio-vit-e2220-03.html
Silberschatz, A., & Galvin, P. B. (1999). Sistemas Operativos 5ya Edición. Mexico:
Pearson.
Tanenbaum, A. S. (2009). Sistemas Operativos Modernos 3era Edición. Mexico: Pearson.
Wolf, G., Ruiz, E., Bergero, F., & Meza, E. (2015). Fundamentos de Sistemas Operativos.
Mexico: UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO.
Silberschatz, A., & Galvin, P. B. (1999). Sistemas Operativos 5ya Edición. Mexico:
Pearson.
Stalligs, W. (2005). Sistemas Operativos. Madrid: Pearson.
Tanenbaum, A. S. (2009). Sistemas Operativos Modernos 3era Edición. Mexico: Pearson.
Wolf, G., Ruiz, E., Bergero, F., & Meza, E. (2015). Fundamentos de Sistemas Operativos.
Mexico: UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO.
Zabaljáuregui, M. (2011). Concurrencia y mecanismos de sincronización.

Sistema Operativo Linux

Más contenido relacionado

La actualidad más candente (20)

Similar a Sistema Operativo Linux (20)

Último (20)

Sistema Operativo Linux