int selectInterrupt(global tabla){
if(mtexto)printf("INTERRUPCION.I--%s\n",tabla.cabecera->name);
int i=0,respuesta,status=1,fdmax=*(tabla.maxfd);
char mensaje[128],mensajeError[64],numero[16],data[8];
answer aux;
fd_set readfds;
readfds=*(tabla.original->original);
if(selectGRID_planificador(fdmax,&readfds)>0){
while ((!FD_ISSET(i,&readfds))&&(i<=fdmax)){
i++;
}
log_trace(tabla.logging.trace,"\t\t\t------INTERRUPT------\t\t\t","TRACE");
strcpy(mensaje,"Nº:I");
itoa(i,numero,10);
strcat(mensaje,"--Socket:(Esp./Recv.)-Msj:(Esp./Recv.)-(Msj/Cont/Dat/Sym)--Duenio: --(N/");
strcat(mensaje,numero);
strcat(mensaje,")--(");
if (i>fdmax){
if(mtexto)puts("--ERROR:No se encontro candidato para selectear!!--");
strcpy(mensajeError,"Nº:I");
strcat(mensajeError,"-ERROR:No se encontro candidato para selectear!!");
log_info(tabla.logging.info,mensaje,"ERROR");
exit(1);
}else{
if(mtexto)printf("INTERRUPCION.MID.I--%s\n",tabla.cabecera->name);
respuesta=recvAnswer(&aux,i);
if(mtexto)printf("INTERRUPCION.MID.F--%s\n",tabla.cabecera->name);
strcat(mensaje,"ALL/");
itoa((int)aux.msg,numero,10);
strcat(mensaje,numero);
strcat(mensaje,")--(");
strcat(mensaje,numero);
itoa((int)aux.cont,numero,10);
strcat(mensaje,"/");
strcat(mensaje,numero);
strcat(mensaje,"/");
data[0]=aux.data;
data[1]='\0';
strcat(mensaje,data);
strcat(mensaje,"/");
data[0]=aux.symbol;
data[1]='\0';
strcat(mensaje,data);
strcat(mensaje,")--Duenio:");
if(i==tabla.cabecera->nid) strcat(mensaje,tabla.cabecera->name);
else {
data[0]=buscarSimbolo(i,tabla);
data[1]='\0';
strcat(mensaje,data);
}
strcat(mensaje,".");
log_trace(tabla.logging.trace,mensaje,"TRACE");
status=interrupcion(i,respuesta,&aux,tabla);
log_trace(tabla.logging.trace,"\t\t\t------INTERRUPT------\t\t\t","TRACE");
}
}
if(mtexto)printf("INTERRUPCION.F--%s\n",tabla.cabecera->name);
//}while(muerto);
return status;
}
/**
* 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);
}
}
