// Nombre: idProcesos

// Propósito: muestra el PID de procesos padre e hijo

// Autor: E. Carrasco
// FCreación: 11/02/2008
// FModificación: 27/02/2013

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h> // Librería necesaria para getpid() y getppid()

int main() {
// Variables para almacenar los identificadores de proceso
pid_t id_proceso;
pid_t id_padre;

// Indicar propósito del programa

puts("\n==== ESTE PROGRAMA MUESTRA EL IDENTIFICADOR DE PROCESO DE UN PROCESO Y
DE SU PROCESO PADRE ====\n");

// Obtener identificadores
id_proceso = getpid(); // Obtiene el PID del proceso actual
id_padre = getppid(); // Obtiene el PID del proceso padre

// Mostrar resultados
printf("Identificador de proceso: %d\n", id_proceso);
printf("Identificador del proceso padre: %d\n", id_padre);

// Salir del programa

return 0;
}

// Nombre: nombreMasId
// Propósito: muestra el nombre y el identificador de un proceso
// Autor: Edwin Carrasco
// FCreación: 27/02/2013
// FModificación: ----

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h> // Necesario para getpid()

int main(int argc, char *argv[]) {

// Variables
char *nombreDePrograma = argv[0]; // Lee el nombre del programa desde la línea
de comandos
pid_t processId;

// Indicar propósito del programa

puts("\n==== ESTE PROGRAMA MUESTRA SU NOMBRE Y SU IDENTIFICADOR DE PROCESO
====\n");

// Obtener identificador de proceso

processId = getpid();

// Mostrar resultados
printf("Mi nombre de programa es: %s\n", nombreDePrograma);
printf("Mi identificador de proceso es: %d\n\n", processId);

// Salir del programa

 return 0;
}

// Nombre: infoProc
// Propósito: muestra información del usuario y el grupo de usuario que ejecuta un
proceso
// Autor: E. Carrasco
// FCreación: 11/02/2008
// FModificación: 27/02/2013

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h> // Necesario para getuid(), geteuid(), getgid()

int main() {
// Indicar propósito del programa
puts("\n==== ESTE PROGRAMA MUESTRA INFORMACIÓN DEL USUARIO QUE EJECUTA EL
PROCESO ====\n");

// Mostrar resultados
printf("Identificador de usuario: %d\n", getuid());
printf("Identificador de usuario efectivo: %d\n", geteuid());
printf("Identificador del grupo: %d\n", getgid());
printf("Identificador de grupo efectivo: %d\n", getegid());

// Salir del programa

return 0;
}

// Nombre: printHome
// Propósito: imprime el contenido de la variable de entorno HOME
// Autor: E. Carrasco
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <stdlib.h>

int main() {
// Variables
char *home = NULL;

// Indicar propósito del programa

puts("\n==== ESTE PROGRAMA MUESTRA EL CONTENIDO DE LA VARIABLE HOME DEL SISTEMA
====\n");

// Obtener y mostrar la variable de entorno HOME

home = getenv("HOME");
if (home == NULL)
printf("HOME no se encuentra definida\n");
else
printf("El valor de HOME es %s\n", home);

// Salir del programa

return 0;
}

// Nombre: entornoProc
// Propósito: imprime información del entorno de un proceso
// Autor: E. Carrasco
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>

extern char **environ; // Variable externa que almacena las variables de entorno

int main() {
// Variables
char **var;

// Indicar propósito del programa

puts("\n==== ESTE PROGRAMA MUESTRA INFORMACIÓN DEL ENTORNO DE UN PROCESO ====\
n");

// Mostrar variables de entorno

for (var = environ; *var != NULL; ++var)
printf("%s\n", *var);

// Salir del programa

return 0;
}

// Nombre: creaProcesoHijo
// Propósito: crea un proceso hijo y muestra su ID
// Autor: E. Carrasco
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
// Variables
pid_t forkReturn;

// Indicar propósito del programa

puts("\n==== ESTE PROGRAMA CREA UN PROCESO Y MUESTRA EL ID DEL PROCESO CREADO Y
DEL PROCESO CREADOR ====\n");

// Crear proceso
forkReturn = fork();

// Mostrar resultados
if (forkReturn == 0)
printf("Soy el proceso Hijo. Mi PID es %d\n", getpid());
else
printf("Soy el proceso Padre. Mi PID es %d\n", getpid());

// Salir del programa

return 0;
}

// Nombre: creaNHijos
// Propósito: crea N hijos para un proceso
// Autor: E. Carrasco
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
// Variables
pid_t forkReturn;
int i;
int n = 5; // Número de procesos hijo a crear

// Indicar propósito del programa

puts("\n==== ESTE PROGRAMA CREA N PROCESOS HIJO Y CADA UNO MUESTRA SU
IDENTIFICADOR Y EL DE SU PADRE ====\n");

// Crear procesos hijos

for (i = 0; i < n; i++) {
forkReturn = fork();
if (forkReturn == 0)
break; // Si es el hijo, salir del bucle
}

// Mostrar resultados
printf("%d; El padre del proceso %d es %d \n", i, getpid(), getppid());

// Salir del programa

return 0;
}

PRACTICAS LABORATORIO

// Soluciones a los ejercicios en lenguaje C

// Adaptado para ejecutarse en Porteus con GCC 4.5.2

// Nombre: jerarquiaProcesos
// Propósito: Crea una jerarquía de procesos en cadena (P1 → P2 → P3 → ... → Pn)
// Autor: Carlos Canal
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#define N 4 // Número de procesos en la jerarquía (se puede modificar)

int main() {
pid_t pid;
int nivel = 1; // Indica el nivel del proceso en la jerarquía

printf("Soy el proceso P%d con PID %d\n", nivel, getpid());

for (int i = 1; i < N; i++) {

pid = fork(); // Crear un nuevo proceso hijo

if (pid == 0) { // Proceso hijo

nivel++; // Aumenta el nivel de jerarquía
 printf("Soy el proceso P%d con PID %d, hijo de %d\n", nivel, getpid(),
getppid());
} else { // Proceso padre espera a su hijo
wait(NULL);
break; // El padre sale del bucle para evitar más forks
}
}
return 0;
}

// Ejercicio VII.2: Crear un proceso hijo que calcule el cuadrado, el padre calcula
el cubo
void cuadrado_y_cubo() {
int num;
printf("Ingrese un número: ");
scanf("%d", &num);
pid_t pid = fork();
if (pid == 0) {
printf("Hijo: El cuadrado de %d es %d\n", num, num * num);
} else {
wait(NULL);
printf("Padre: El cubo de %d es %d\n", num, num * num * num);
}
}

// Ejercicio VII.3: Crear un hijo, esperar su terminación y mostrar su estado

void esperar_hijo() {
pid_t pid = fork();
int status;
if (pid == 0) {
printf("Hijo ejecutándose (PID: %d)\n", getpid());
exit(5);
} else {
wait(&status);
printf("Padre: Hijo finalizó con estado %d\n", WEXITSTATUS(status));
}
}

// Ejercicio VII.4: vfork() para calcular la raíz cuadrada

void raiz_cuadrada() {
double num;
printf("Ingrese un número: ");
scanf("%lf", &num);
pid_t pid = vfork();
if (pid == 0) {
printf("Hijo: La raíz cuadrada de %.2f es %.2f\n", num, sqrt(num));
_exit(0);
} else {
wait(NULL);
}
}

// Ejercicio VII.5: Generar un número aleatorio y verificar si es primo

int es_primo(int num) {
if (num < 2) return 0;
for (int i = 2; i <= sqrt(num); i++) {
if (num % i == 0) return 0;
}
 return 1;
}
void verificar_primalidad() {
pid_t pid = fork();
if (pid == 0) {
srand(getpid());
int num = rand() % 100 + 1;
printf("Hijo: Número generado: %d\n", num);
exit(num);
} else {
int status;
wait(&status);
int num = WEXITSTATUS(status);
printf("Padre: El número %d es %s\n", num, es_primo(num) ? "primo" :
"compuesto");
}
}

int main() {
int opcion;
do {
printf("\nSeleccione una opción:\n");
printf("1. Jerarquía de procesos\n");
printf("2. Cuadrado y cubo\n");
printf("3. Esperar hijo\n");
printf("4. Raíz cuadrada\n");
printf("5. Primalidad\n");
printf("0. Salir\n");
printf("Ingrese su elección: ");
scanf("%d", &opcion);
switch (opcion) {
case 1: jerarquia_procesos(); break;
case 2: cuadrado_y_cubo(); break;
case 3: esperar_hijo(); break;
case 4: raiz_cuadrada(); break;
case 5: verificar_primalidad(); break;
}
} while (opcion != 0);
return 0;
}

RESUELTOSS

// Nombre: jerarquiaProcesos
// Propósito: Crea una jerarquía de procesos
// Autor: Carlos Canal
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
pid_t pid1, pid2;

// Crear primer hijo

 pid1 = fork();
if (pid1 == 0) {
// Primer hijo crea un segundo hijo
pid2 = fork();
if (pid2 == 0) {
printf("Soy el nieto con PID %d, hijo de %d\n", getpid(), getppid());
} else {
printf("Soy el hijo con PID %d, hijo de %d\n", getpid(), getppid());
}
} else {
printf("Soy el padre con PID %d\n", getpid());
}
return 0;
}

// Nombre: calcularCuadradoCubo
// Propósito: Crea un proceso hijo que calcula el cuadrado, mientras el padre
calcula el cubo
// Autor: Carlos Canal
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
int numero;
printf("Ingrese un número: ");
scanf("%d", &numero);

pid_t pid = fork();

if (pid == 0) {
printf("Hijo: El cuadrado de %d es %d\n", numero, numero * numero);
} else {
printf("Padre: El cubo de %d es %d\n", numero, numero * numero * numero);
}
return 0;
}

// Nombre: esperaHijo
// Propósito: Crea un hijo, espera su terminación y muestra su estado
// Autor: Carlos Canal
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main() {
pid_t pid = fork();
int estado;
if (pid == 0) {
printf("Hijo: Mi PID es %d\n", getpid());
} else {
wait(&estado);
printf("Padre: Mi hijo ha terminado con estado %d\n", estado);
 }
return 0;
}

// Nombre: calcularRaiz
// Propósito: Usa vfork() para calcular la raíz cuadrada en el hijo y mostrar el
resultado en el padre
// Autor: Carlos Canal
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <math.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
double numero, resultado;
printf("Ingrese un número: ");
scanf("%lf", &numero);

pid_t pid = vfork();

if (pid == 0) {
resultado = sqrt(numero);
_exit(0);
} else {
wait(NULL);
printf("La raíz cuadrada de %.2f es %.2f\n", numero, resultado);
}
return 0;
}

// Nombre: verificaPrimo
// Propósito: Hijo genera número aleatorio, padre verifica si es primo
// Autor: Carlos Canal
// FCreación: 11/02/2008
// FModificación: 28/02/2013

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int esPrimo(int num) {

if (num < 2) return 0;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) return 0;
}
return 1;
}

int main() {
int numero;
pid_t pid = fork();

if (pid == 0) {
srand(getpid());
numero = rand() % 100 + 1;
 printf("Hijo: Número generado %d\n", numero);
exit(numero);
} else {
int estado;
wait(&estado);
numero = WEXITSTATUS(estado);
printf("Padre: El número %d es %s\n", numero, esPrimo(numero) ? "primo" :
"no primo");
}
return 0;
}