Instituto Tecnológico de Tepic

Ingeniería en sistemas computacionales

Materia: Sistemas Operativos I
Unidad 2: Administración del procesador y procesos
Llamadas al sistema para
administrar procesos en los sistemas Operativos
Alumnos:
Enciso Luna Cristian Gerardo 19400563
Paredes Curiel Sebastián 18401174
Aguilar Valdivia Josué Nomar 18401079
Catedrático: Efraín Padilla Valera
Fecha de entrega: 25 de octubre de 2021
Los procesos son una de las abstracciones más antiguas e importantes que proporcionan
los sistemas operativos estos proporcionan la capacidad de operar concurrentemente,
incluso cuando hay un CPU disponible. (convierten una CPU en varias CPU virtuales.) sin la
abstracción de procesos la computación moderna no podría existir. En cuanto los hilos son
mini procesos o procesos ligeros dentro de un proceso en donde cada proceso tiene un solo
hilo de control, esto ayuda a que un proceso al descomponerse en hilos, el modelo de
programación se simplifica.
Si queremos que nuestro programa empiece a ejecutar varias cosas "a la vez", tenemos dos
opciones. Por una parte, podemos crear un nuevo proceso y por otra, podemos crear un
nuevo hilo de ejecución (un thread). En realidad, nuestro ordenador, salvo que tenga varias
cpu, no ejecutará varias cosas a la vez. Cuando digo "a la vez", me refiero a que el sistema
operativo irá ejecutando cachos de programa por turnos (por rodajas de tiempo) de forma
muy rápida, dando la sensación de simultaneidad.

1
Llamadas al sistema para administrar procesos en
Linux
Las llamadas al sistema son puntos de entrada al núcleo (kernel) de Linux. Éstas
usualmente no son invocadas de forma directa, sino que se utilizan funciones
wrapper de la librería del lenguaje C, glibc, para que estas hagan una serie de
pasos necesarios para que la llamada sea exitosa. Estos wrappers normalmente
tienen el mismo nombre de la función original y el trabajo que hacen es mínimo
la mayoría de las veces.
Cuando una llamada al sistema falla retorna un número de error negativo, pero
la función de C retorna -1 y le asigna este número de error negado (positivo) a
la variable errno (errno.h).
Aunque no es el caso común, algunas de las llamadas al sistema no tienen una
función equivalente proveída por la librería de C, así que hay que llamarlas
directamente mediante la función syscall (sys/syscall.h).
Algunas llamadas al sistema relacionadas con los procesos. El código de retorno
s es 1 si ocurre un error, pid es un ID de proceso y residual es el tiempo restante
en la alarma anterior. Los parámetros son lo que los nombres sugieren.

Llamada al sistema Descripción

pid = fork( ) Crea un proceso hijo idéntico al padre

pid = waitpid(pid, &statloc, Espera a que un hijo termine

opts)

s = execve(name, argv, envp) Reemplaza la imagen del núcleo de un proceso

exit(status) Termina la ejecución del proceso y devuelve el

estado

s = sigaction(sig, &act, Define la acción a realizar en las señales

&oldact)

s = sigreturn(&context) Regresa de una señal

s = sigprocmask(how, &set, Examina o cambia la máscara de la señal

&old)

s = sigpending(set) Obtiene el conjunto de señales bloqueadas

s = sigsuspend(sigmask) Reemplaza la máscara de la señal y suspende el

proceso

2
 s = kill(pid, sig) Envía una señal a un proceso

residual = alarm(seconds) Establece el reloj de alarma

s = pause( ) Suspende el proceso que hizo la llamada hasta la

siguiente señal

Llamadas al sistema para administrar procesos en

Windows
En Windows encontramos que por cada llamada al sistema existe un
procedimiento de biblioteca que los invoca. Por ello Windows ha creado un
conjunto de procedimientos, llamado API Win32 [5], que se ha de utilizar para
solicitar servicios al sistema operativo. La creación de procesos en Windows se
genera mediante la llamada CreateProcess, que tanto crea el proceso como
carga el programa en el nuevo proceso. Esta llamada tiene 10 parámetros: el
programa a ejecutar, atributos de seguridad, bits de control de archivos
abiertos, prioridad, especificación de la ventana a crear y un apuntador a la
estructura a la que al invocador se le devuelve información del proceso recién
creado. CreateProcess tiene 100 funciones más para administrar y sincronizar
procesos.
Algunas de las llamadas de Win32 para administrar procesos, hilos y fibras
son:

Función de la API Descripción

Win32

CreateProcess Crea un proceso

CreateThread Crea un hilo en un proceso existente

CreateFiber Crea una fibra

ExitProcess Termina el proceso actual con todos sus hilos

ExitThread Termina este hilo

ExitFiber Termina esta fibra

SwitchToFiber Ejecuta una fibra distinta en el hilo actual

SetPriorityClass Establece la clase de prioridad para un proceso

SetThreadPriority Establece la prioridad para un hilo

3
 CreateSemaphore Crea un nuevo semáforo

CreateMutex Crea un nuevo mutex

OpenSemaphore Abre un semáforo existente

OpenMutex Abre un mutex existente

WaitForSingleObject Se bloquea en un solo semáforo, mutex, etc

WaitForMultipleObjects Se bloquea en un conjunto de objetos cuyos manejadores

se proporcionan

PulseEvent Establece un evento como señalado, y después como no

señalado

ReleaseMutex Libera un mutex para que otro hilo lo pueda adquirir

ReleaseSemaphore Incrementa el conteo de semáforos en 1

EnterCriticalSection Adquiere un bloqueo en una sección crítica

LeaveCriticalSection Libera el bloqueo en una sección crítica

Llamadas al sistema para administrar procesos en

Unix
Las implementaciones clásicas de Unix administran los procesos en un
esquema similar al de nSystem. La estrategia de scheduling de procesos es un
poco más elaborada pues implementa procesos con prioridades y al mismo
tiempo intenta dar un buen tiempo de respuesta a los usuarios interactivos,
algo que no es fácil de lograr debido a las restricciones que impone la memoria
del procesador.
Entre los aspectos más destacados de la gestión de procesos en UNIX se
encuentra la forma en que éstos se crean y cómo se ejecutan nuevos
programas, así como las siguientes funciones:

Función Descripción Categoría

fork() Crear procesos Control de procesos

exit() Finaliza al proceso

4
 wait() Espera hasta que uno de los procesos termine

open() Crear / abrir un archivo Manipulación de

archivos
read() Lee un archivo

write() Edita un archivo

close() Cierra un archivo

ioctl() Permite a una aplicación controlar o comunicarse con un driver manipulación de

de dispositivo dispositivos

read() Abrir un dispositivo

write() Edita un dispositivo

getpid() Devuelve el ID del proceso (PID) del proceso que llama Mantenimiento de
información
alarm() Devuelve el número de segundos que faltan para que se emita
cualquier alarma previamente programada, o cero si no había
ninguna alarma programada.

sleep() Permite suspender la ejecución actual (comando) por un

intervalo de tiempo determinado.

pipe() Conexión entre dos procesos Comunicación

shm open() Crea y abre un nuevo objeto de memoria compartida POSIX, o

abre uno ya existente.
existente

mmap() Asigna archivos o dispositivos a la memoria

chmod() Obtener / establecer permisos a un archivo Protección

umask() Establece los permisos por defecto para los nuevos archivos y
directorios creados por el proceso actual.

chown() Cambia al propietario de un archivo

5
Gestión de señales Posix
En primer lugar, POSIX significa Portable Operating System Interface. Consiste
en una familia de estándares especificadas por la IEEE con el objetivo de
facilitar la interoperabilidad de sistemas operativos. Además, POSIX establece
las reglas para la portabilidad de programas. Por ejemplo, cuando se desarrolla
software que cumple con los estándares POSIX existe una gran probabilidad
de que se podrá utilizar en sistemas operativos del tipo Unix. Si se ignoran
tales reglas, es muy posible que el programa o librería funcione bien en un
sistema dado pero que no lo haga en otro.
Objetivo de la práctica
Esta práctica permite al alumno familiarizarse con los servicios para la gestión
de señales en POSIX. Se debe realizar un programa que calcule la tasa de
fallos, es decir, la tasa de señales que se generan. Para ello se ejecutarán de
forma aleatoria las siguientes señales:
SIGPIPE: Se envía a un proceso cuando intenta escribir en una tubería sin un
proceso conectado al otro extremo.
SIGFPE: Esta se envía a un proceso cuando se detecta error aritmético de
punto flotante o entero.
SIGSEGV: Significa una señal de violación de acceso a la memoria, tratando
de leer o escribir desde/hacia un área de memoria a la que su proceso no tiene
acceso.
SIGBUS: Es la señal que envía un programa cuando ha habido un error en el
bus. Las condiciones que conducen al envío de la señal son, por ejemplo, una
alineación incorrecta del acceso a la memoria o una dirección física inexistente.
SIGILL: Se envía a un proceso cuando intenta ejecutar una instrucción ilegal,
mal formada o desconocida. Mientras que algunos compiladores proporcionan
automáticamente un valor de retorno predeterminado, otros enviarán un SIGILL
o SIGTRAP en tiempo de ejecución cuando intenten dejar una función sin un
valor de retorno.

6
Código de la práctica:
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>

#define INTENTOS 1000

#define sSIGFPE 1
#define sSIGPIPE 2
#define sSIGSEGV 3
#define sSIGBUS 4
#define sSIGILL 5

int modulo_I()
{
int num = 1+rand()%(6-1);
return num;
}

void modulo1(void);
void modulo2(void);
void modulo3(void);

int main(void){
srand(time(NULL));
int i;
float cSIGFPE = 0;
float cSIGPIPE = 0;
float cSIGSEGV = 0;
float cSIGBUS = 0;
float cSIGILL = 0;

for (i = 0; i <= INTENTOS; i++){

switch (modulo_I()){
case sSIGFPE:
//Si devuelve SIGFPE entonces cuenta
cSIGFPE++;
break;
case sSIGPIPE:
//Si devuelve SIGPIPE entonces cuenta
cSIGPIPE++;
break;
case sSIGSEGV:
//Si devuelve SIGSEGV entonces cuenta
cSIGSEGV++;
break;
case sSIGBUS:
//Si devuelve SIGBUS entonces cuenta
7
 cSIGBUS++;
break;
case sSIGILL:
//Si devuelve SIGILL entonces cuenta
cSIGILL++;
break;
}
}

// Muestra los porcentajes de error

printf(" Porcentajes de SIGFPE: %4.2f\n",cSIGFPE * 100 / INTENTOS);
printf(" Porcentajes de SIGPIPE: %4.2f\n",cSIGPIPE * 100 / INTENTOS);
printf(" Porcentajes de SIGSEGV: %4.2f\n",cSIGSEGV * 100 / INTENTOS);
printf(" Porcentajes de SIGBUS: %4.2f\n",cSIGBUS * 100 / INTENTOS);
printf(" Porcentajes de SIGILL: %4.2f\n",cSIGILL * 100 / INTENTOS);
//para finalizar la función main debe devolver un valor
return(0);
}

Resultado:

8
Lo procesos son creados y destruidos por el sistema operativo, así como también este se
debe hacer cargo de la comunicación entre procesos. El mecanismo por el cual un proceso
crea otro proceso se denomina bifurcación. El sistema operativo es el responsable de
determinar las pautas de intercalado y asignación de recursos a cada proceso.
Si existe un esquema con diferentes niveles de prioridad de procesos es conveniente
mantener varias colas de procesos listos, una para cada nivel de prioridad, lo que ayuda a
determinar cuál es el proceso que más conviene ejecutar a continuación.

The IEEE and The Open Group. Posix.1-2008 – the open group base specifications issue 7,
2008. Available from: http://pubs.opengroup.org/onlinepubs/9699919799/.
Carretero, G. P. (2013). Monitoreo de Procesos en Linux, Windows. En Zarpele, Libro de
prácticas de Sistemas Operativos (págs. 43-50). Madrid: McGrawHill.
Tanenbaum, A. (2009). Sistemas Operativos Modernos. (3ra Edición). PEARSON
EDUCACIÓN.