Manual de Practicas SO

MANUAL DE PRÁCTICAS

INGENIERÍA EN SISTEMAS COMPUTACIONALESPLAN ISIC-2010-224

SISTEMAS OPERATIVOS I

AEC-1061

ÍndiceINTRODUCCIÓN …...........................................................................................................................................................1

Práctica 1.............................................................................................................................................................................2

EL DESPACHADOR DE PROCESOS Y MANEJADOR DE INTERRUPCIONES.....................................................2

Práctica 2.............................................................................................................................................................................5

PROBLEMA DE LA CENA DE LOS FILÓSOFOS.......................................................................................................5

Práctica 3.............................................................................................................................................................................9

COMO CONSUMEN RECURSOS LOS PROCESOS....................................................................................................9

Práctica 4...........................................................................................................................................................................15

LLAMANDO AL SISTEMA.........................................................................................................................................15

Práctica 5...........................................................................................................................................................................20

Arboles............................................................................................................................................................................20

Práctica 6...........................................................................................................................................................................26

RECOMPILANDO EL NUCLEO..................................................................................................................................26

8.- LISTA DE MATERIAL, EQUIPO O REACTIVO A UTILIZAR...............................................................................31

9.- LISTA DE BIBLIOGRAFÍA REQUERIDA................................................................................................................31

10.- CONTROL DE CAMBIOS DEL MANUAL DE PRÁCTICAS................................................................................32

Sistemas Operativos [AEC-1061]

INTRODUCCIÓN

Los sistemas operativos son un conjunto de tareas definidas que permiten la

interacción entre los dispositivos así como también con usuario, por esto es que se

definieron las siguientes prácticas con el fin de identificar partes importantes del

sistema operativo, y así tener una visión más clara de la ejecución de tareas, como

también las arduas tareas que realiza el sistema operativo.

Fecha de Actualización 22/08/2013 Página 1


Práctica 1

EL DESPACHADOR DE PROCESOS Y MANEJADOR DE INTERRUPCIONES

Observaciones: Esta práctica incluye a las Prácticas # 1 y # 2 del temario de Sistemas Operativos I que dicen “Identificar en el laboratorio, los elementos fundamentales del código fuente, para los módulos del núcleo del sistema; señalando los que corresponden al despachador de procesos y al manejador de interrupciones.” Y “Identificar en el laboratorio, los códigos fuente que corresponden al manejo de interrupciones y de intercomunicación entre procesos. (IPC).”.

1.-OBJETIVO

El alumno aprenderá, comprenderá e identificara de LINUX KERNEL, el código donde se encuentra programado el despachador de procesos, así como también el manejador de interrupciones, con el propósito de empezar a profundizar en el sistema operativo basado en LINUX

2.- MARCO TEÓRICO

Kernel/Núcleo

Que es el kernel/núcleo?

El kernel o núcleo de Linux se puede definir como el corazón de este sistema operativo. Es el encargado de que el software y el hardware de tu ordenador puedan trabajar juntos.Las funciones más importantes del mismo, aunque no las únicas, son:Administración de la memoria para todos los programas y procesos en ejecución.Administración del tiempo de procesador que los programas y procesos en ejecución utilizan.Es el encargado de que podamos acceder a los periféricos/elementos de nuestro ordenador de una manera cómoda.

Hasta que empezó el desarrollo de la serie 2.6 del núcleo, existieron dos tipos de versiones del núcleo:Versión de producción: La versión de producción, era la versión estable hasta el momento. Esta versión era el resultado final de las versiones de desarrollo o experimentales.

Cuando el equipo de desarrollo del núcleo experimental, decidía que tenía un núcleo estable y con la suficiente calidad, se lanzaba una nueva versión de producción o estable. Esta versión era la que se debía utilizar para un uso normal del sistema, ya que eran las versiones consideradas más estables y libres de fallos en el momento de su lanzamiento.

Versión de desarrollo: Esta versión era experimental y era la que utilizaban los desarrolladores para programar, comprobar y verificar nuevas características, correcciones, etc. Estos núcleos solían ser inestables y no se debían usar sin saber lo que se hacía.



Como interpretar los números de las versiones de las series por debajo de la 2.6:Las versiones del núcleo se numeraban con 3 números, de la siguiente forma: AA.BB.CCAA: Indicaba la serie/versión principal del núcleo. Solo han existido la 1 y 2. Este número cambiaba cuando la manera de funcionamiento del kernel había sufrido un cambio muy importante.BB: Indicaba si la versión era de desarrollo o de producción. Un número impar, significaba que era de desarrollo, uno par, que era de producción.

CC: Indicaba nuevas revisiones dentro de una versión, en las que lo único que se había modificado eran fallos de programación.

Unos ejemplos nos ayudaran a entenderlo mejor:ej1: versión del núcleo 2.4.0: Núcleo de la serie 2 (AA=2), versión de producción 4 (BB=4 par), primera versión de la serie 2.4 (CC=0)

ej2: versión del núcleo 2.4.1: Núcleo de la serie 2, versión 4, en el que se han corregido errores de programación presentes en la versión 2.4.0 (CC=1)

ej3: versión del núcleo 2.5.0: versión 0 del núcleo de desarrollo 2.5.Con la serie 2.6 del núcleo, el sistema de numeración así como el modelo de desarrollo han cambiado. Las versiones han pasado a numerarse con 4 dígitos y no existen versiones de producción y desarrollo.Las versiones del núcleo se numeran hoy en día con 4 dígitos, de la siguiente forma: AA.BB.CC.DD.

AA: Indica la serie/versión principal del núcleo.

BB: Indica la revisión principal del núcleo. Números pares e impares no tienen ningún significado hoy en día.

CC: Indica nuevas revisiones menores del núcleo. Cambia cuando nuevas características y drivers son soportados.

DD: Este digito cambia cuando se corrigen fallos de programación o fallos de seguridad dentro de una revisión.

Hoy en día se suele usar el núcleo distribuido con la distribución que el usuario utiliza. Son las distribuciones las encargadas de distribuir núcleos estables a sus usuarios y estos núcleos se basan en el núcleo ("vanilla") distribuido por Linus Torvalds y el equipo de programadores del núcleo.

3.- MATERIAL, EQUIPO, REACTIVO o SOTFWARE A UTILIZAR

Disco de Sistema Operativo Ubuntu Procesador de Textos Internet



4.- COMPETENCIAS ESPECÍFICAS

Con ayuda del profesor los alumnos se organizaran por equipos (3 personas como máximo) de las cuales sus tareas serán:

Descargar el kernel de LINUX de la página: “https://www.kernel.org/” una vez realizada la descargar

Deberán identificar del código fuente del kernel donde se encuentra programado el despachador de procesos así como también el manejador de interrupciones

De no poder identificarlo podrá apoyarse del internet para la identificación, con el propósito de familiarizarse con el kernel de Linux.

5. RESULTADOS

En esta parte el alumno integrara cada una de las pantallas donde se realizó la identificación de los despachadores así como un mapa mental de la ubicación de este.

6. CONCLUSIONES

El alumno comprenderá la estructura interna del kernel de LINUX y la identificación de los elementos que lo componen.

7.-BIBLIOGRAFÍA

1. Andrew S. Tanenbaum, Roberto Escalona García, Sistemas Operativos Modernos, Ed. Prentice Hall.

2. Sistemas Operativos Dhamdhere, Dhananjay M. Ed. Mc-Graw Hill de México 2008

3. William Stallings, Sistemas operativos. Aspectos internos y principios de diseño. Quinta edición. 2005. Pearson. Prentice-Hall.

4. Abraham Silberschatz, Peter Baer Galvin, Greg Gagne. 2006, Fundamentos de sistemas operativos. Séptima edición. McGraw-Hill.



Práctica 2

PROBLEMA DE LA CENA DE LOS FILÓSOFOSObservaciones: Esta práctica incluye a las Prácticas # 3, # 4 y #5 del temario de Sistemas Operativos I que dicen “Realizar una práctica para la detección de interbloqueos en los mutex del minikernel.”, “Realizar una práctica de implementación de semáforos usando un lenguaje de alto nivel.” Y “Realizar una práctica de planificación round-robin en el minikernel.”.

1.- OBJETIVO

El alumno aplicara los conocimientos adquiridos en materia de programación así como los adquiridos en clase para la planificación de procesos y detección de interbloqueos.

2.- MARCO TEÓRICO

Para que se produzca un interbloqueo deben cumplirse las cuatro condiciones. Asegurando que un de estas cuatro no se cumplan podemos prevenir la aparición de interbloqueos.

Exclusión mutua.- Al menos un recurso debe estar en modo no compartido, es decir, solo un procesos puede usarlo cada vez. Si otro proceso solicita el recurso, el proceso solicitante tendrá que esperar hasta que el recurso sea liberado.

Retención y espera.- Un proceso debe estar retenido al menos un recurso y esperando para adquirir otro recurso adicionales que actualmente estén retenidos por otro proceso.

Sin desalojo.- Los recursos no pueden ser desalojados, es decir un recurso solo puede ser liberado voluntariamente por el proceso que le retiene, después de que dicho proceso haya completado su tarea.

Espera circular.- debe existir un conjunto de procesos en espera, tal que este proceso esté esperando a un recurso retenido por P1, P1 esté esperando a un recurso retenido por P2, …,Pn-1 esté esperando a un recurso retenido por Pn, y Pn esté esperando a un recurso retenido por P0.

PRINCIPIOS DEL INTERBLOQUEO

El interbloqueo se puede definir como el bloqueo permanente de un conjunto de procesos que compiten por los recursos del sistema o bien se comunican unos con otros. A diferencia de otros problemas de la gestión concurrente de procesos, no existe una solución eficiente para el caso general.

Todos los interbloqueos suponen necesidades contradictorias de recursos por parte de dos o más procesos.

Ejemplo 1: Interbloqueo de tráfico



Cuatro coches llegan aproximadamente en el mismo instante a un cruce de cuatro caminos. Los cuatro cuadrantes de la intersección son los recursos compartidos sobre los que se demanda control; por tanto, si los coches desean atravesar el cruce, las necesidades de recursos son las siguientes:

- El coche que va hacia el norte necesita los cuadrantes 1 y 2.

- El coche que va hacia el oeste necesita los cuadrantes 2 y 3.

- El coche que va hacia el sur necesita los cuadrantes 3 y 4.

- El coche que va hacia el este necesita los cuadrantes 4 y 1.

La norma más habitual en la carretera es que un coche en un cruce de cuatro caminos debe ceder el paso al coche que está a su derecha. Esta norma funciona si solo hay dos o tres coches en el cruce. Por ejemplo, si solo llegan al cruce los coches del norte y del oeste, el coche del norte esperará hasta que el del oeste pase. Sin embargo, si los cuatro coches llegan al mismo tiempo cada uno se abstendrá de entrar en el cruce, provocando interbloqueo. Si todos los coches ignoran las normas y entran (con cuidado) en el cruce, cada coche obtendrá un recurso (un cuadrante) pero no podrá continuar porque el segundo recurso que necesita ya ha sido invadido por otro coche. De nuevo, se tiene interbloqueo.



Ejemplo 2: Cruce en un puente (es parecido al interbloqueo de tráfico)

En una carretera de dos direcciones, donde en un determinado cruce con la vía del ferrocarril, se ha construido un puente que solo deja pasar vehículos en un solo sentido. El bloqueo ocurre cuando dos carros intentan pasar por el puente al mismo tiempo.

Una manera de resolver el bloqueo es: el conductor situado en uno de los extremos es lo suficientemente educado que deja pasar en primer lugar al del otro extremo y luego pasa él.

Este ejemplo nos muestra como sucede el interbloqueo en nuestra vida diaria.


Java 7u21 Procesador de Textos Internet


Los alumnos con apoyo del profesor se integraran por equipos (3 personas máximo) para resolver:

El problema de los comensales filósofos que dice así: Cinco filósofos chinos se sientan alrededor de una mesa y pasan su vida cenando y pensando. Cada filósofo tiene un plato de fideos y un palillo a la izquierda de su plato. Para comer los fideos son necesarios dos palillos y cada filósofo sólo puede tomar los que están a su izquierda y derecha. Si cualquier filósofo toma un palillo y el otro está ocupado, se quedará esperando, con el palillo en la mano, hasta que pueda tomar el otro palillo, para luego empezar a comer.Si dos filósofos adyacentes intentan tomar el mismo tenedor a una vez, se produce una condición de carrera: ambos compiten por tomar el mismo palillo, y uno de ellos se queda sin comer.Si todos los filósofos toman el palillo que está a su derecha al mismo tiempo, entonces todos se quedarán esperando eternamente, porque alguien debe liberar el palillo que les falta. Nadie lo hará porque todos se



encuentran en la misma situación (esperando que alguno deje sus palillos). Entonces los filósofos se morirán de hambre. Este bloqueo mutuo se denomina interbloqueo o deadlock.

Desarrollar el algoritmo para resolver el problema. Codificación del algoritmo.

5. RESULTADOS

En esta parte el alumno integrara cada una de las pantallas donde se realizó la codificación y el algoritmo de la resolución del problema.

6. CONCLUSIONES

El alumno aprenderá y comprenderá el funcionamiento básico de un planificador de procesos.

7.- BIBLIOGRAFÍA







Práctica 3

COMO CONSUMEN RECURSOS LOS PROCESOSObservaciones: Esta práctica incluye a las Prácticas # 6 del temario de Sistemas Operativos I que dicen “Realizar una práctica de monitoreo de memoria de un proceso.”.

1.- OBJETIVO

El alumno entenderá el funcionamiento de la memoria y como se relaciona con los procesos.

2.- MARCO TEÓRICO

Se refiere a colocar de forma general, la información necesaria para el desarrollo de la práctica, es decir está orientado al cortical Izquierdo.

El comando top nos provee una vistá dinámica y en tiempo real con la cantidad y estado de los

procesos corriendo actualmente, memoria, espacio de swap y los recursos utilizados por cada proceso.

La interfaz es actualizada cada cierto período de tiempo (por defecto, 3segundos). Despliega un

resumen del estado del sistema y una lista de los procesos corriendo, de la siguiente manera:

top - 16:26:10 up 2:53, 1 user, load average: 0.01, 0.01, 0.00

Tasks: 46 total, 2

running, 44 sleeping, 0 stopped, 0 zombie

Cpu(s): 0.3%us, 0.3%sy, 6.0%ni, 93.0%id, 0.3%wa, 0.0%hi, 0.0%si, 0.0%st

Mem: 252692k total, 248656k used, 4036k free, 19440k buffers

Swap: 506036k total, 44k used, 505992k free, 188384k cached

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+

COMMAND



3365 p2p 39 19 42560 21m 4716 S 6.3 8.9 3:32.54 mlnet

4076 root 20 0 2324 1120 888 R 0.3 0.4 0:00.11 top

1 root 20 0 1656 496 456 S 0.0 0.2 0:00.38 init

2 root 15 -5 0 0 0 S 0.0 0.0 0:00.00 kthreadd

3 root 15 -5 0 0 0 S 0.0 0.0 0:00.00 ksoftirqd/0

4 root 15 -5 0 0 0 S 0.0 0.0 0:00.00 events/0

5 root 15 -5 0 0 0 S 0.0 0.0 0:00.03 khelper

163 root 15 -5 0 0 0 S 0.0 0.0 0:00.00 kblockd/0

Resumen del estado del sistema

En la primer línea tenemos la fecha y hora actual, la cantidad de

usuarios utilizando el sistema y la carga del sistema del último minuto, de los últimos 5 minutos y de los

últimos 15 minutos respectivamente. Cómo se calcula el load average es un tema en sí mismo, pero

básicamente es el promedio de la cantidad de procesos corriendo o prontos para correr en cierto

período de tiempo.

Lo que tenemos que saber que a mayor load average, mayor uso de procesador. Un load average de 0

indica que el procesador ha sido muy poco utilizado en ese período de tiempo, mientras que si es

mayor, significa que hay más procesos corriendo y prontos para correr que lo que el(los) core(s)

pueden procesar. Un load average igual a la cantidad de cores indica un uso óptimo del CPU. Más

info acá y acá.

En la segunda línea (Tasks) tenemos la cantidad de procesos y una agregación según el estado de

cada uno. Los diferentes estados que muestra son los siguientes:

Running: procesos corriendo actualmente, o listos para correr en cuanto se les asigne tiempo de CPU.

Sleeping: el proceso está dormido esperando que ocurra un evento para volver al estado “running”.



Stopped: La ejecución del proceso está parada; no está corriendo, y no va a volver a correr. Los

procesos generalmente entran en este estado cuando reciben señales que no están manejando, y la

acción por defecto de las mismas es pasar el proceso a stopped. Esto incluye señales como SIGSTOP,

SIGTSTP, SIGTTIN, y SIGTTOU. Una señal de tipo SIGCONT saca al proceso de este estado (ver el

comando fg). Con Ctrl+Z mandamos el proceso corriendo en la terminal al background, pasando a

estado stopped.

Zombie: El proceso tampoco está corriendo. Los procesos quedan en este estado cuando su el proceso

que los inició murió, ya sea por un error de programación o porque fue matado (ver kill -9).

La tercera línea nos da los porcentajes de uso de procesador, discriminado por “tipo” de uso. Los

diferentes tipos significan lo siguiente:

us: tiempo de procesos de usuario

sy: tiempo de procesos del sistema (kernel)

ni: tiempo de procesos del usuario que tienen un “nice” positivo

wa: tiempo en el cual los procesos están esperando por pedidos de I/O pendientes.

id: tiempo “idle”, en que no hay procesos requiriendo tiempo de procesador, y tampoco hay pedidos de

I/O pendientes.

st: “steal time”, sólo aplica cuando nuestro Linux corre en una máquina virtual. Es el tiempo que algún

proceso de nuestro sistema estaba esperando en la cola de ejecución, pero el hypervisor eligió no

darnos tiempo de procesador, y asignarlo a otro procesador virtual.

Si presionamos la tecla ‘1’, top nos muestra las estadísticas de uso discriminado por cada

core/procesador:

top - 18:57:22 up 12 days, 5:09, 1 user, load average: 0.03, 0.03, 0.00

nTasks: 174 total, 1 running, 173 sleeping, 0 stopped, 0 zombie

Cpu0 : 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si,



0.0%st


0.0%st

Cpu2 : 0.0%us, 0.3%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st


0.0%st

Cpu4 : 0.0%us, 0.3%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st


0.0%st


0.0%st


0.0%st

La línea siguiente (Mem) detalla las estadísticas de uso de memoria. En ella vemos la memoria total, la

memoria utilizada, la memoria libre y la memoria utilizada por como buffers.

Mem: 252692k total, 248656k used, 4036k free, 19440k buffers

La última de las líneas del

resumen (Swap) detalla el uso del espacio de swap. Indica cuánto es el espacio de swap total, cuánto

está utilizado, cuánto libre y cuánto está siendo utilizado por páginas cacheadas

Swap: 506036k total, 44k used, 505992k free, 188384k cached

Lista de procesos

Luego del resumen del uso de los recursos del sistema top lista los procesos activos, ordenándolos

según el uso de procesador.

Las columnas tienen el siguiente significado:



PID: Process ID

USER: usuario que inició el proceso

PR: prioridad del proceso

NI: nice value. Un valor negativo significa mayor prioridad (hasta -20), un valor positivo, menor prioridad

(hasta 19)

VIRT: Cantidad de memoria virtual utilizada por el proceso (incluyendo datos, código, shared libraries y

swap)

RES: Cantidad de memoria RAM física que el proceso está utilizando

SHR: Cantidad de memoria compartida.

Refleja la memoria que potencialmente podría ser compartida con otros procesos.

S: Status del proceso. Los posibles estados son ‘D’ (uninterruptible sleep), ‘R’ (running), ‘S’ (sleeping),

‘T’ (traced ostopped) o ‘Z’ (zombie).

%CPU: porcentaje de CPU utilizado desde la última actualización de la pantalla.

%MEM: porcentaje de memoria física utilizada por el proceso

TIME+: Tiempo total de CPU que el proceso ha utilizado desde que se inició.

COMMAND: comando utilizado para iniciar el proceso.

Se pueden agregar, quitar o cambiar el orden de estas columnas con las teclas f y o.

Interacción con top

Podemos utilizar las siguientes teclas para interactuar con top:

M – Ordenar por uso de memoria

P – Ordenar por uso de CPU

T – Ordenar por tiempo de CPU utilizado

F – seleccionar campo por el cual ordenar la lista de procesos

i – mostrar u ocultar procesos idle y zombie



m, l, t, 1 – muestra u oculta las líneas del resumen (parte de arriba)

f, o – agregar/quitar columnas, cambiar el orden

s – cambia el tiempo de actualización de la pantalla (por defecto, 3 segundos)

z – Colores

k – Matar un proceso (luego pregunta el PID)

r – “renice” cambia el nice value de un proceso (luego pregunta el PID)

q – finalizar

h – ayuda


Sistema Operativo Ubuntu Procesador de Textos Internet


Los alumnos con apoyo del profesor se integraran por equipos (3 personas máximo) para el resolver:

Abrir una terminal. Escribir en la terminal el comando top y presionamos 1. Escribir en la terminal el comando watch -d free –m Comparar top vs watch. Que identificaste de las terminales.

5. RESULTADOS

En esta parte el alumno integrara cada una de las pantallas donde se realizaron laspruebas.

6. CONCLUSIONES

El alumno aprenderá comandos básicos para monitoreo del sistema en LINUX.

7.- BIBLIOGRAFÍA







Práctica 4

LLAMANDO AL SISTEMAObservaciones: Esta práctica incluye a las Prácticas # 8 del temario de Sistemas Operativos I que dicen “Realizar una práctica de introducción de una nueva llamada al sistema en el minikernel.”.

1.- OBJETIVO

El alumno aplicará la llamada al kernel para identificar de qué manera responde este.

2.- MARCO TEÓRICO

Se refiere a colocar de forma general, la información necesaria para el desarrollo de la práctica, es decir está orientado al cortical Izquierdo.A la hora de programar en C hay 3 tipos de funciones a las que podemos recurrir. Las funciones ordinarias internas a tu programa (desarrollo propio al programa), las funciones de librería que son funciones ordinarias que residen en una librería externa a tu programa (desarrollo propio o ajeno al programa). Como por ejemplo las funciones de la librería estandar C (libc). Una llamada a estas funciones es igual a cualquier llamada a una función. Los argumentos son situados en los registros del procesador o en la pila. La ejecución es transferida al comienzo del código de la función, que típicamente está cargada en una librería compartida. Y, por último, las llamadas al sistema (system call).

Una llamada al sistema está implementada en el núcleo de Linux. Cuando un programa llama a una función del sistema, los argumentos son empaquetados y manejados por el núcleo, el cual toma el control de la ejecución hasta que la llamada se completa. Una llamada al sistema no es una llamada a una función ordinaria, y se requiere un procedimiento especial para transferir el control al núcleo. Sin embargo la librería GNU C encapsula las llamadas al sistema con funciones de manera que pueden ser



llamadas de manera sencilla y se confunden con llamadas a funciones ordinarias. Las funciones de entrada/salida como open y read son ejemplos de llamadas al sistema en Linux.

El conjunto de llamadas al sistema Linux forman el interfaz más básico entre los programas y el núcleo de Linux.

Existen llamadas al sistema que sólo pueden ser ejecutados por el supe usuario en caso contrario fallarán. Además una función de librería puede invocar una o más funciones de librería o llamadas del sistema como parte de su implementación.

Linux tiene más de 300 diferentes llamadas al sistema. Un listado de las llamadas al sistema de tu versión del kernel de Linux se puede encontrar en /usr/include/asm/unistd.h actualmente este fichero incluye a otros dos uno para arquitecturas de 32 bits y otro para arquitecturas de 64 bits (unistd_32.h y unistd_64.h respectivamente)

Para poder introducirnos en las llamadas al sistema es necesario conocer strace. Strace (system trace) es un comando de la shell donde puedes depurar las llamadas al sistema de cualquier programa. strace te informa sobre las llamadas al sistema que realiza un programa además de las señales que recibe. Es por tanto un herramienta muy valiosa de depuración.

Para utilizar strace basta con escribir strace seguido del nombre del programa que quieres analizar, por ejemplo

$ strace hostname

strace basicamente ejecuta el comando especificado hasta que este finaliza. Strace intercepta y registra las llamadas al sistema que el programa ha ejecutado y las señales recibidas por el proceso. strace envia a stderror o a un fichero especificado con la opción -o el nombre de la llamada al sistema, sus argumentos y el valor de retorno de la llamada. Por ejemplo:

execve("/bin/hostname", ["hostname"], [/* 43 vars */]) = 0

La llamada al sistema es execve. Los parámetros que se pasan al programa son los que se encuentran entre parámetros "/bin/hostname", ["hostname"], [/* 43 vars */] y el valor de retorno aparece despues del igual (0)

Para señales se imprime el símbolo de la señal y una cadena explicativa rodeado de '---' y '+++'. Por Ejemplo:

--- SIGFPE (Floating point exception) @ 0 (0) ---+++ killed by SIGFPE +++

En el caso de SIGKILL podemos ver:

<unfinished ...>

Recordemos que esta señal no se puede enmascarar.

A continuación voy a analizar un par de llamadas al sistema bastante comunes que pueden servir como ejemplo. El primero es access que sirve para comprobar los permisos sobre un determinado fichero. Access puede comprobar cualquier combinación de permisos lectura, escritura y ejecución.

La llamada a access tiene 2 argumentos el primero es la ruta al fichero cuyos permisos queremos



comprobar el segundo es un campo de bits tipo OR que puede contener R_OK, W_OK, X_OK que corresponden a verificar los permisos de lectura, escritura y ejecución. El valor de retorno es 0 si tiene todos los permisos especificados por el segundo parámetro. Si el fichero existe pero no tiene todos los permisos especificados devuelve -1 y errno cambia a EACCES (o a EROFS si se ha solicitado los permisos de escritura para un fichero de sólo lectura).

Si el segundo argumento es F_OK sólo se comprueba la existencia del fichero. Si el fichero existe devuelve 0 si no existe devuelve -1 y fija errno a NOENT. Si el directorio donde está el fichero es inaccesible errno se fija a EACCESS. Veamos un ejemplo:

Otro ejemplo de llamada a sistema es fsync. Fsync permite sincronizar el contenido de un fichero con su copia en disco. Linux utiliza sincronizaciones asincronas entre la copia del fichero en memoria y la copia en disco. Para asegurarse de que ambas copias contienen la misma información. El sistema se encarga de hacer esto automaticamente pero es posible hacerlo manualmente a través de esta llamada. Este es un ejemplo.



Si compilas el fichero anterior y al ejecutable lo llamamos sync en el directorio actual podemos ejecutar

$ traceroute sync

Y así ver como traceroute nos muestra la llamada al sistema, sync().




Sistema Operativo Ubuntu Procesador de Textos Internet



Abrir Gedit Introducir el siguiente texto:

Compilar con gcc. Identificar la llamada que está realizando. Explicar el código que realiza.

5. RESULTADOS


6. CONCLUSIONES

El alumno aprenderá codificación básica para la llamada al sistema operativo.

7.- BIBLIOGRAFÍA









Práctica 5

ArbolesObservaciones: Esta práctica incluye a las Prácticas # 9, # 10 y #11 del temario de Sistemas Operativos I que dicen “Realizar una práctica de gestión de archivos. Representando un árbol de directorios.”, “Realizar una práctica de creación de un sistema de archivos simulando una semejanza con el servidor de archivos en Windows.”, “Realizar una práctica de creación de un sistema de archivos simulando su semejanzacon el servidor de archivos de Linux”.

1.- OBJETIVO

El alumno desarrollara el modelado XML para la representación de árboles de archivos.

2.- MARCO TEÓRICO

Se refiere a colocar de forma general, la información necesaria para el desarrollo de la práctica, es decir está orientado al cortical Izquierdo.Árbol de directorios

Estructura de directorios básica en GNU/Linux

Al examinar el contenido de nuestro disco duro mediante la consola o cualquiera de las utilidades graficas de que dispone nuestra distribuciÃ³n de GNU/Linux (tomemos como ejemplo el navegador Konqueror de KDE), nos daremos cuenta de que existen muchos directorios cuyo nombre puede parecer confuso, sobretodo si tenemos cierta experiencia en los sistemas de Microsoft. En este caso, también observaremos que los directorios utilizan el carácter / en lugar del carácter \ para referirse a una ruta de subdirectorios anidados.

En GNU/Linux, todo tiene su reflejo en algún archivo o en algún directorio del sistema de archivos.

Los directorios de GNU/Linux pueden pertenecer a dos categorías distintas, según si se pueden o no compartir en un entorno de red, o si contienen datos estáticos o variables.

Pero desde el punto de vista del usuario, en GNU/Linux existen dos tipos de directorios: los directorios del sistema y el directorio del usuario.



Directorios del sistema

Los directorios del sistema son aquellos en los que se guardan todos los archivos que componen nuestro sistema operativo GNU/Linux. Es de capital importancia que ningÃºn usuario que no disponga de los permisos adecuados pueda acceder a los archivos que componen nuestro sistema, ya que, de lo contrario, un usuario inexperto (por ejemplo) podrÃa modificarlos o eliminarlos y hacer que todo el sistema se volviera inestable, o incluso inutilizable (como es el caso de los sistemas de Microsoft, donde la mera activaciÃ³n de un virus por parte de un usuario determinado vulnera la totalidad del sistema operativo y la seguridad y privacidad de los datos del resto de usuarios).

En una distribuciÃ³n GNU/Linux tÃpica podemos encontrar los siguientes directorios delsistema:

/boot Este directorio contiene la informaciÃ³n necesaria para poder arrancar nuestro sistema GNU/Linux. Entre otros archivos, aquÃ se encuentran los nÃºcleos que se pueden iniciar (normalmente se trata de archivos con un nombre similar a vmlinuz-x.y.z).

/etc Este directorio contiene todos los archivos de configuraciÃ³n de nuestro sistema GNU/Linux (como el archivo passwd, que contiene una lista con los nombres de usuario y contraseÃ±as, o el archivo fstab, que contiene una lista con los puntos donde se han montado las diferentes particiones y los sistemas de archivos que utilizan).

/bin Contiene programas ejecutables (tambiÃ©n llamados binarios) que forman parte del sistema operativo GNU/Linux. Estos comandos pueden ser usados por cualquier usuario y son relativos a la consola.

/sbin Contienen programas ejecutables (tambiÃ©n llamados binarios) que forman parte del sistema operativo GNU/Linux. Estos comandos son relativos a los sistemas de archivos, particiones e inicio del sistema, y solo pueden ser usados por el administrador.

/lib Contiene las bibliotecas (o librerÃas) del sistema que son necesarias durante el inicio del mismo. Estas bibliotecas son anÃ¡logas a los archivos DLL de Windows. Su ventaja reside en que no es necesario integrar su cÃ³digo en los programas que las usan, ya que cuando un programa necesita alguna de sus funciones, se carga la biblioteca en la memoria y puede ser usada por cualquier otro programa que la necesite, sin necesidad de volver a cargarla en memoria. Un subdirectorio especial es/lib/modules, que contiene los mÃ³dulos del nÃºcleo (normalmente se trata de controladores de dispositivos) que se cargan Ãºnicamente en caso de que haga falta usar un determinado dispositivo, por lo que no estarÃ¡n permanentemente ocupando memoria.

/mnt Este directorio es tÃpico de las distribuciones RedHat, aunque puede no estar presente en otras distribuciones. Su misiÃ³n consiste en agrupar en un mismo lugar los puntos de montaje de diversas particiones externas, como por ejemplo: CD-ROM, DVD, disqueteras, unidades ZIP, particiones de MS-Windows y de otros sistemas operativos, etc. Este directorio contiene un subdirectorio adicional para cada una de estas particiones (como /mnt/cdrom, /mnt/win_c, /mnt/floppy o /mnt/zip). Si accedemos a estos subdirectorios estaremos accediendo realmente a esas particiones.



/usr Su nombre proviene de user (usuario) y, como tal, contiene una réplica de otros directorios de nuestro sistema GNU/Linux orientados al usuario en lugar de al propio sistema. Este directorio se puede compartir en una red local, pero su contenido es estático.

/opt Contiene paquetes de software adicionales, como por ejemplo KDE o GNOME. Algunas distribuciones no hacen uso de él.

/var Su nombre procede de variable, y esa es la naturaleza de la informaciÃ³n que contienen sus subdirectorios y archivos, como colas de impresiÃ³n (en /var/spool/lpd), correo electrÃ³nico que todavÃ-a no se ha recogido (en /var/spool/mail) o enviado (en/var/spool/mqueue), o archivos de registro creados por los distintos procesos de nuestro sistema (en /var/log).

/tmp Este directorio contiene diversos archivos temporales que son usados por distintos programas de nuestro sistema.

/dev Este directorio contiene archivos de dispositivos que permiten la comunicaciÃ³n con los distintos elementos hardware que tengamos instalados en nuestro sistema. Entre los distintos dispositivos que aquÃ podemos encontrar estÃ¡n los discos duros (como /dev/hda o /dev/sda), las particiones de los discos duros (como por ejemplo/dev/hda1 o /dev/sda4), las unidades de CD-ROM SCSI (como /dev/scd0) y los vÃnculos a cualquier tipo de unidad de CD-ROM (como /dev/cdrom), las disqueteras (como /dev/fd0), las impresoras (como /dev/lp0), los puertos serie (como /dev/ttyS0 o/dev/cua0), el puerto PS/2 (/dev/psaux) y las tarjetas de sonido (como /dev/audio).

/proc Contiene los archivos del sistema de archivos de proceso. No son verdaderos archivos, sino una forma de acceder a las propiedades de los distintos procesos que se estÃ¡n ejecutando en nuestro sistema. Para cada proceso en marcha existe un subdirectorio /proc/<número de proceso> con información sobre él.

/root Este es el directorio personal del usuario root o superusuario. Contiene bÃ¡sicamente la misma informaciÃ³n que los directorios personales de los distintos usuarios del sistema, pero orientada única y exclusivamente al usuario root.

/home AquÃ residen los directorios de los distintos usuarios del sistema, excepto el del usuario root, que se encuentra en el directorio especial /root. Este directorio es opcional, aunque estÃ¡ presente en casi todas las distribuciones.

La jerarquía /etc

Este directorio posee distintos subdirectorios que se utilizan para la configuración de determinados componentes de nuestro sistema:



/etc/opt Contiene los archivos de configuraciÃ³n para el software instalado en el directorio /opt. Cada paquete de software tendrÃ¡ su correspondiente subdirectorio dentro de /etc/opt.

/etc/X11 Contiene los archivos de configuraciÃ³n del entorno grÃ¡fico X Window. Entre otras cosas, contiene los gestores de ventanas y de arranque de los distintos escritorios grÃ¡ficos. Este directorio es opcional.

/etc/sgml Contiene los archivos de configuraciÃ³n para SGML y XML. Este directorio es opcional.

La jerarquÃa /usr

Este directorio contiene distintos subdirectorios:

/usr/bin Contiene casi la totalidad de los comandos que un usuario puede necesitar.

/usr/include Contiene los archivos de cabeceras usados por los programas escritos en el lenguaje C.

/usr/lib Contiene las bibliotecas de usuario.

/usr/local Contiene la jerarquÃa local de usuario, con los subdirectorios tÃpicos /bin, /include, /lib, /sbin, etc. Tras la instalaciÃ³n de un sistema GNU/Linux, este directorio estarÃ¡ vacÃo.

/usr/sbin Contiene los archivos binarios (ejecutables) no vitales del sistema usados por el administrador.

/usr/share Contiene archivos de datos independientes de la arquitectura del sistema, como documentaciÃ³n, howtos, etc. AquÃ se encontrar los subdirectorios /man (que contiene manuales de programas) y /misc (que contiene diversos datos independientes de la arquitectura). TambiÃ©n se pueden encontrar los subdirectorios/dict, /doc, /games, /info, /locale, /smgl, zoneinfo, etc.

/usr/X11R6 Contiene todos los programas que componen el entorno grÃ¡fico X Window (binarios, bibliotecas y pÃ¡ginas man, por lo que encontraremos directorios como /usr/X11R6/bin /usr/X11R6/lib y /usr/X11R6/man). Este directorio es opcional.

/usr/games Contiene los archivos binarios de muchos juegos y programas educativos. Este directorio es opcional.

/usr/src Contiene el cÃ³digo fuente del nÃºcleo de GNU/Linux. Este directorio es opcional.

/usr/local Como en el resto de sistemas operativos UNIX, GNU/Linux estÃ¡ diseÃ±ado para ser usado en entornos de red, por lo que es bastante frecuente que el directorio /usr no se encuentre en el ordenador local, sino en un servidor. Por ello, el directorio /usr/local estÃ¡ destinado a contener el software que se instale localmente en cada ordenador, y contiene subdirectorios similares a los que se puede encontrar bajo /usr (como /usr/local/bin, /usr/local/sbin, /usr/local/lib, /usr/local/man, etc.). Adicionalmente, encontraremos un directorio /usr/local/etc con idÃ©ntica funcionalidad al directorio /etc.



Aunque use su ordenador de forma aislada y no en un entorno de red, este es el directorio en el que deberá instalar sus programas.

La jerarquía /var

Este directorio también posee una estructura típica de subdirectorios:

/var/cache Contiene datos de aplicaciones en cache, como archivos del servidor web y pÃ¡ginas de manual.

/var/lib Contiene información de estado variable.

/var/log Contiene registros creados por diversos programas y por el propio sistema operativo.

/var/run Contiene datos relevantes para algunos procesos que se estÃ¡n ejecutando.

/var/spool Contiene datos encolados de diversas aplicaciones, como correo electrónico del sistema y colas de impresión.

/var/tmp Contiene datos temporales que deben ser preservados entre reinicios del sistema.

El directorio del usuario

En un sistema GNU/Linux, cada usuario dispone de su propio directorio personal donde puede guardar los documentos creados por Ã©l con los distintos programas. Este directorio personal puede ser de acceso exclusivo para cada usuario, por lo que ningÃºn otro usuario podrÃ¡ entrar en Ã©l y visualizar el contenido de los archivos que contiene (aunque esto depende del nivel de seguridad seleccionado durante la instalaciÃ³n del sistema, ya que lo normal suele ser que el resto de usuarios puedan entrar en él y ver el contenido de algunos archivos y subdirectorios, pero no modificarlo).

Los directorios personales están ubicados en /home/<nombre de usuario>. El usuarioroot si dispone de los permisos suficientes para acceder a los directorios personales del resto de usuarios.

Otros directorios

Algunas distribuciones hacen uso de otros directorios adicionales que suelen montar en el directorio raíz:

/media Es un directorio anÃ¡logo al estÃ¡ndar /mnt, y contiene los puntos de montaje delos dispositivos extraÃbles.

/windows Algunas distribuciones lo crean si detectan un sistema Microsoft Windows instalado en nuestro equipo, creando dentro de Ã©ste tantos subdirectorios como particiones de Windows tengamos (como /windows/C, /windows/D, etc.). Contiene el punto de montaje de estas particiones.



/srv AquÃ se alojan los directorios que usan los distintos servidores que tengamos instalados, como el servidor web (en /srv/www) o el servidor FTP (en /srv/ftp).

Estos directorios no forman parte del estándar FHS, por lo que deberán ser evitados


Sistema Operativo Ubuntu Procesador de Textos Internet XML gedit



Abrir Gedit. Programa un árbol en XML. Programar un árbol de la estructura de archivos de Windows. Programar un árbol de la estructura de archivos de Linux. Identificar los nodos, raíz, tallo y hojas del sistema de archivos.

5. RESULTADOS


6. CONCLUSIONES

El alumno aprenderá codificación básica para la representación de sistemas de archivos.

7.- BIBLIOGRAFÍA







Práctica 6

RECOMPILANDO EL NUCLEOObservaciones: Esta práctica incluye a las Prácticas # 12 y # 13 del temario de Sistemas Operativos I que dicen “Desarrollar una práctica de recompilación del núcleo de un sistema operativo puede serdidáctico como pcxinu de Douglas Comer o minix de Andrew Tanenbaum o real comoGNU/LINUX.” y “Elaborar algunas llamadas al sistema y distinguir el mecanismo de las interrupciones enel contexto de los Procesos”.

1.- OBJETIVO

El alumno aprenderá a compilar y modificar el KERNEL de LINUX.

2.- MARCO TEÓRICO

¿Qué es el Kernel?El kernel o núcleo de Linux lo podríamos definir como el corazón del SO.Antiguamente había dos tipos de versiones del núcleo. Teníamos:Versión de produccion: Era la versión estable del momento y la que se debía de utilizar, ya que, esta versión era el resultado final de las versiones que estaban en desarrollo.Versión de desarrollo:Era la versión que estaba en desarrollo y la que los programadores utilizaban para corregir bugs. Esta versión era muy inestable.¿Cómo entender los “numeritos” del kernel?Muchas veces habrá visto los kernel de esta manera:Kernel 2.4.1Kernel 2.6.21.1Y claro, ¿cómo se entiende eso?Pues bien, las versiones por debajo de la 2.6 se numeraban en 3 dígitos. (SS.PP.VV)SS: Indica la serie (o versión) principal del kernel. Solo existen las versiones 1 y 2.PP: Indica si la versión es de desarrollo o de producción. Fácil, número impar es que está en desarrollo, numero par que esta de producción.VV: Indica si el kernel tiene revisiones dentro de la versión (Sólo se modificaban fallos de programación)Hoy en día, también convive con la 2.4, la 2.6. Con ésta serie el sistema de numeración pues cambio. En esta serie los modelos de desarrollo han cambiado, la manera de numerarse a pasado a ser de 4 dígitos (VV.RR.NR.CR) y no existen las versiones de producción ni la de desarrollo.VV: Indica la versión (o serie) del kernel.RR: Indica la revisión del kernel (Da igual que los vea de forma impar o par, hoy en día, no tiene significado)NR: Indica nuevas revisionesdel kernel. Estos números cambian cuando se incorporan nuevas características y driversCR: Este digito cambia cuando se corrigen fallos de programación o fallos de seguridad dentro de una revisión.



Jerarquía de directorios

En Linux existe un sistema de archivos que carga y contiene todos los directorios, redes, programas, particiones, dispositivos, etc. que el sistema sabe reconocer, o por lo menos, identificar. Este sistema de ficheros y directorios, tiene como base al carácter (/); ese mismo carácter sirve también para demarcar los directorios, como por ejemplo: "/home/usuario/imagen.jpg". El directorio especificado por una ruta consistente sólo por este carácter contiene toda la jerarquía de los directorios que constituyen todo el sistema. A este directorio suele llamárselo directorio raíz. En Linux, a los discos no se les asigna una letra como en Windows (p.e. "C:"), sino que se les asigna un directorio de la jerarquía del directorio raíz (/), como por ejemplo: "/media/floppy". Es práctica común en el sistema de ficheros de Linux, utilizar varias sub-jerarquías de directorios, según las diferentes funciones y estilos de utilización de los archivos.16Estos directorios pueden clasificarse en:

Estáticos: Contiene archivos que no cambian sin la intervención del administrador (root), sin embargo, pueden ser leídos por cualquier otro usuario. (/bin, /sbin, /opt, /boot, /usr/bin...)

Dinámicos: Contiene archivos que son cambiantes, y pueden leerse y escribirse (algunos solo por su respectivo usuario y el root). Contienen configuraciones, documentos, etc. Para estos directorios, es recomendable una copia de seguridad con frecuencia, o mejor aún, deberían ser montados en una partición aparte en el mismo disco, como por ejemplo, montar el directorio /home en otra partición del mismo disco, independiente de la partición principal del sistema; de esta forma, puede repararse el sistema sin afectar o borrar los documentos de los usuarios. (/var/mail, /var/spool, /var/run, /var/lock, /home...)

Compartidos: Contiene archivos que se pueden encontrar en un ordenador y utilizarse en otro, o incluso compartirse entre usuarios.

Restringidos: Contiene ficheros que no se pueden compartir, solo son modificables por el administrador. (/etc, /boot, /var/run, /var/lock...)

Kernel panic

Kernel panic.

En Linux, un panic es un error casi siempre insalvable del sistema detectado por el núcleo en oposición a los errores similares detectados en el código del espacio de usuario. Es posible para el código del núcleo indicar estas condiciones mediante una llamada a la función de pánico situada en el archivo header sys/system.h. Sin embargo, la mayoría de las alertas son el resultado de excepciones en el código del núcleo que el procesador no puede manejar, como referencias a direcciones de memorias inválidas. Generalmente esto es indicador de la existencia de un bug en algún lugar de la cadena de alerta. También pueden indicar un fallo en el hardware como un fallo de la RAM o errores en las funciones aritméticas en el procesador, o por un error en el software. En muchas ocasiones es posible reiniciar o apagar adecuadamente el núcleo mediante una combinación de teclas como ALT+SysRq+REISUB.


http://commons.wikimedia.org/wiki/File:Kernel-panic.jpg


Lenguajes de programaciónLinux está escrito en el lenguaje de programación C, en la variante utilizada por el compilador GCC (que ha introducido un número de extensiones y cambios al C estándar), junto a unas pequeñas secciones de código escritas con el lenguaje ensamblador. Por el uso de sus extensiones al lenguaje, GCC fue durante mucho tiempo el único compilador capaz de construir correctamente Linux. Sin embargo, Intel afirmó haber modificado su compilador C de forma que permitiera compilarlo correctamente.Asimismo se usan muchos otros lenguajes en alguna forma, básicamente en la conexión con el proceso de construcción del núcleo (el método a través del cual las imágenes arrancables son creadas desde el código fuente). Estos incluyen a Perl, Python y varios lenguajes shell scripting. Algunos drivers también pueden ser escritos en C++, Fortran, u otros lenguajes, pero esto no es aconsejable. El sistema de construcción de Linux oficialmente solo soporta GCC como núcleo y compilador de controlador.

Portabilidad.

Ipod ejecutando un núcleo Linux.

Aún cuando Linus Torvalds no ideó originalmente Linux como un núcleo portable, ha evolucionado en esa dirección. Linux es ahora de hecho, uno de los núcleos más ampliamente portados, y funciona en sistemas muy diversos que van desde iPAQ (una handheld) hasta unzSeries (un mainframe masivo). Está planeado que Linux sea el sistema operativo principal de las nuevas supercomputadoras de IBM, Blue Gene cuando su desarrollo se complete.

De todos modos, es importante notar que los esfuerzos de Torvalds también estaban dirigidos a un tipo diferente de portabilidad. Según su punto de vista, la portabilidad es la habilidad de compilar fácilmente en un sistema aplicaciones de los orígenes más diversos; así, la popularidad original de Linux se debió en parte al poco esfuerzo necesario para tener funcionando las aplicaciones favoritas de todos, ya sean GPL o de Código abierto.

Las arquitecturas principales soportadas por Linux son DEC Alpha, ARM, AVR32, Blackfin,ETRAX CRIS, FR-V, H8, IA64, M32R, m68k, MicroBlaze, MIPS, MN10300, PA-RISC, PowerPC, System/390, SuperH, SPARC, x86, x86 64 y Xtensa17

Arquitectura de máquina virtual

El núcleo Linux puede correr sobre muchas arquitecturas de máquina virtual, tanto como host del sistema operativo o como cliente. La máquina virtual usualmente emula la familia de procesadores Intel x86, aunque en algunos casos también son emulados procesadores de PowerPC o ARM.


http://commons.wikimedia.org/wiki/File:Ipod_linux_booting_kernel.jpg


Formatos binarios soportados Linux 1.0 admitía sólo el formato binario a.out. La siguiente serie estable (Linux 1.2) agregó la utilización del formato ELF, el cual simplifica la creación de bibliotecas compartidas (usadas de forma extensa por los actuales ambientes de escritorio como GNOME yKDE). ELF es el formato usado de forma predeterminada por el GCC desde alrededor de la versión 2.6.0. El formato a.out actualmente no es usado, convirtiendo a ELF en el formato binario utilizado por Linux en la actualidad.

Linux tiene la capacidad de permitir al usuario añadir el manejo de otros formatos binarios. También binfmt_misc permite correr el programa asociado a un archivo de datos.


Sistema Operativo Ubuntu Kernel de LINUX Procesador de Textos Internet gedit



Iniciar en Ubuntu. Descargar el Kernel mas actual del siguiente hipervínculo: https://www.kernel.org/ Descomprimirlo en el lugar de preferencia. Abrir una terminal forma manual o por el comando: Ctrl+Alt+T. Acceder por medio de la terminal a la ruta donde se encuentra el kernel descomprimido. Una vez dentro del directorio ejecutar en la terminal el comando: make menuconfig. Ya que cargo el configurador podrás explorar cada una de las opciones que te da el Kernel

para poder personalizarlo. Al final guardas los cambios que hayas hecho o los descartas según sea el caso. Ingresa en la terminal el siguiente condigo para compilar los modulos: make modules. Y para instalar los módulos al kernel ingresa el siguiente código:make modules_install. Al final para instalar el kernel modificado ingresa el siguiente código: make install. Ingresa por último el siguiente comando: update-grub. Reinicia la máquina para que visualices los cambios al Kernel. Del código fuente deberás identificar donde se encuentra el módulo del despachador de

procesos, roud-robin, semáforo.

5. RESULTADOS

En esta parte el alumno integrara cada una de las pantallas donde se realizaron laspruebas y las modificaciones al kernel.

6. CONCLUSIONES

El alumno aprenderá a compilar y personalizar un kernel real de GNU/LINUX.



7.- BIBLIOGRAFÍA







8.- LISTA DE MATERIAL, EQUIPO O REACTIVO A UTILIZAR

FOLIO NOMBRE DEL MATERIAL, EQUIPO O REACTIVO CANT. UNIDAD

1 Java 7u21

2 Sistema Operativo Ubuntu

3 Procesador de Textos

4 Internet

5 XML

6 gedit

7Kernel de LINUX

9.- LISTA DE BIBLIOGRAFÍA REQUERIDA

FOLIO BIBLIOGRAFIA CANT

1Andrew S. Tanenbaum, Roberto Escalona García, Sistemas Operativos Modernos, Ed. Prentice Hall.

2Sistemas Operativos Dhamdhere, Dhananjay M. Ed. Mc-Graw Hill de México 2008

3William Stallings, Sistemas operativos. Aspectos internos y principios de diseño. Quinta edición. 2005. Pearson. Prentice-Hall.

4

5

6



10.- CONTROL DE CAMBIOS DEL MANUAL DE PRÁCTICAS

DATOS GENERALESFECHA DE

ACTUALIZACION ELABORÓ Y/O ACTUALIZÓ DESCRIPCIÓN DE LA ACTUALIZACIÓN

22/08/2013 Ing. Edgar Franco Pérez Se elaboró todo el manual de prácticas debido a que es nuevo plan de estudios.


Documents

Manual de Practicas SO