void ejecutoInstruccion(char* programa_ansisop, t_metadata_program* metadata, int numeroDeInstruccion){ t_puntero_instruccion inicio; int offset; t_intructions instr = metadata->instrucciones_serializado[numeroDeInstruccion]; inicio = instr.start; offset = instr.offset; char* instruccion = malloc(offset+1); //instruccion = obtener_cadena(programa_ansisop, inicio, offset); memset(instruccion, '\0', offset); strncpy(instruccion, &(programa_ansisop[inicio]), offset); analizadorLinea(instruccion, &funciones, &funciones_kernel); free(instruccion); }
int execute_line(void *instruction_line) { if(strcmp(instruction_line, "end") == 0) { //End of program reached status_update(EXIT); return EXIT; } log_info(cpu_log, "Starting delay of : %d seconds", actual_kernel_data->QSleep/1000); usleep(actual_kernel_data->QSleep * 1000); analizadorLinea((char*) instruction_line, &funciones_generales_ansisop, &funciones_kernel_ansisop); log_info(cpu_log, "Finished line %d execution", actual_pcb->program_counter); return SUCCESS; }
int main(int argc, char **argv) { printf("Ejecutando\n"); char *programa = strdup(PROGRAMA); t_metadata_program *metadata = metadata_desde_literal(programa); int programCounter = 0; while(!terminoElPrograma()){ char* const linea = conseguirDatosDeLaMemoria(programa, metadata->instrucciones_serializado[programCounter].start, metadata->instrucciones_serializado[programCounter].offset); printf("\t Evaluando -> %s", linea); analizadorLinea(linea, &functions, &kernel_functions); free(linea); programCounter++; } metadata_destruir(metadata); printf("================\n"); return EXIT_SUCCESS; }
void ejecutar() { int quantum; char *instruccion; pcb_actual = recibirPcb(socket_nucleo, false, &quantum); printf("Ejecuto el programa pid: %d.\n",pcb_actual.pid); printf("quantum: %d.\n", quantum); //Vuelvo el estado al original estado = TODO_OK; int i; for(i=0;i<quantum;i++) { usleep(quantum_sleep * 1000);//Sleep enunciado if(estado != TODO_OK) break; if(senial_activada) break; t_intructions instruction = pcb_actual.indice_cod.instrucciones[pcb_actual.PC]; instruccion = solicitarInstruccion(instruction); if(instruccion == NULL){ estado = ERROR; break; } printf("Voy a entrar a analizador linea.\n"); analizadorLinea(instruccion, &funciones, &funciones_kernel); printf("Salgo de analizador linea.\n"); //Avanzo el PC pcb_actual.PC++; free(instruccion); } if( senial_activada ) { printf("Terminando ejecucion por SIGUSR1.\n"); apagarse(); } if(estado == TODO_OK) {//Termino el quantum. Envio el pcb con las modificaciones que tuvo enviarPcb(pcb_actual, socket_nucleo, -1); //liberarPcb(pcb_actual); printf("Se me termino el quantum.\n"); } else if( estado == ENTRADA_SALIDA || estado == WAIT ) { printf("Estoy bloqueado...\n"); //Envio el pcb enviarPcb(pcb_actual,socket_nucleo,-1); //liberarPcb(pcb_actual); return; }else if( estado == FIN_PROGRAMA) { printf("Termino el programa.\n"); return; }else if( estado == ERROR ) { socketes_finalizar(); } }
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); }
void correrRetornar(){ printf("Ejecutando '%s'\n", RETORNAR); analizadorLinea(strdup(RETORNAR), &functions, &kernel_functions); printf("================\n"); }
void correrFunction(){ printf("Ejecutando '%s'\n", FUNCTION); analizadorLinea(strdup(FUNCTION), &functions, &kernel_functions); printf("================\n"); }
void correrFinalizar() { printf("Ejecutando '%s'\n", FINALIZACION); analizadorLinea(strdup(FINALIZACION), &functions, &kernel_functions); printf("================\n"); }
void correrImprimir() { printf("Ejecutando '%s'\n", IMPRIMIR); analizadorLinea(strdup(IMPRIMIR), &functions, &kernel_functions); printf("================\n"); }
void correrImprimirTexto() { printf("Ejecutando '%s\n'", IMPRIMIR_TEXTO); analizadorLinea(strdup(IMPRIMIR_TEXTO), &functions, &kernel_functions); printf("================\n"); }
void correrAsignar() { printf("Ejecutando '%s'\n", ASIGNACION); analizadorLinea(strdup(ASIGNACION), &functions, &kernel_functions); printf("================\n"); }
void correrDefinirVariables() { printf("Ejecutando '%s'\n", DEFINICION_VARIABLES); analizadorLinea(strdup(DEFINICION_VARIABLES), &functions, &kernel_functions); printf("================\n"); }
int main(void) { char* sentencia; int i = 0; double quantum_ret; t_EstructuraInicial* est_quantum; config = config_create(getenv("CONFIG")); CrearLog(); log_info(Log, "----------------Comienza el proceso CPU----------------"); /* * Manejo de la interrupcion SIGUSR1 */ signal(SIGUSR1, sig_handler); log_info(Log, "Se abre conexion con el Kernel"); if ((socket_PCP = ConectarPCP()) < 0) { log_error(Log, "Ha ocurrido un error durante la conexion con el PCP"); return EXIT_FAILURE; } log_info(Log, "Se abre conexion con la UMV"); if ((socket_UMV = ConectarUMV()) < 0) { log_error(Log, "Ha ocurrido un error durante la conexion con la UMV"); return EXIT_FAILURE; } HandshakeUMV(); log_info(Log, "Se recibe el Quantum"); if ((est_quantum = RecibirQuantum()) < 0) { log_error(Log, "Error al recibir el Quantum"); return EXIT_FAILURE; } quantum_ret = (est_quantum->RetardoQuantum) / 1000; log_info(Log, "Comienza la ejecucion de las sentencias"); while (1) { operacion = NOTHING; log_info(Log, "Se recibe un PCB"); if (RecibirPCB(&pcb) < 0) { log_error(Log, "Error al recibir el PCB"); break; } operacion = SUCCESS; CambiarProcesoActivo(); log_info(Log, "Se crea el Diccionario de Variables"); //Funcion que arma el diccionario de variables a partir del pcb RecrearDiccionario(false); if (operacion == ERROR) break; log_info(Log, "Se obtiene el Array de Etiquetas"); //Funcion que obtiene el diccionario de etiquetas etiq_creadas = ObtenerDiccionarioEtiquetas(); if (operacion == ERROR) break; //Se ejecutan quantum instrucciones del programa for (i = 0; i < (est_quantum->Quantum); i++) { operacion = QUANTUM; pcb->PC++; log_debug(Log, "Se incrementa el valor del PC (Program Counter), que ahora vale: %d", pcb->PC); //Obtener proxima sentencia a ejecutar Indice de Codigo log_info(Log, "Se obtiene la proxima sentencia a ejecutar"); if ((sentencia = ObtenerSentencia(pcb)) == NULL ) break; log_debug(Log, "La sentencia es: %s", sentencia); //Parsear sentencia y Ejecutar operaciones requeridas log_debug(Log, "Se ejecuta el parser y las primitivas correspondientes"); analizadorLinea(strdup(sentencia), &functions, &kernel_functions); log_debug(Log, "Se ejecuta un retardo de %d milisegundos", est_quantum->RetardoQuantum); sleep(quantum_ret); free(sentencia); if (operacion != QUANTUM) break; } CambioContexto(); if (cerrarCPU) break; } log_debug(Log, "Cerrando CPU"); free(est_quantum); if (operacion != NOTHING) finalizarConexion(socket_PCP); finalizarConexion(socket_UMV); log_info(Log, "CPU cerrada"); log_destroy(Log); config_destroy(config); return EXIT_SUCCESS; }
void core_conexion_kernel(void){ if((sockKernel=socket_crearYConectarCliente(configuracion_cpu.ip_kernel,configuracion_cpu.puerto_kernel))==-1){ log_error_socket(); //abort(); } log_escribir(archLog, "Conexion", INFO, "Se conecto correctamente al Kernel"); t_tipoEstructura tipoRecibido; void* structRecibida; socket_recibir(sockKernel,&tipoRecibido,&structRecibida); t_struct_numero* k = ((t_struct_numero*)structRecibida); quantum = k->numero; free(k); log_escribir(archLog, "Quantum", INFO, "Se seteo el quantum en %d al ser recibido del kernel", quantum); socket_recibir(sockKernel,&tipoRecibido,&structRecibida); k = ((t_struct_numero*)structRecibida); configuracion_cpu.retardo= k->numero; free(k); int id; dicc_variables =dictionary_create(); t_struct_pcb* pcb_recibida; t_struct_pcb_io* pcb_actualizada; t_struct_numero * solicitarPCB; sem_wait(&sem_kernel); while(1){ t_tipoEstructura tipoRecibido; void* structRecibida; sleep(configuracion_cpu.retardo); solicitarPCB = malloc(sizeof(t_struct_numero)); solicitarPCB->numero = 1; int j = socket_enviar(sockKernel, D_STRUCT_NUMERO, solicitarPCB); if(j==1){ printf("Se solicita la liberacion de la cpu\n");}else{printf("NO MANDA\n");} free(solicitarPCB); fin_PCB = 0; sig_flag = 0; UMV_flag = 0; SEG_flag = 0; fin_quantum = 0; socket_recibir(sockKernel,&tipoRecibido,&structRecibida); if(tipoRecibido!=D_STRUCT_PCB){ printf("NO ES PCB!\nEs tipo %d\n", tipoRecibido); return; } pcb_recibida = ((t_struct_pcb*)structRecibida); log_escribir(archLog, "Recibida pcb", INFO, "Se recibio la pcb con pid: %d", pcb_recibida->pid); temp_id=pcb_recibida->pid; log_escribir(archLog, "PCB", INFO, "Se recibio el pid %d", temp_id); temp_cursor_stack= pcb_recibida->c_stack; temp_seg_codigo = pcb_recibida->codigo; temp_ind_codigo = pcb_recibida->index_codigo; var_ind_etiquetas = pcb_recibida->index_etiquetas; temp_counter = pcb_recibida->program_counter; var_seg_stack = pcb_recibida->stack; var_tamanio_contexto = pcb_recibida->tamanio_contexto; var_tamanio_etiquetas = pcb_recibida->tamanio_indice; temp_estado = pcb_recibida->estado; recupero_diccionario(dicc_variables,var_tamanio_contexto); while((fin_quantum!=quantum)&&(fin_PCB==0)){ t_struct_sol_bytes * solicitar_indice = malloc(sizeof(t_struct_sol_bytes)); solicitar_indice->base = temp_ind_codigo; solicitar_indice->offset = temp_counter * 8; solicitar_indice->tamanio = 2 * sizeof(uint32_t); socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, solicitar_indice); // free(solicitar_indice); /************************* Solicita indice *************************/ void * estructuraRecibida2; t_tipoEstructura tipoRecibido2; socket_recibir(sockUMV, &tipoRecibido2, &estructuraRecibida2); /************************* Recibe indice *************************/ uint32_t temp_tamanio; void * temp_buffer; temp_buffer = ((t_struct_respuesta_umv*) estructuraRecibida2)->buffer; temp_tamanio = ((t_struct_respuesta_umv*) estructuraRecibida2)->tamano_buffer; if (temp_tamanio == sizeof(int)) { int*respuesta2 = malloc(sizeof(int)); memcpy(respuesta2, ((t_struct_respuesta_umv*) estructuraRecibida2)->buffer, temp_tamanio); int valor = *respuesta2; printf("Valor respondido: %d",valor); if (valor ==-30) { excepcion_UMV(0); break; } } uint32_t indice_temp; uint32_t tamanio_temp; int off_set; memcpy(&indice_temp, temp_buffer, off_set = sizeof(uint32_t)); memcpy(&tamanio_temp, temp_buffer + off_set, sizeof(uint32_t)); t_struct_sol_bytes * solicitar_instruccion = malloc(sizeof(t_struct_sol_bytes)); solicitar_instruccion->base = temp_seg_codigo; solicitar_instruccion->offset = indice_temp; solicitar_instruccion->tamanio = tamanio_temp; /************************* Se solicita la proxima instruccion *************************/ socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, solicitar_instruccion); free(solicitar_instruccion); /************************* Se recibe la siguiente instruccion *************************/ void * estructuraRecibida3; t_tipoEstructura tipoRecibido3; socket_recibir(sockUMV, &tipoRecibido3, &estructuraRecibida3); int tamanio_instruccion = ((t_struct_respuesta_umv*) estructuraRecibida3)->tamano_buffer; if (tamanio_instruccion == sizeof(int)) { int*respuesta = malloc(sizeof(int)); memcpy(respuesta, ((t_struct_respuesta_umv*) estructuraRecibida3)->buffer, tamanio_instruccion); int valor = *respuesta; printf("Valor respondido: %d",valor); if (valor ==-30) { excepcion_UMV(0); break; } } char * codigo = malloc(tamanio_instruccion); memcpy(codigo, ((t_struct_respuesta_umv*) estructuraRecibida3)->buffer, tamanio_instruccion); // codigo=((t_struct_respuesta_umv*)estructuraRecibida3)->buffer; char** partes = string_split(codigo, "\n"); free(codigo); codigo = partes[0]; free(partes); printf("\n\n>>>>> %s\n\n", codigo); char * codigoContac = strcat(codigo, "\0"); analizadorLinea(codigoContac, &funciones_parser, &funciones_kernel); free(((t_struct_respuesta_umv*) estructuraRecibida3)->buffer); free(temp_buffer); free(estructuraRecibida3); free(estructuraRecibida2); free(codigo); sleep(configuracion_cpu.retardo); temp_counter++; fin_quantum++; signal(SIGUSR1, llegoSenialParaTerminar); if (sig_flag == 1 && (quantum - fin_quantum == 0)) { break; } } if(fin_PCB==0 && UMV_flag == 0){ t_struct_pcb* pcb_fin = malloc(sizeof(t_struct_pcb)); pcb_fin->c_stack=temp_cursor_stack; pcb_fin->codigo=temp_seg_codigo; pcb_fin->index_codigo=temp_ind_codigo; pcb_fin->index_etiquetas=var_ind_etiquetas; pcb_fin->pid=temp_id; pcb_fin->program_counter=temp_counter; pcb_fin->stack=var_seg_stack; pcb_fin->tamanio_contexto=var_tamanio_contexto; pcb_fin->tamanio_indice=var_tamanio_etiquetas; pcb_fin->estado=temp_estado; socket_enviar(sockKernel, D_STRUCT_PCB, pcb_fin); log_escribir(archLog,"Se envio la PCB al kernel",INFO,"El estado de finalizacion es normal"); } fin_quantum = 0; if (sig_flag == 1) { break; } } printf("Gracias al SIGUSR1, se sale del bucle"); t_struct_numero* valor = malloc(sizeof(t_struct_numero)); valor->numero=0; socket_enviar(sockUMV,D_STRUCT_NUMERO,valor); if(socket_cerrarConexion(sockUMV)==0){ log_escribir(archLog,"Cerrar Conexion",ERROR,"Finalizo la ejecucion de la CPU por SISGUR1"); } if(socket_cerrarConexion(sockKernel)==0){ log_escribir(archLog,"Cerrar Conexion",ERROR,"Finalizo la ejecucion de la CPU por SISGUR1"); } return; }
void correrSalto(){ printf("Ejecutando '%s'\n", SALTO); analizadorLinea(strdup(SALTO), &functions, &kernel_functions); printf("================\n"); }
int main(){ char *proxInstrucc; dic_Variables = dictionary_create(); cpu_file_log = txt_open_for_append("./CPU/logs/cpu.log"); txt_write_in_file(cpu_file_log,"---------------------Nueva ejecucion------------------------------\n"); txt_write_in_file(cpu_file_log, "Cargo la configuracion desde el archivo\n"); t_config *unaConfig = config_create("./CPU/cpu_config"); char *puertoKernel = config_get_string_value(unaConfig, "Puerto_Kernel"); char *ipKernel = config_get_string_value(unaConfig, "IP_Kernel"); char *puertoUmv = config_get_string_value(unaConfig, "Puerto_UMV"); char *ipUmv = config_get_string_value(unaConfig, "IP_UMV"); imprimo_config(puertoKernel, ipKernel, puertoUmv, ipUmv); printf("El PID de este CPU es %d \n", getpid()); /*conexion con el kernel*/ handshake_kernel(puertoKernel, ipKernel); /*conexion con la umv*/ handshake_umv(puertoUmv, ipUmv); /*maneja si recibe la señal SIGUSR, hay que revisarlo todavia*/ signal(SIGUSR1, signal_handler); signal(SIGINT, signal_handler); while(quit_sistema){ /*recibe un pcb del kernel*/ recibirUnPcb(); if(pcb == NULL) goto _fin; /* le digo a la UMV q cambie el proceso activo */ cambio_PA(pcb->id); traerIndiceEtiquetas(); /*se crea un diccionario para guardar las variables del contexto*/ regenerar_dicc_var(); for (quantum_actual = 0;(quantum_actual < quantum_max) && (!fueFinEjecucion) && (!entre_io) && (!sem_block); quantum_actual++){//aca cicla hasta q el haya terminado los quantums printf("Quantum nº%i\n",quantum_actual+1); proxInstrucc = solicitarProxSentenciaAUmv(); analizadorLinea(proxInstrucc, &functions, &kernel_functions); free(proxInstrucc); } if(!fueFinEjecucion){ salirPorQuantum(); } free(etiquetas); free(pcb); pcb = NULL; cambio_PA(0);//lo cambio a 0 asi la UMV puede comprobar q hay un error fueFinEjecucion = 0; huboSegFault = 0; entre_io = 0; sem_block = 0; } socket_cerrar(socketKernel); socket_cerrar(socketUmv); _fin: return 0; }
// main int main(int argc, char *argv[]) { signal(SIGINT, depuracion); signal(SIGUSR1, depuracion); // Definicion de variables seguirEjecutando = 1; // Mediante la señal SIGUSR1 se puede dejar de ejecutar el cpu // Obtengo datos de archivo de configuracion y se crea el logger variables = list_create(); config = config_create("../cpu.config"); strcpy(umvip, config_get_string_value(config, "UMV_IP")); strcpy(kernelip, config_get_string_value(config, "KERNEL_IP")); port_kernel = config_get_int_value(config, "PORT_KERNEL"); port_umv = config_get_int_value(config, "PORT_UMV"); config_destroy(config); logger = log_create("../logcpu.log", "CPU", true, LOG_LEVEL_INFO); log_info(logger, "Se leyo el arch de config y se creo el logger satisfactoriamente."); // Me conecto al kernel ConectarA(&sockKernel, &port_kernel, kernelip, &kernel_addr, logger); log_info(logger, "Conectado al kernel."); // Obtengo datos de la umv ConectarA(&sockUmv, &port_umv, umvip, &umv_addr, logger); log_info(logger, "Conectado a la UMV."); // Handshake con el kernel mensaje.id_proceso = CPU; mensaje.tipo = HANDSHAKE; strcpy(mensaje.mensaje, "Hola kernel."); send(sockKernel, &mensaje, sizeof(t_mensaje), 0); if (recv(sockKernel, &mensaje, sizeof(t_mensaje), 0) == 0) { log_error(logger, "Kernel desconectado."); depuracion(SIGINT); } if (mensaje.tipo == HANDSHAKEOK) { log_info(logger, "Handshake con kernel satisfactorio."); } else { log_error(logger, "Handshake con kernel erroneo."); depuracion(SIGINT); } // Handshake con la UMV msg_handshake.tipo = CPU; send(sockUmv, &msg_handshake, sizeof(t_msg_handshake), 0); if (recv(sockUmv, &msg_handshake, sizeof(t_msg_handshake), 0) == 0) { log_error(logger, "UMV desconectada."); depuracion(SIGINT); } if (msg_handshake.tipo == UMV) { log_info(logger, "Handshake con UMV satisfactorio."); } else { log_error(logger, "Handshake con UMV erroneo."); depuracion(SIGINT); } t_mensaje msg_aux; int i; int j; int quantum, retardo; int salir_bucle = 0; int inicio_instruccion = 0; int cantidad_letras_instruccion = 0; int pos_en_instruccion = 0; char buf[82]; // Variable auxiliar para almacenar la linea de codigo char instruccion[82]; int bufferaux[2]; if (recv(sockKernel, &mensaje, sizeof(t_mensaje), 0) == 0) { log_error(logger, "Kernel desconectado."); depuracion(SIGINT); } quantum = mensaje.datosNumericos; if (recv(sockKernel, &mensaje, sizeof(t_mensaje), 0) == 0) { log_error(logger, "Kernel desconectado."); depuracion(SIGINT); } retardo = mensaje.datosNumericos; if (recv(sockKernel, &mensaje, sizeof(t_mensaje), 0) == 0) { log_error(logger, "Kernel desconectado."); depuracion(SIGINT); } stack = mensaje.datosNumericos; char cadena_aux[15]; // Bucle principal del proceso while(seguirEjecutando) { // Recibo el pcb del kernel if (recv(sockKernel, &pcb, sizeof(t_pcb), 0) == 0) { log_error(logger, "Kernel desconectado."); depuracion(SIGINT); } log_info(logger,"Recibi PCB de Kernel"); // Regenero diccionario de variables regenerarDiccionario(); for (i = 0; i < quantum; i++) { if (proceso_bloqueado == 0 && proceso_finalizo == 0) { salir_bucle = 0; inicio_instruccion = 0; cantidad_letras_instruccion = 0; // Preparo mensaje para la UMV msg_solicitud_bytes.base = pcb.instruction_index; msg_solicitud_bytes.offset = pcb.program_counter * 8; msg_solicitud_bytes.tamanio = 8; msg_cambio_proceso_activo.id_programa = pcb.unique_id; mensaje.tipo = SOLICITUDBYTES; send(sockUmv, &mensaje, sizeof(t_mensaje), 0); send(sockUmv, &msg_cambio_proceso_activo, sizeof(t_msg_cambio_proceso_activo), 0); send(sockUmv, &msg_solicitud_bytes, sizeof(t_msg_solicitud_bytes), 0); // Espero la respuesta de la UMV if (recv(sockUmv, &mensaje, sizeof(t_mensaje), 0) == 0) { log_error(logger, "UMV desconectada."); depuracion(SIGINT); } if (recv(sockUmv, &bufferaux, 8, 0) == 0) { log_error(logger, "UMV desconectada."); depuracion(SIGINT); } // Preparo mensaje para la UMV msg_solicitud_bytes.base = pcb.code_segment; msg_solicitud_bytes.offset = bufferaux[0]; msg_solicitud_bytes.tamanio = bufferaux[1]; msg_cambio_proceso_activo.id_programa = pcb.unique_id; mensaje.tipo = SOLICITUDBYTES; send(sockUmv, &mensaje, sizeof(t_mensaje), 0); send(sockUmv, &msg_cambio_proceso_activo, sizeof(t_msg_cambio_proceso_activo), 0); send(sockUmv, &msg_solicitud_bytes, sizeof(t_msg_solicitud_bytes), 0); // Espero la respuesta de la UMV if (recv(sockUmv, &mensaje, sizeof(t_mensaje), 0) == 0) { log_error(logger, "UMV desconectada."); depuracion(SIGINT); } if (recv(sockUmv, &buf, bufferaux[1], 0) == 0) { log_error(logger, "UMV desconectada."); depuracion(SIGINT); } buf[bufferaux[1]] = '\0'; // Verifico limites de instruccion while (salir_bucle != 1) { if(buf[inicio_instruccion] == '\t' || buf[inicio_instruccion] == '\0') { inicio_instruccion++; } else { salir_bucle = 1; } } salir_bucle = 0; pos_en_instruccion = inicio_instruccion; while (salir_bucle != 1) { if(buf[pos_en_instruccion] != '\n') { cantidad_letras_instruccion++; } else { salir_bucle = 1; } pos_en_instruccion++; } memcpy(&instruccion[0], &buf[inicio_instruccion], cantidad_letras_instruccion); instruccion[cantidad_letras_instruccion] = '\0'; // Analizo la instruccion y ejecuto primitivas necesarias log_info(logger, "Me llego la instruccion: %s.", instruccion); usleep(retardo); analizadorLinea(strdup(instruccion), &primitivas, &primitivasKernel); log_info(logger, "Se termino de procesar la instruccion: %s.", instruccion); // Actualizo el pcb pcb.program_counter++; } else { break; } } // Aviso al kernel que termino el quantum del proceso y devuelvo pcb actualizado if (proceso_finalizo == 1) { // Envio a consola de programa el valor final de las variables proceso_finalizo = 0; silverstack_imprimirTexto("Valor final de variables:\n"); for (j = 0; j < list_size(variables); j++) { nueva_var = list_get(variables, j); cadena_aux[0] = nueva_var->id; cadena_aux[1] = ' '; cadena_aux[2] = '='; cadena_aux[3] = ' '; cadena_aux[4] = '\0'; silverstack_imprimirTexto(cadena_aux); silverstack_imprimir(nueva_var->valor); } mensaje.id_proceso = CPU; mensaje.tipo = PROGRAMFINISH; send(sockKernel, &mensaje, sizeof(t_mensaje), 0); log_info(logger, "Envie PROGRAMFINISH al kernel."); send(sockKernel, &pcb, sizeof(t_pcb), 0); log_info(logger, "Envie PCB al kernel."); proceso_finalizo = 0; proceso_imprimir_valores_finales = 1; } else { mensaje.id_proceso = CPU; mensaje.tipo = QUANTUMFINISH; send(sockKernel, &mensaje, sizeof(t_mensaje), 0); log_info(logger,"Envie QUANTUMFINISH al Kernel"); send(sockKernel, &pcb, sizeof(t_pcb), 0); log_info(logger,"Envie PCB al Kernel"); proceso_bloqueado = 0; } } log_info(logger, "Se deja de dar servicio a sistema."); // Libero memoria log_destroy(logger); config_destroy(config); free(variables); // Cierro los sockets close(sockKernel); close(sockUmv); return 0; }