Sistemas Operativos Fis Hctor E Medelln Anaya Objetivos

Sistemas Operativos Fis. Héctor E. Medellín Anaya

Objetivos • Analizar el concepto de proceso y su manejo por el sistema operativo. • Revisar los problemas clásicos de la comunicación de procesos. • Conocer los aspectos fundamentales del software de entrada y salida. • Analizar los algoritmos de manejo de memoria. • Conocer los aspectos fundamentales del sistema de archivos de algunos sistemas operativos actuales. • Analizar, utilizar y configurar algunos sistemas operativos.

Bibliografía • Andrew S. Tanenbaum, Sistemas Operativos, diseño e implementación. Prentice Hall, 1988 • Stuart E. Madnick y John J. Donovan. Sistemas Operativos. Ed. Diana • Rachel Morgan y Henry Mc. Gilton. Introducción al UNIX Sistema V. Mc. Graw Hill

Reseña histórica Primera generación (1945 -1955): Computadoras de tubos de vacío, programación por tarjetas perforadas. Segunda generación (1955 -1965): Computadoras de transistores, sistemas por lotes

Tercera generación (1965 -1980) Circuitos integrados, multiprogramación, sistema 360 (OS/360 en la 7040 de IBM), petición de trabajos, manejo de cola de impresión, Simultaneous Peripherial Operation On Line (Splooling), tiempo compartido (CTSS) MIT 1962. MULTICS (Multiplexed Information and Computing Service). DEC PDP-1 en 1961, 4 k. B, $120, 000 PDP-11 Brian Kernighan escribió UNICS (Uniplexed Information and Computing Service) deribó en UNIX, en Bell Laboratories, Dennis Ritchy escribió C para escribir UNIX. Cuarta generación (1980 -1990) MS-DOS, UNIX para 68000, sistemas de red y sistemas distribuidos. MINIX es un UNIX gratis, derivó en LINUX.

Definición Puede considerarse al sistema operativo como el más fundamental de todos los programas. Controla todos los recursos del sistema de cómputo y ofrece la base sobre la cual pueden escribirse los programas de aplicación. El sistema operativo es una capa de software que está sobre la parte superior del hardware descubierto. De esta manera se manejan todas las partes del sistema y se presentar al usuario una interfaz o máquina virtual que es más fácil de entender y programar.

Niveles de software en un sistema

El sistema operativo como una máquina ampliada La función del sistema operativo es la de presentar al usuario con el equivalente de una máquina ampliada o máquina virtual que sea más fácil de programar que el hardware implícito. El sistema operativo como un manejador de recursos La tarea principal del sistema operativo es llevar el control de quién utiliza cuál recurso, conceder requisiciones de recursos, explicar el uso e interceder en requisiciones conflictivas de diferentes programas y usuarios. La interfaz entre el sistema operativo y los programas de usuario se define por medio del conjunto de "instrucciones extendidas" que el sistema operativo proporciona, estas se conocen como llamadas al sistema.

Procesos Un proceso es un programa en ejecución. Consta del programa ejecutable, los datos y la pila del programa, su contador de programa, apuntador de pila y otros registros, así como de toda la información que se necesita para ejecutar el programa. En muchos sistemas operativos, toda la información referente a cada proceso se almacena en una tabla del sistema operativo llamada tabla de procesos, la cual es un arreglo (o lista enlazada) de estructuras, una para cada proceso en existencia corriente. Por lo tanto un proceso consta de su espacio de direcciones, generalmente llamada imagen del núcleo y su registro de la tabla de procesos, que contiene sus registros entre otras cosas.

Un proceso puede crear uno o más procesos diferentes (conocidos como procesos hijos) y estos a su vez generan nuevos procesos hijos, se llega rápidamente a una estructura de árbol.

Archivos Un archivo es un bloque de información que generalmente reside en disco. El directorio es una forma de guardar archivos, éste tiene una estructura de árbol.

Un concepto importante en los archivos es el de archivo especial, este permite manejar los dispositivos como si fueran archivos. Los archivos especiales se dividen en dos tipos, archivos especiales de bloque y archivos especiales de caracteres. los archivos especiales de bloque manejan dispositivos en los que las transferencias se hacen en bloque al azar, como los discos. Los archivos especiales de caracteres modelan dispositivos seriales como impresoras de línea, interfaces de red, etc. El dispositivo estándar de entrada se reconoce con el descriptor de archivo 0 y el dispositivo estándar de salida por el descriptor de archivo 1. El descriptor de archivo 2 se refiere al dispositivo error estándar.

Se definen dos números, el número de dispositivo mayor y el número de dispositivo menor, el primero se refiere al tipo de dispositivo (disco, terminal, impresora, etc. ) y el segundo a cual de esos de dispositivos se refiere. Los número de dispositivo pueden observarse al listar /dev. Otro archivo especial es la tubería (pipe), este es un pseudo archivo que se usa para conectar dos proceso, cuando un proceso A desea enviar datos a otro proceso B, aquél escribe en la tubería. El proceso B puede leer los datos al leer la tubería.

El intérprete de comandos llamado shell (concha) no es parte del sistema operativo, pero hace un uso intenso de las llamadas al sistema. Cuando un usuario entra al sistema, se inicia un shell. Una vez activado el shell espera a que el usuario emita un comando. Cuando se emite un comando el shell crea un proceso derivado y espera a que este termine.

LLAMADAS AL SISTEMA La llamada fork produce una copia idéntica del proceso padre, el valor que genera es cero en el hijo y pid en el padre. while (TRUE) { /* repetir por siempre */ /* leer la entrada desde la terminal */ read_command(command, parameters); if (fork() != 0){ /* ramificar el proceso hijo */ wait(&status); /*código padre */ }else { execve(command, parameters, 0); /* código hijo */ } }

Los procesos tienen tres segmentos: texto, datos y pila. En este ejemplo, Los tres están en el espacio de dirección, pero también se soportan espacios para datos e instrucciones separados.

Llamadas al sistema para señalación (1) 2 3* (4)* (5)* (6)* (7)* (8)* 9 (10)* (11)* (12)* 13 14 15 16 SIGHUP El modem ha detectado una conexión telefónica rota SIGINT Se ha oprimido la llave DEL en el teclado SIGQUIT Señal de renuncia del teclado SIGILL Instrucción ilegal SIGTRAP Trampa de seguimiento SIGIOT Instrucción IOT SIGEMT Instrucción EMT SIGFPE Desbordamiento/insuficiencia de punto flotante SIGKILL Eliminación SIGBUS Error de bus SIGSEGV Violación de la segmentación SIGSYS Argumento erróneo para la llamada al sistema SIGPIPE Escritura en tubería sin lector SIGALRM Alarma SIGTERM Señal de terminación generada por el software no asignado

$Estructura para STAT y FSTAT: struct stat { short st_dev; /* dispositivo a donde$

Estructura para STAT y FSTAT: struct stat { short st_dev; /* dispositivo a donde pertenece el nodo i */ unsigned short st_ino; /* número de nodo i */ unsigned short st_node; /* palabra de nodo */ short st_nlink; /* número de enlaces */ short st_uid; /* id del usuario */ short st_gid; /* id del grupo */ short st_rdev; /* dispositivo mayor/menor de archivos esp. */ }; long st_size; /* tamaño del archivo */ long st_atime; /* igual que st_mtime */ long st_mtime; /* hora de la última modificación */ long st_ctime; /* igual que st_mtime */

pipeline(process 1, process 2) char *process 1, *process 2; /* apuntadores a los nombres del programa */ { int fd[2]; pipe(&fd[0]); /* crea una tubería */ if (fork != 0) { /* El proceso padre ejecuta estas proposiciones */ close(fd[0]); /* el proceso 1 no necesita leer de la tubería */ close(STD_OUTPUT); /* prepárese para la nueva salida estándar */ dup(fd[1]); /* fijar la salida estándar en fd[1] */ close(fd[1]); /* la tubería ya no se necesita */ execl(process 1, 0); } else {/* El proceso hijo ejecuta estas proposiciones */ close(fd[1]); /* el proceso 2 no necesita escribir de la tubería */ close(STD_INPUT); /* prepárese para la nueva entrada estándar */ dup(fd[0]); /* fijar la salida estándar en fd[0] */ close(fd[0]); /* la tubería ya no se necesita */ execl(process 2, 0); } }

$struct sgttyb { char sg_ispeed; /* velocidad de entrada (no se usa ahora) */$

struct sgttyb { char sg_ispeed; /* velocidad de entrada (no se usa ahora) */ char sg_ospeed; /* velocidad de salida (no se usa ahora) */ char sg_erase; /* borrar carácter */ char sg_kill; /* eliminar carácter */ int sg_flag; /* indicaciones de modo */ }; /* campos en sg_flags. */ #define XTABS 0006000/* ocacionar la expansión tabular */ #define RAW 0000040/* actvar el modo no elaborado */ #define CRMOD 0000020/* hacer el mapa lf igual a cr + lf */ #define ECHO 0000010/* activar el eco de la entrada tecleada */ #define CBREAK 0000002 /* activar el modo cbreak */ #define COOKED 0000000 /* ni CBREAK ni RAW */ #define TIOCGETP (('t'<<8) | 8) #define TIOCSETP (('t'<<8) | 9)