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;
}
