t_valor_variable dereferenciar(t_puntero direccion_variable){ //obtiene los cuatro bytes siguientes a direccion_variable t_valor_variable valor; int32_t base = pcb->dir_seg_stack; int32_t offset = direccion_variable-base+1; int32_t tam= sizeof(int32_t); enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, tam, NULL); //recibir de umv 4 bytes de valor_variable t_men_comun *men_comun = socket_recv_comun(socketUmv); if (men_comun->tipo == R_SOL_BYTES){ memcpy(&valor, men_comun->dato,men_comun->tam_dato); txt_write_in_file(cpu_file_log, "Dereferenciar \n"); txt_write_in_file(cpu_file_log, "y su valor es \n"); printf(" Dereferenciar %d, offset:%i y su valor es: %d\n",direccion_variable, offset,valor); } if(men_comun->tipo ==SEGMEN_FAULT){ finalizarContexto(SEGMEN_FAULT); } destruir_men_comun(men_comun); return valor; }
void wait(t_nombre_semaforo identificador_semaforo){ enviar_men_comun_destruir(socketKernel, WAIT, identificador_semaforo, string_length(identificador_semaforo)+BARRA_CERO); txt_write_in_file(cpu_file_log, "Haciendo wait a semaforo\n"); printf(" Haciendo wait a semaforo %s\n", identificador_semaforo); t_men_comun *men_resp = socket_recv_comun(socketKernel); switch(men_resp->tipo){ case SEM_OK: //El semaforo esta disponible, seguir procesando o lo que sea printf(" Se recibio el mensaje SEM_OK, se continuara con la ejecucion\n"); txt_write_in_file(cpu_file_log, "El semaforo esta disponible, se continua con la ejecucion."); //No hago nada, continua con la ejecucion normalmente break; case SEM_BLOQUEADO: finalizarContexto(SEM_BLOQUEADO); // para que no busque la proxima instruccion, y se quede bloqueado // no hace falta mandar nada al kernel, ya que al avisar que lo bloquea lo manda a bloqueado por get_cpu printf(" Se recibio el mensaje SEM_BLOQUEADO del semaforo,se bloquea el programa n° %i\n", pcb->id); txt_write_in_file(cpu_file_log, "Se bloqueo el programa por un semaforo, se desaloja de la cpu."); //El semaforo esta bloqueado, desalojar(suponiendo que tiene que cambiar de proceso, si es asi, mandar el pcb) break; case SEM_INEX: printf(" Acceso a semaforo %s inexistente \n",identificador_semaforo); txt_write_in_file(cpu_file_log,"Acceso a semaforo inexistente"); finalizarContexto(SEM_INEX); break; default: printf(" El tipo de dato recibido: %i es erroneo\n",men_resp->tipo); txt_write_in_file(cpu_file_log,"Se recibio un msj del kernel de tipo erroneo"); break; } destruir_men_comun(men_resp); }
t_valor_variable obtenerValorCompartida(t_nombre_compartida variable){ //le mando al kernel el nombre de la variable compartida enviar_men_comun_destruir(socketKernel, OBTENER_VALOR, variable, string_length(variable)+BARRA_CERO); //recibo el valor t_men_comun *respuesta = socket_recv_comun(socketKernel); t_valor_variable valor; if((respuesta->tipo != VAR_INEX) && (respuesta->tipo != R_OBTENER_VALOR)) printf(" ERROR se ha recibido un tipo de dato erroneo\n"); if(respuesta->tipo == VAR_INEX){ txt_write_in_file(cpu_file_log, "Acceso a variable global inexistente \n"); printf(" Error en acceso a la variable %s, no existe", variable); valor = 0;//todo asigno 0 si la variable no existe finalizarContexto(VAR_INEX);//todo romper }else{ valor = atoi(respuesta->dato); txt_write_in_file(cpu_file_log, "Obteniendo el valor de compartida \n"); txt_write_in_file(cpu_file_log, "el valor \n"); printf(" Obteniendo el valor de compartida %s que es %i \n", variable, valor); } destruir_men_comun(respuesta); return valor; }
void logear_char(FILE* destino,char un_char){ if (un_char == '\0'){ char *aux_string = "\\0"; txt_write_in_file(destino, aux_string); }else{ char *aux_string = string_itoa((int)un_char); txt_write_in_file(destino, aux_string); free(aux_string); } txt_write_in_file(destino,"-"); }
void mi_signal(t_nombre_semaforo identificador_semaforo){ enviar_men_comun_destruir(socketKernel, SIGNAL, identificador_semaforo, string_length(identificador_semaforo)+BARRA_CERO); txt_write_in_file(cpu_file_log,"Haciendo signal a semaforo\n"); printf(" Haciendo signal a semaforo %s\n", identificador_semaforo); t_men_comun *respuesta = socket_recv_comun(socketKernel); if(respuesta->tipo == SEM_INEX){ txt_write_in_file(cpu_file_log,"Signal a semaforo inexistente\n"); printf(" Signal a semaforo %s inexistente \n", identificador_semaforo); finalizarContexto(SEM_INEX); } destruir_men_comun(respuesta); }
t_valor_variable asignarValorCompartida(t_nombre_compartida variable, t_valor_variable valor){ //le mando al kernel el nombre de la variable compartida //le mando el valor que le quiero asignar enviar_men_comun_destruir(socketKernel, GRABAR_VALOR, variable, string_length(variable)+BARRA_CERO); t_men_comun *men_resp = socket_recv_comun(socketKernel); if(men_resp->tipo == VAR_INEX){ txt_write_in_file(cpu_file_log, "Acceso a variable global inexistente \n"); printf(" Error en acceso a la variable %s, no existe", variable); finalizarContexto(VAR_INEX); destruir_men_comun(men_resp); return -1; } if(men_resp->tipo == R_GRABAR_VALOR){ destruir_men_comun(men_resp); char *c = string_itoa(valor); enviar_men_comun_destruir(socketKernel, VALOR_ASIGNADO, c, string_length(c)+BARRA_CERO); free(c); men_resp = socket_recv_comun(socketKernel); destruir_men_comun(men_resp); return valor; } printf(" ERROR el kernel me mando:%i y se esperaba otro tipo\n",men_resp->tipo); return -1; }
static void _log_write_in_level(t_log* logger, t_log_level level, const char* message_template, va_list list_arguments) { if (_isEnableLevelInLogger(logger, level)) { char *message, *time, *buffer; unsigned int thread_id; message = string_from_vformat(message_template, list_arguments); time = temporal_get_string_time(); thread_id = process_get_thread_id(); buffer = string_from_format("[%s] %s %s/(%d:%d): %s\n", log_level_as_string(level), time, logger->program_name, logger->pid, thread_id, message); if (logger->file != NULL) { txt_write_in_file(logger->file, buffer); } if (logger->is_active_console) { txt_write_in_stdout(buffer); } free(time); free(message); free(buffer); } }
t_puntero obtenerPosicionVariable(t_nombre_variable identificador_variable){ /*Se fija en el diccionario de variables la posicion la posicion va a ser el data del elemento*/ identificador_variable = es_numero_pasar_char(identificador_variable); char *key = string_substring_until(&identificador_variable, 1); int32_t *dir_mem = dictionary_get(dic_Variables,key); int32_t ret = *dir_mem; if (dir_mem == NULL) printf(" ERROR no se ha podido encontrar la key:%s\n",key); txt_write_in_file(cpu_file_log, "La posicion de la variable\n"); txt_write_in_file(cpu_file_log, "es\n"); printf(" La posicion de la variable: %s, es %i\n", key, ret); free(key); return ret; }
void handshake_kernel(char *puerto, char *ip){ //envio al kernel socketKernel = socket_crear_client(puerto,ip); enviar_men_comun_destruir(socketKernel, HS_CPU, NULL, 0); //espero conexion de kernel t_men_comun *mensaje_inicial = socket_recv_comun(socketKernel); if(mensaje_inicial->tipo == HS_KERNEL){ txt_write_in_file(cpu_file_log, "Kernel conectado\n"); printf("Kernel conectado\n"); destruir_men_comun(mensaje_inicial); }else{ txt_write_in_file(cpu_file_log, "ERROR HANDSHAKE KERNEL \n"); printf("ERROR HANDSHAKE\n"); } }
void handshake_umv(char *puerto, char *ip){ //envio a la UMV socketUmv = socket_crear_client(puerto,ip); enviar_men_comun_destruir(socketUmv, HS_CPU, NULL, 0); //espero coneccion de la UMV t_men_comun *mensaje_inicial = socket_recv_comun(socketUmv); if(mensaje_inicial->tipo == HS_UMV){ txt_write_in_file(cpu_file_log, "UMV conectada \n"); printf("UMV conectada\n"); destruir_men_comun(mensaje_inicial); }else{ txt_write_in_file(cpu_file_log, "ERROR HANDSHAKE UMV\n"); printf("ERROR HANDSHAKE\n"); } }
void irAlLabel(t_nombre_etiqueta nombre_etiqueta){//revisar // primer instruccion ejecutable de etiqueta y -1 en caso de error char *etiq_sin_blancos = sacar_caracteres_escape(nombre_etiqueta); //t_puntero_instruccion pos_etiqueta= metadata_buscar_etiqueta("inicio", etiquetas, pcb->tam_indice_etiquetas); t_puntero_instruccion pos_etiqueta= metadata_buscar_etiqueta(etiq_sin_blancos, etiquetas, pcb->tam_indice_etiquetas); if(pos_etiqueta != -1){ pcb->program_counter = pos_etiqueta; txt_write_in_file(cpu_file_log, "Yendo al label \n"); printf(" Yendo al label con pos: %i, con nombre: %s, \n",pos_etiqueta, etiq_sin_blancos); }else{ txt_write_in_file(cpu_file_log, "Hubo un error en la busqueda de la etiqueta\n"); printf(" ERROR en la busqueda de la etiqueta:%s \n",etiq_sin_blancos); finalizarContexto(ERROR); } free(etiq_sin_blancos); }
void entradaSalida(t_nombre_dispositivo dispositivo, int tiempo){ enviar_men_comun_destruir(socketKernel, IO_ID, dispositivo, string_length(dispositivo)+BARRA_CERO); char *aux_tiempo = string_itoa(tiempo); enviar_men_comun_destruir(socketKernel, IO_CANT_UNIDADES,aux_tiempo , string_length(aux_tiempo)+BARRA_CERO); free(aux_tiempo); enviar_pcb_destruir(); fueFinEjecucion = 1; entre_io =1; txt_write_in_file(cpu_file_log, "Saliendo a IO en dispositivo\n"); printf(" Saliendo a IO ID:%s, cant. unidades:%d\n", dispositivo, tiempo); }
void llamarConRetorno(t_nombre_etiqueta etiqueta, t_puntero donde_retornar){ int32_t base, offset, tam, pos_retorno; //preservar el contexto, agrega al segmento stack la dir de memoria del contexto anterior y la cantidad de variables del contex anterior preservarContexto(); //aca le digo a la umv q me guarde en el stack la dir de la variable a la q tengo q asignarle el valor retornado por la "funcion" base = pcb->dir_seg_stack; offset = pcb->dir_cont_actual - base + (pcb->cant_var_cont_actual*5)+8; tam = sizeof(int32_t); char *buffer = copiar_int_to_buffer(donde_retornar); enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, tam, buffer); free(buffer); t_men_comun *r_alm = socket_recv_comun(socketUmv); if(r_alm->tipo == R_ALM_BYTES){ txt_write_in_file(cpu_file_log, "Se almaceno la direccion de retorno \n"); printf(" Se almaceno la direccion de retorno\n"); //actualizo las estructuras pcb->dir_cont_actual = pcb->dir_seg_stack+offset+4; pcb->cant_var_cont_actual = 0; regenerar_dicc_var(); pos_retorno = metadata_buscar_etiqueta(etiqueta, etiquetas, pcb->tam_indice_etiquetas); pcb->program_counter = pos_retorno; txt_write_in_file(cpu_file_log, "Llamando con retorno a la etiqueta\n"); printf(" Llamando con retorno a etiqueta %s, pos_PC:%i\n", etiqueta, pos_retorno); return; } if(r_alm->tipo == SEGMEN_FAULT){ finalizarContexto(SEGMEN_FAULT); return; } printf(" ERROR tipo de dato:%i, recibido es erroneo\n", r_alm->tipo); }
char* solicitarProxSentenciaAUmv(){// revisar si de hecho devuelve la prox instruccion(calculos) int32_t base, offset, tam; t_men_comun *men_base_offset; //con el indice de codigo y el pc obtengo la posicion de la proxima instruccion a ejecutar base = pcb->dir_indice_codigo; offset = pcb->program_counter * sizeof(t_intructions); tam = sizeof(t_intructions); enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, tam, NULL); men_base_offset = socket_recv_comun(socketUmv); memcpy(&offset, men_base_offset->dato, sizeof(int32_t)); memcpy(&tam, men_base_offset->dato+sizeof(int32_t), sizeof(int32_t)); if((men_base_offset->tam_dato != 8) || (men_base_offset->tipo!=R_SOL_BYTES))//por si la UMV me llega a mandar un tamanio distinto al q pedi o si el tipo de dato es diferente printf("ERROR el tamanio recibido:%i es distinto a 8, o el tipo de dato:%i es distinto a R_SOL_BYTES\n",men_base_offset->tam_dato,men_base_offset->tipo); destruir_men_comun(men_base_offset); base = pcb->dir_seg_codigo; //le mando a la umv base, offset y tamanio de la proxima instruccion enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, tam, NULL); //recibir la instruccion a ejecutar t_men_comun *rec_inst = socket_recv_comun(socketUmv); char proxInst[tam+BARRA_CERO]; if(rec_inst->tipo == R_SOL_BYTES){ memcpy(proxInst, rec_inst->dato, tam); proxInst[tam] = '\0'; char *proxInst_sin_blancos = sacar_caracteres_escape(proxInst); txt_write_in_file(cpu_file_log, "Instruccion que voy a ejecutar\n"); printf("Instruccion que voy a ejecutar:%s\n",proxInst_sin_blancos); pcb->program_counter ++; destruir_men_comun(rec_inst); return proxInst_sin_blancos; } if(rec_inst->tipo == SEGMEN_FAULT){ finalizarContexto(SEGMEN_FAULT); destruir_men_comun(rec_inst); return NULL; } printf("ERROR tipo de dato:%i, recibido es erroneo\n", rec_inst->tipo); return NULL; }
void llamarSinRetorno(t_nombre_etiqueta etiqueta){ int32_t pos_retorno; /*Preserva el contexto de ejecución actual para poder retornar luego al mismo.*/ preservarContexto(); //actualizo las estructuras pcb->dir_cont_actual = pcb->dir_cont_actual + (5*pcb->cant_var_cont_actual)+8;//todo probar q ande pcb->cant_var_cont_actual = 0; regenerar_dicc_var(); pos_retorno = metadata_buscar_etiqueta(etiqueta, etiquetas, pcb->tam_indice_etiquetas); pcb->program_counter = pos_retorno; txt_write_in_file(cpu_file_log, "Llamando sin retorno a etiqueta\n"); printf(" Llamando sin retorno a etiqueta:%s, con pos_PC:%i\n", etiqueta, pos_retorno); }
//Primitivas ANSISOP t_puntero definirVariable(t_nombre_variable id_var){ int32_t base, offset, tam; base = pcb->dir_seg_stack; offset= pcb->dir_cont_actual - base + (pcb->cant_var_cont_actual*5); tam = 5; int32_t pos_mem = base + offset; printf(" Definir la variable %c en la posicion %i, offset:%i\n",id_var, pos_mem,offset); id_var = es_numero_pasar_char(id_var); id_var = es_numero_pasar_char(id_var); char *key = string_substring_until(&id_var, 1); enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, tam, key); t_men_comun *r_alm = socket_recv_comun(socketUmv); if(r_alm->tipo == R_ALM_BYTES){ int32_t *pos = malloc(sizeof(int32_t)); *pos = pos_mem; dictionary_put(dic_Variables, key, pos); free(key); (pcb->cant_var_cont_actual) ++; txt_write_in_file(cpu_file_log, "Definiar la variable \n"); txt_write_in_file(cpu_file_log, "en la posicion \n"); destruir_men_comun(r_alm); return pos_mem; }else{ finalizarContexto(SEGMEN_FAULT); destruir_men_comun(r_alm); free(key); return -1; } }
void imprimirTexto(char* texto){ char *texto_sin_esc = sacar_caracteres_escape(texto); enviar_men_comun_destruir(socketKernel, IMPRIMIR_TEXTO, texto_sin_esc, string_length(texto_sin_esc)+BARRA_CERO); char *aux_string = string_itoa(pcb->id); enviar_men_comun_destruir(socketKernel, ID_PROG, aux_string, string_length(aux_string)+BARRA_CERO); free(aux_string); recibir_resp_kernel(R_IMPRIMIR); txt_write_in_file(cpu_file_log, " Imprimiendo texto\n"); printf(" Imprimiendo texto: %s\n", texto_sin_esc); free(texto_sin_esc); }
void imprimir(t_valor_variable valor_mostrar){ if(!huboSegFault){ char *string_int = string_itoa(valor_mostrar); enviar_men_comun_destruir(socketKernel, IMPRIMIR_VALOR, string_int, string_length(string_int)+BARRA_CERO); char *aux_string = string_itoa(pcb->id); enviar_men_comun_destruir(socketKernel, ID_PROG, aux_string, string_length(aux_string)+BARRA_CERO); free(aux_string); recibir_resp_kernel(R_IMPRIMIR); txt_write_in_file(cpu_file_log, " Imprimiendo valor\n"); printf(" Imprimiendo valor: %s\n", string_int); free(string_int); } }
void asignar(t_puntero direccion_variable, t_valor_variable valor){ //envio a la umv para almacenar base= contexto actual offset= direccion_variable tamaño=4bytes buffer= valor if(!huboSegFault){ int32_t base = pcb->dir_seg_stack; int32_t offset = direccion_variable-base+1; int32_t tam = sizeof(t_valor_variable); char *buffer = copiar_int_to_buffer(valor); enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, tam, buffer); free(buffer); t_men_comun *r_alm = socket_recv_comun(socketUmv); if(r_alm->tipo == R_ALM_BYTES){ txt_write_in_file(cpu_file_log, "Asignando en la direccion \n"); txt_write_in_file(cpu_file_log, "el valor \n"); printf(" Asignando en la direccion %d, offset:%i, el valor %d \n", direccion_variable, offset, valor); } if(r_alm->tipo == SEGMEN_FAULT){ finalizarContexto(SEGMEN_FAULT); } destruir_men_comun(r_alm); } }
void retornar(t_valor_variable retorno){ int32_t base, offset, tam; int32_t dir_retorno; int32_t prog_counter; int32_t dir_context_ant; //consigo 3 int, el primero para asignarle el valor retorno, el segundo para el program counter a retornar y el tercero para la dir de memoria al contexto anterior tam= 12; base= pcb->dir_seg_stack; offset= pcb->dir_cont_actual-base- 12; enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, tam, NULL); t_men_comun *rec_ret= socket_recv_comun(socketUmv); if(rec_ret->tipo == R_SOL_BYTES){ memcpy(&dir_context_ant, rec_ret->dato,sizeof(int32_t)); memcpy(&prog_counter, rec_ret->dato+4,sizeof(int32_t)); memcpy(&dir_retorno, rec_ret->dato+8,sizeof(int32_t)); }else{ finalizarContexto(SEGMEN_FAULT); return; } //actualizar el pcb int32_t cant_var = (pcb->dir_cont_actual - dir_context_ant-12)/5; actualizar_pcb(cant_var,prog_counter,dir_context_ant); regenerar_dicc_var(); //almaceno la variable retorno en el contexto anterior char *buffer = copiar_int_to_buffer(retorno); offset = (dir_retorno - base + 1); enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, sizeof(int32_t), buffer); free(buffer); t_men_comun *rec_alm = socket_recv_comun(socketUmv); if(rec_alm->tipo == R_ALM_BYTES){ txt_write_in_file(cpu_file_log, "Retornando valor de variable\n"); printf(" Retornando valor de variable:%d en la direccion %d\n", retorno, dir_retorno); }else{ printf(" ERROR se esperaba un tipo de dato R_SOL_BYTES y recibo un:%i\n", rec_ret->tipo); } }
void preservarContexto(){ int32_t base, offset, tam; base = pcb->dir_seg_stack; offset = pcb->dir_cont_actual - base + (pcb->cant_var_cont_actual*5); // la posicion siguiente al ultimo valor de la ultima varaible tam = sizeof(int32_t); char *buffer = copiar_int_to_buffer(pcb->dir_cont_actual); enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, tam, buffer); free(buffer); t_men_comun *r_con = socket_recv_comun(socketUmv); if (r_con->tipo == R_ALM_BYTES){ destruir_men_comun(r_con); offset = offset + 4; char *buffer = copiar_int_to_buffer(pcb->program_counter); enviar_men_cpu_umv_destruir(ALM_BYTES, base, offset, tam, buffer); free(buffer); t_men_comun *r_proxins = socket_recv_comun(socketUmv); if(r_proxins->tipo == R_ALM_BYTES){ txt_write_in_file(cpu_file_log, "Se almaceno correctamente el contexto\n"); printf(" Se almaceno correctamente el contexto\n"); destruir_men_comun(r_proxins); return; } if(r_proxins->tipo == SEGMEN_FAULT){ finalizarContexto(SEGMEN_FAULT); destruir_men_comun(r_proxins); return; } } if(r_con->tipo == SEGMEN_FAULT){ finalizarContexto(SEGMEN_FAULT); destruir_men_comun(r_con); return; } printf(" ERROR tipo de dato:%i, recibido es erroneo\n", r_con->tipo); }
void finalizar(){ int32_t base, offset, tam; //si es el fin de programa, le digo al kernel q finalizo y salgo de la funcion if(pcb->dir_cont_actual == pcb->dir_seg_stack){ finalizarContexto(OK); txt_write_in_file(cpu_file_log, "Finalizando el programa actual\n"); printf(" Finalizando el programa actual\n"); return; } int32_t prog_counter; int32_t dir_context_ant; //consigo 2 int, el primero para el program counter a retornar y el segundo para la dir de memoria al contexto anterior tam= 8; base= pcb->dir_seg_stack; offset= pcb->dir_cont_actual-base- 8; enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, tam, NULL); t_men_comun *rec_ret= socket_recv_comun(socketUmv); if(rec_ret->tipo == R_SOL_BYTES){ memcpy(&dir_context_ant, rec_ret->dato,sizeof(int32_t)); memcpy(&prog_counter, rec_ret->dato+4,sizeof(int32_t)); }else{ finalizarContexto(SEGMEN_FAULT); return; } //actualizar el pcb int32_t cant_var = (pcb->dir_cont_actual - dir_context_ant-8)/5; actualizar_pcb(cant_var,prog_counter,dir_context_ant); regenerar_dicc_var(); }
void logear_int(FILE* destino,int32_t un_int){ char *aux_string = string_itoa(un_int); txt_write_in_file(destino,aux_string); free(aux_string); }
void finalizarContexto(int32_t tipo_fin){ int32_t i, base, offset; char *aux_string; switch(tipo_fin){ case SEM_INEX: printf(" ERROR,el semaforo es inexistente\n"); fueFinEjecucion=1; break; case SEM_BLOQUEADO: fueFinEjecucion=1; enviar_pcb_destruir(); break; case VAR_INEX: printf(" ERROR,la variable global es inexistente\n"); fueFinEjecucion=1; break; case ERROR: printf(" ERROR, la etiqueta no se ha encontrado pero creo q esta fuera del alcanse del tp\n"); fueFinEjecucion = 1; break; case SEGMEN_FAULT: aux_string = string_itoa(pcb->id); printf("Hubo un error en la solictud de memoria, se finalizará la ejecucion del programa actual %d\n", pcb->id); txt_write_in_file(cpu_file_log, "Hubo un error en la solictud de memoria, se finalizará la ejecucion del programa actual\n"); enviar_men_comun_destruir(socketKernel, SEGMEN_FAULT, aux_string, string_length(aux_string)+BARRA_CERO); free(aux_string); fueFinEjecucion = 1; huboSegFault = 1; break; case OK: printf(" Imprmiendo variables y finalizando proceso\n"); char *string = "\n----------Imprimo el estado final de las variable----------\n"; enviar_men_comun_destruir(socketKernel, IMPRIMIR_TEXTO, string, string_length(string)+BARRA_CERO); char *aux_string = string_itoa(pcb->id); enviar_men_comun_destruir(socketKernel, ID_PROG, aux_string, string_length(aux_string)+BARRA_CERO); free(aux_string); recibir_resp_kernel(R_IMPRIMIR); for(i=0;i<pcb->cant_var_cont_actual;i++){//esta MIERDA de for es para imprimir vas variables en la consola del proceso progrma base = pcb->dir_cont_actual; offset = (5*i); enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, 1, NULL); t_men_comun *men_nombre_var = socket_recv_comun(socketUmv); base = pcb->dir_cont_actual; offset = (5*i)+1; enviar_men_cpu_umv_destruir(SOL_BYTES, base, offset, 4, NULL); t_men_comun *men_cont_var = socket_recv_comun(socketUmv); int32_t cont_var; memcpy(&cont_var,men_cont_var->dato,4); char *aux_cont_var =string_itoa(cont_var); int32_t tam_string = string_length(aux_cont_var)+3;// 1(nombre de la variable)+1(el igual)+string_length(aux_cont_var)+1(el \n)+1(el \0) char var_a_imp_con_contexto[tam_string]; var_a_imp_con_contexto[0] = men_nombre_var->dato[0]; var_a_imp_con_contexto[1] = '='; memcpy(var_a_imp_con_contexto+2,aux_cont_var,string_length(aux_cont_var)); var_a_imp_con_contexto[tam_string-1] = '\0'; free (aux_cont_var); enviar_men_comun_destruir(socketKernel, IMPRIMIR_TEXTO, var_a_imp_con_contexto, string_length(var_a_imp_con_contexto)+BARRA_CERO); char *aux_string = string_itoa(pcb->id); enviar_men_comun_destruir(socketKernel, ID_PROG, aux_string, string_length(aux_string)+BARRA_CERO); free(aux_string); recibir_resp_kernel(R_IMPRIMIR); destruir_men_comun(men_cont_var); destruir_men_comun(men_nombre_var); } aux_string = string_itoa(pcb->id); enviar_men_comun_destruir(socketKernel, FIN_EJECUCION, aux_string, string_length(aux_string)+BARRA_CERO); free(aux_string); fueFinEjecucion = 1; break; default: printf("ERROR: tipo_fin:%i inexistente\n",tipo_fin); break; } }
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; }