char* serializarFinQuantum(t_pcb *pcb, uint32_t *totalPaquete, char* resultadosDeEjecuciones) {
uint32_t cabecera = FIN_QUANTUM;
uint32_t offset=0;
uint32_t tamanioenterosPCB, tamaniopath, tamanioCabecera, path, tamanioMensajes, tamanioCabeceraMensaje;
tamanioenterosPCB = 4 * sizeof(uint32_t); //4 int de pcb
tamaniopath = sizeof(uint32_t);
tamanioCabecera = sizeof(cabecera);
path = strlen(pcb->path);
tamanioCabeceraMensaje = sizeof(uint32_t);
tamanioMensajes = strlen(resultadosDeEjecuciones);
*totalPaquete = tamanioCabecera + tamanioCabeceraMensaje + tamanioMensajes + tamanioenterosPCB + tamaniopath + path;
char *paqueteSerializado = malloc(*totalPaquete);
int medidaAMandar;
medidaAMandar = tamanioCabecera;
memcpy(paqueteSerializado + offset, &cabecera, medidaAMandar);
offset += medidaAMandar;
medidaAMandar = tamanioCabeceraMensaje ;
memcpy(paqueteSerializado + offset, &tamanioMensajes, medidaAMandar);
offset += medidaAMandar;
medidaAMandar = tamanioMensajes;
memcpy(paqueteSerializado + offset, resultadosDeEjecuciones, medidaAMandar);
offset += medidaAMandar;
return serializarPCB(pcb, offset, paqueteSerializado);
}
int main(void) {
tipoPCB pcb;
pcb.estado = 'm';
pcb.insPointer = 123;
pcb.pid = 100;
pcb.ruta = "tuvieja";
imprimirPCB(pcb);
void* buffer = serializarPCB(pcb);
tipoPCB pcbRecibido;
deserializarPCB(buffer, &pcbRecibido);
imprimirPCB(pcbRecibido);
return EXIT_SUCCESS;
}
int main(int argc,char **argv){
printf("%s", "\n\n****** INICIO CPU ******\n\n");
sigusr1_desactivado=1;
signal(SIGUSR1, sig_handler);
signal(SIGINT, sig_handler2);
log= log_create(ARCHIVOLOG, "CPU", 0, LOG_LEVEL_INFO);
log_info(log,"Iniciando CPU\n");
char* serializado;
pthread_mutex_init(&mutex_pcb, NULL);
t_paquete* paquete_recibido;
levantar_configuraciones();
umc = conectarConUmc();
nucleo = conectarConNucleo();
t_paquete* datos_kernel=recibir(nucleo);
asignar_datos_de_nucleo(datos_kernel);
liberar_paquete(datos_kernel);
while(sigusr1_desactivado){
log_info(log,"sigusr1: %d", sigusr1_desactivado);
programaBloqueado = 0;
programaFinalizado = 0;
programaAbortado = 0;
int quantum_aux=quantum;
log_info(log,"Esperando Pcb\n");
//while(sigusr1_desactivado){
flag=1;
datos_kernel=recibir(nucleo);
asignar_datos_de_nucleo(datos_kernel);
liberar_paquete(datos_kernel);
flag=0;
//}
paquete_recibido = recibir(nucleo);
log_info(log,"Deserializando PCB\n");
pcb = desserializarPCB(paquete_recibido->data);
log_info(log,"Recibi PCB del nucleo con el program counter en: %d y SizeContextoActual en %d\n", pcb->pc, pcb->sizeContextoActual);
log_info(log,"Pcb pid: %d\n",pcb->pid);
int pid = pcb->pid;
var_max=(tamanioPag*(stack_size+pcb->paginasDeCodigo))-1;
log_info(log, "Enviando pid %d a UMC\n",pcb->pid);
enviar(umc, 3, sizeof(int), &pid);
log_info(log, "Envie pid %d a UMC\n",pcb->pid);
liberar_paquete(paquete_recibido);
while((quantum_aux!=0) && !programaBloqueado && !programaFinalizado && !programaAbortado){
t_direccion* datos_para_umc = malloc(12);
crearEstructuraParaUMC(pcb, tamanioPag, datos_para_umc);
log_info(log, "Direccion= Pag:%d Offset:%d Size:%d\n", datos_para_umc->pagina, datos_para_umc->offset, datos_para_umc->size);
log_info(log, "Pido instruccion\n");
char* sentencia=leer(datos_para_umc->pagina,datos_para_umc->offset, datos_para_umc->size);
if(sentencia==NULL){
programaAbortado=1;
log_info(log,"Cambiando flag programaAbortado a %d\n", programaAbortado);
}else{
log_info(log, "Recibi instruccion de UMC con tamanio %d\n", datos_para_umc->size);
char* barra_cero="\0";
memcpy(sentencia+( datos_para_umc->size-1), barra_cero, 1);
log_info(log,"Tamanio sentencia: %d\n", strlen(sentencia));
log_info(log,"Recibi sentencia: %s\n", depurarSentencia(sentencia));
analizadorLinea(depurarSentencia(sentencia), &primitivas, &primitivas_kernel);
free(datos_para_umc);
free(sentencia);
pcb->pc++;
quantum_aux--;
usleep(quantum_sleep*1000);
}
if (programaBloqueado){
log_info(log, "El programa salió por bloqueo\n");
log_info(log, "PC= %d\n", pcb->pc);
serializado = serializarPCB(pcb);
if(!sigusr1_desactivado){
log_info(log,"mande el flag");
int algo;
enviar(nucleo,399,sizeof(int),algo);
usleep(300*1000);
}
enviar(nucleo, 340, ((t_pcb*)serializado)->sizeTotal, serializado);
free(serializado);
destruirPCB(pcb);
}
if (programaAbortado){
log_info(log, "El programa aborto\n");
log_info(log, "El pcb que sale por aborto tiene pid %d\n",pcb->pid);
serializado = serializarPCB(pcb);
if(!sigusr1_desactivado){
log_info(log,"mande el flag");
int algo;enviar(nucleo,399,sizeof(int),algo);usleep(1000*300);
}
enviar(nucleo, 370, ((t_pcb*)serializado)->sizeTotal, serializado);
free(serializado);
destruirPCB(pcb);
}
if((quantum_aux==0) &&!programaFinalizado&&!programaBloqueado&&!programaAbortado){
log_info(log,"**Saliendo por fin de quantum\n");
log_info(log,"**SizeContextoActual antes: %d\n", pcb->sizeContextoActual);
serializado = serializarPCB(pcb);
log_info(log,"SizeContextoActual despues: %d\n", pcb->sizeContextoActual);
if(!sigusr1_desactivado){
log_info(log,"mande el flag");
int algo;enviar(nucleo,399,sizeof(int),algo);
usleep(300*1000);
}
enviar(nucleo, 304, ((t_pcb*)serializado)->sizeTotal, serializado);
free(serializado);
destruirPCB(pcb);
log_info(log,"destrui pcb\n");
}
}
}
log_info(log,"Se cierra por senial SIGUSR1\n");
printf("SALI BIEN\n");
int algo2;enviar(nucleo,4,sizeof(int),algo2);
close(nucleo);
close(umc);
exit(EXIT_SUCCESS);
}
