/*
* @NAME: config_create
* @DESC: Crea y devuelve un puntero a una estructura t_config
* @PARAMS:
* path - path del archivo de configuracion
*/
t_config *config_create(char *path) {
t_config *config = malloc(sizeof(t_config));
config->path = strdup(path);
config->properties = dictionary_create();
struct stat stat_file;
stat(path, &stat_file);
FILE* file = NULL;
file = fopen(path, "r");
if (file != NULL) {
char* buffer = calloc(1, stat_file.st_size + 1);
fread(buffer, stat_file.st_size, 1, file);
char** lines = string_split(buffer, "\n");
void add_cofiguration(char *line) {
if (!string_starts_with(line, "#")) {
char** keyAndValue = string_split(line, "=");
dictionary_put(config->properties, keyAndValue[0], keyAndValue[1]);
free(keyAndValue[0]);
free(keyAndValue);
}
}
string_iterate_lines(lines, add_cofiguration);
string_iterate_lines(lines, (void*) free);
free(lines);
free(buffer);
fclose(file);
} else {
int main(void)
{
//Diccionario de funciones de comunicacion
fns = dictionary_create();
dictionary_put(fns, "server_saludar", &server_saludar);
//Creo estrucutra de datos para esta conexion
data_client * data = malloc(sizeof(data_client));
data->x = 2;
data->y = 9;
//Me conecto a servidor, si hay error informo y finalizo
if((socket_server = connectServer(ip, port, fns, &server_connectionClosed, data)) == -1)
{
printf("Error al intentar conectar a servidor. IP = %s, Puerto = %d.\n", ip, port);
exit(1);
}
printf("Se ha conectado exitosamente a servidor. Socket = %d, IP = %s, Puerto = %d.\n", socket_server, ip, port);
//saludo a servidor
runFunction(socket_server, "client_saludar", 3, "hola", "como", "estas");
//Dejo bloqueado main
pthread_mutex_init(&mx_main, NULL);
pthread_mutex_lock(&mx_main);
pthread_mutex_lock(&mx_main);
return EXIT_SUCCESS;
}
void inicializar_programa() {
t_dictionary* codigo_programa = dictionary_create();
int* id = (int*) recibirStream(socketNucleo, sizeof(int));
int* cantPag = (int*) recibirStream(socketNucleo, sizeof(int));
log_info(umcConfg.loguer, "Alocar Programa empezado");
int seguir = 1;
while(seguir){
int* pagina = recibirStream(socketNucleo,sizeof(int));//si es menos uno no hay mas paginas
if(*pagina==-1){
seguir = 0;
}
else{
void* buffer = recibirStream(socketNucleo,umcConfg.configuracionUMC.MARCO_SIZE);
dictionary_put(codigo_programa,pagina,buffer);
}
}
usleep(umcConfg.configuracionUMC.RETARDO*1000);
if(alocarPrograma(*cantPag,*id,codigo_programa)==-1){
int error = ERROR;
send(socketNucleo,&error, sizeof(int),0);
log_info(umcConfg.loguer, "Programa no ha sido alocado correctamente");
}else{
int ok = OK;
send(socketNucleo,&ok, sizeof(int),0);
log_info(umcConfg.loguer, "Programa alocado correctamente");
}
free(id);
free(cantPag);
}
t_puntero primitiva_definirVariable(t_nombre_variable variable){
t_puntero dirRetornada=-1; //---->indica ERROR ???
if(!g_expulsar){
t_size tamanio =sizeof(t_nombre_variable);
t_puntero base =g_pcb.segmento_pila;
t_size offset =dictionary_size(g_diccionario_var)*(sizeof(t_byte)+sizeof(t_palabra))+(g_pcb.cursor_de_pila-g_pcb.segmento_pila); //cada varibale ocupa 5 bytes(1byte:nombre+4bytes:contenido)
printf("***primitiva--->definir Varible***\n");
printf(" --->mandando a guardar var:%c base:%i offset:%i tamanio:%i<---\n",variable,base,offset,tamanio);
log_debug(g_logger,":::primitiva_definirVariable:::\n mandando a guardar la var:%c base:%i offset:%i tam:%i",variable,base,offset,tamanio);
//ENVIA MENSAJE A UMV CON: base+offset+tamaño+contenido a almacenar
if(escrituraUMV(base,offset,tamanio,(t_byte *)&variable)==-1){//=>segmentation fault?
//error--->segmento sobrepasado
printf("error de escritura de nombre de variable en umv -sEGMENTATIoN FAuLT-\n");
log_debug(g_logger,"Error en la escritura del nombre de una variable en umv...");
falloMemoria();
}else{
t_var *var_diccio =crearVarDiccio(variable,offset+1);
//printf("se guardara la variable var_diccio->nombre_var:%s var_diccio->dir:%i\n",var_diccio->nombre_var,var_diccio->direccion_var);
dictionary_put(g_diccionario_var,var_diccio->nombre_var,var_diccio);
g_pcb.tamanio_contexto_actual++;
dirRetornada=offset+1;
}
}
return dirRetornada;
}
void cargarArchivoDeConfiguracion() {
t_dictionary* diccionario;
diccionario = dictionary_create();
char* dato;
char* clave;
char textoLeido[200];
FILE* archivo;
char* config = "configMartus";
archivo = fopen(config,"r");
while ((feof(archivo)) == 0) {
fgets(textoLeido, 200, archivo);
clave = string_split(textoLeido, ",")[0];
dato = string_split(textoLeido, ",")[1];
dictionary_put(diccionario, clave, dato);
}
puertoFileSystem = obtenerDatoLimpioDelDiccionario(diccionario, "puertoFS");
ipFileSystem = obtenerDatoLimpioDelDiccionario(diccionario, "ipFS");
}
//---------------------------------------------- <VARIABLES>
//Setea el diccionario general de variables globales definidos por configuración, iniciándolas en cero
void set_vars_dictionary(){
int i = 0;
while(shared_values[i] != NULL){
dictionary_put(vars_control_dictionary, shared_values[i], 0);
i++;
}
}
void ansisop_asignarValorCompartida(int socket_local,int pid_local){
int* tamanioNombreGV = recibirCpu(socket_local,sizeof(int),pid_local);
int* valorAGrabar = recibirCpu(socket_local, sizeof(int),pid_local);
char* nombreVariable = recibirCpu(socket_local,*tamanioNombreGV,pid_local);
pthread_mutex_lock(&varsGlobals);
free(dictionary_remove(reg_config.dic_variables,nombreVariable));//libero xq es un int* malloc lo q hay
dictionary_put(reg_config.dic_variables,nombreVariable, valorAGrabar);
pthread_mutex_unlock(&varsGlobals);
free(tamanioNombreGV);
free(nombreVariable);
}
t_puntero definirVariable(t_nombre_variable identificador_variable) {
if (SEG_flag == 1)
return 0;
printf("definirVariable\n");
int recepcion;
//Se arma la estructura de definir_variable con lo recibido
t_struct_env_bytes * definir_variable = malloc(sizeof(t_struct_env_bytes));
definir_variable->base = var_seg_stack;
definir_variable->offset = temp_cursor_stack + 5 * var_tamanio_contexto;
definir_variable->tamanio = sizeof(t_nombre_variable) + sizeof(t_valor_variable);
//Se agrega la variable en el diccionario
char key = identificador_variable;
char keyABuscar[2] = { key, '\0' };
definir_variable->buffer = &(keyABuscar[0]);
key = *((char*) definir_variable->buffer);
socket_enviar(sockUMV, D_STRUCT_ENV_BYTES, definir_variable);
int* posicion_variable = malloc(sizeof(int));
*posicion_variable = var_tamanio_contexto + 1;
dictionary_put(dicc_variables, keyABuscar, posicion_variable);
/*probamos si el valor que guardo en el diccionario de variables sea el correcto
int direccion;
void* posicion2=malloc(sizeof(int));
posicion2=dictionary_get(dicc_variables,&identificador_variable);
memcpy(&direccion,posicion2,sizeof(int));
printf("la variable definida esta en la posicion # :%d\n",direccion);
*/
free(definir_variable);
//free(posicion_variable);
void * structRecibido;
t_tipoEstructura tipoStruct;
socket_recibir(sockUMV, &tipoStruct, &structRecibido);
if (tipoStruct != D_STRUCT_NUMERO) {
printf("Respuesta en desreferenciar incorrecta\n");
return 0;
}
recepcion = ((t_struct_numero*) structRecibido)->numero;
excepcion_UMV(recepcion);
var_tamanio_contexto++; //aumentamos el tamanio de contexto
free(structRecibido);
log_escribir(archLog,"Se termina de ejecutar una instruccion",INFO,"Se ejecuto definirVariable");
return obtenerPosicionVariable(keyABuscar[0]); //mejor que devuelva el desplazamiento dentro del stack y no la direccion por que el stack esta en otro proceso
}
void recupero_diccionario(t_dictionary* diccionario, int tamanio_contexto) {
dictionary_clean(diccionario); // debemos limpiar el diccionario y rellenarlo con las variables del contexto anterior
int cant_vars = tamanio_contexto;
int i = 0;
int incremento = 0;
int posicion = 1;
int offset;
while (i < cant_vars) { // con esto volvemos a llenar el dicc_variables con las variables del contexto anterior
int valor_var;
char nombre_var;
t_struct_sol_bytes * sol_var_ant = malloc(sizeof(t_struct_sol_bytes));
sol_var_ant->base = var_seg_stack;
sol_var_ant->offset = temp_cursor_stack + incremento;
sol_var_ant->tamanio = sizeof(char) + sizeof(int);
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, sol_var_ant);
void * structRecibido2;
t_tipoEstructura tipoStruct2;
socket_recibir(sockUMV, &tipoStruct2, &structRecibido2);
memcpy(&nombre_var, ((t_struct_respuesta_umv*) structRecibido2)->buffer, offset = sizeof(char));
memcpy(&valor_var, ((t_struct_respuesta_umv*) structRecibido2)->buffer + offset, sizeof(int)); // no es necesario este valor
char key = nombre_var;
char keyABuscar[2] = { key, '\0' };
int* posicion_variable = malloc(sizeof(int));
*posicion_variable = posicion;
dictionary_put(diccionario, keyABuscar, posicion_variable);
incremento = incremento + (sol_var_ant->tamanio);
i++;
posicion++;
free(sol_var_ant);
free(((t_struct_respuesta_umv*) structRecibido2)->buffer);
free(structRecibido2);
}
}
void cargar_dispositivos() {
char** hioId = config_get_array_value(config, "ID_HIO");
char** hioRetardo = config_get_array_value(config, "HIO");
dispositivos = dictionary_create();
int i;
for(i = 0; hioId[i] != NULL; i++) {
io_t *registro_hio = crear_registro(hioRetardo[i]);
dictionary_put(dispositivos, hioId[i], registro_hio);
}
string_iterate_lines(hioId, free);
string_iterate_lines(hioRetardo, free);
free(hioId);
free(hioRetardo);
}
void cargar_variablesCompartidas()
{
char** variablesCompartidasArray = config_get_array_value(config, "VARIABLES_COMPARTIDAS");
variablesCompartidas = dictionary_create();
int i;
for(i = 0; variablesCompartidasArray[i] != NULL; i++)
{
int32_t *valor = malloc(sizeof(int32_t));
*valor = 0;
dictionary_put(variablesCompartidas, variablesCompartidasArray[i], valor);
}
string_iterate_lines(variablesCompartidasArray, free);
free(variablesCompartidasArray);
}
int main(void) {
t_dictionary* diccionario;
diccionario = dictionary_create();
char* dato;
char* clave;
char* textoLeido;
FILE* archivo;
archivo = fopen("/home/utnso/workspace/extraer datos de archivo de configuracion/src/texto","r");
while (feof(archivo) == 0){
fgets(textoLeido,50,archivo);
clave = string_split(textoLeido,",")[0];
dato = string_split(textoLeido,",")[1];
dictionary_put(diccionario,clave,dato);
}
fclose(archivo);
conseguiRutaArchivos(diccionario);
/*
char* info;
info= (char*)dictionary_get(diccionario,"ip");
printf("%s",info);
*/
printf(dictionary_get(diccionario,"ip")); //cada dato tiene que ser cargado en una variable en ves de imprimirse, ej: ipMarta = dictionary_get(diccionario,"ip");
printf(dictionary_get(diccionario,"puerto"));
printf(dictionary_get(diccionario,"mapper"));
printf(dictionary_get(diccionario,"reducer"));
printf(dictionary_get(diccionario,"combiner"));
printf(dictionary_get(diccionario,"resultado"));
}
//----------------Archivo de Configuracion---------------------------------
void cargarArchivoDeConfiguracion() {
t_dictionary* diccionario;
diccionario = dictionary_create();
char* dato;
char* clave;
char textoLeido[200];
FILE* archivo;
//archivo = fopen("/home/utnso/workspace/tp-2015-1c-sinergia/Nodo/Debug/configNodo","r");
char* config = "configNodo";
archivo = fopen(config,"r");
while ((feof(archivo)) == 0) {
fgets(textoLeido, 200, archivo);
clave = string_split(textoLeido, ",")[0];
dato = string_split(textoLeido, ",")[1];
dictionary_put(diccionario, clave, dato);
}
// IMPORTANTE hay que hacer esto que viene abajo pq el dato obtenido del diccionario viene con un caracter
//de mas entonces tenemos que "limpiarlo" (se lo sacamos)
ipNodo = malloc(15);
puertoNodo = malloc(10);
dirTemp = malloc(100);
puertoFileSystem = obtenerDatoLimpioDelDiccionario(diccionario, "puertoFS");
ipFileSystem = obtenerDatoLimpioDelDiccionario(diccionario, "ipFS");
ipNodo = obtenerDatoLimpioDelDiccionario(diccionario, "ipNodo");
puertoNodo = obtenerDatoLimpioDelDiccionario(diccionario, "puertoNodo");
tamanioNodo = obtenerDatoLimpioDelDiccionario(diccionario, "tamanioNodo");
nodoNuevo = obtenerDatoLimpioDelDiccionario(diccionario, "nodoNuevo");
dirTemp = obtenerDatoLimpioDelDiccionario(diccionario, "dirTemp");
}
//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 cargar_semaforos()
{
char** semaforosArray = config_get_array_value(config, "SEMAFOROS");
char** valorSemaforosArray = config_get_array_value(config, "VALOR_SEMAFORO");
semaforos = dictionary_create();
int i;
semaforo_t *semaforo;
for(i = 0; semaforosArray[i] != NULL && valorSemaforosArray[i] != NULL; i++)
{
semaforo = malloc(sizeof(semaforo_t));
semaforo->valor = atoi(valorSemaforosArray[i]);
semaforo->cola = queue_create();
dictionary_put(semaforos, semaforosArray[i], semaforo);
}
string_iterate_lines(semaforosArray, free);
string_iterate_lines(valorSemaforosArray, free);
free(semaforosArray);
free(valorSemaforosArray);
}
void retornar(t_valor_variable retorno) {
if (SEG_flag == 1)
return;
printf("retornar\n");
uint32_t prog_counter_ant; //vamos a pedir los 12 bytes que guardamos en el stack para volver al cntxt anterior.
uint32_t cursor_contexto_ant;
uint32_t direccion_retornar;
uint32_t cant_vars_ant;
t_struct_sol_bytes * punts_contx_ant = malloc(sizeof(t_struct_sol_bytes));
punts_contx_ant->base = var_seg_stack;
punts_contx_ant->offset = (temp_cursor_stack - (3 * sizeof(uint32_t))); //-var_seg_stack;estoy casi seguro que no se le resta la base, porq el cursor de contexto ya es el offset de la base //restamos el cursor actual - 12(xq es el tamaño de los punteros q guarde en la umv) - el inicio del stack.
punts_contx_ant->tamanio = 3 * sizeof(uint32_t);
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, punts_contx_ant);
void * structRecibido;
t_tipoEstructura tipoStruct;
socket_recibir(sockUMV, &tipoStruct, &structRecibido);
if (tipoStruct != D_STRUCT_RESPUESTA_UMV) {
printf("%d\n", tipoStruct);
}
int tamanio_instruccion;
tamanio_instruccion = ((t_struct_respuesta_umv*) structRecibido)->tamano_buffer;
if (tamanio_instruccion == sizeof(int)) {
int*respuesta = malloc(sizeof(int));
memcpy(respuesta, ((t_struct_respuesta_umv*) structRecibido)->buffer, tamanio_instruccion);
int valor1 = *respuesta;
if (valor1 < 0) {
excepcion_UMV(0);
return;
}
}
int tmanio_respuesta, offset;
tmanio_respuesta = ((t_struct_respuesta_umv*) structRecibido)->tamano_buffer; //esto esta al pedo
memcpy(&cursor_contexto_ant, ((t_struct_respuesta_umv*) structRecibido)->buffer, offset = sizeof(uint32_t));
memcpy(&prog_counter_ant, ((t_struct_respuesta_umv*) structRecibido)->buffer + offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(&direccion_retornar, ((t_struct_respuesta_umv*) structRecibido)->buffer + offset, sizeof(uint32_t));
free(((t_struct_respuesta_umv*) structRecibido)->buffer);
free(structRecibido);
dictionary_clean_and_destroy_elements(dicc_variables, free); // debemos limpiar el diccionario y rellenarlo con las variables del contexto anterior
cant_vars_ant = ((punts_contx_ant->offset) - cursor_contexto_ant) / 5;
int i = 0;
int incremento = 0;
int posicion = 1;
while (i < cant_vars_ant) { // con esto volvemos a llenar el dicc_variables con las variables del contexto anterior
int valor_var;
char nombre_var;
t_struct_sol_bytes * sol_var_ant = malloc(sizeof(t_struct_sol_bytes));
sol_var_ant->base = var_seg_stack;
sol_var_ant->offset = cursor_contexto_ant + incremento;
sol_var_ant->tamanio = sizeof(char) + sizeof(int);
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, sol_var_ant);
void * structRecibido2;
t_tipoEstructura tipoStruct2;
socket_recibir(sockUMV, &tipoStruct2, &structRecibido2);
if (tipoStruct2 != D_STRUCT_RESPUESTA_UMV) {
printf("%d\n", tipoStruct2);
}
memcpy(&nombre_var, ((t_struct_respuesta_umv*) structRecibido2)->buffer, offset = sizeof(char));
memcpy(&valor_var, ((t_struct_respuesta_umv*) structRecibido2)->buffer + offset, sizeof(int)); // no es necesario este valor
char key = nombre_var;
char keyABuscar[2] = { key, '\0' };
int* posicion_variable = malloc(sizeof(int));
*posicion_variable = posicion;
dictionary_put(dicc_variables, keyABuscar, posicion_variable);
incremento = incremento + (sol_var_ant->tamanio);
i++;
posicion++;
free(sol_var_ant);
free(((t_struct_respuesta_umv*) structRecibido2)->buffer);
free(structRecibido2);
//free(posicion_variable);
}
temp_counter = prog_counter_ant; //aca cargamos PCounter del cntxt que guradamos en la UMV.
temp_cursor_stack = cursor_contexto_ant; //aca cargo elcursor del cntxt anterior q se guardo en la UMV.
//direccion_retornar=retorno; // esto no creo q sea asi, me parece que deberia hacerse una asignacion del valor de "reotorno" en la "direccion_retornar". lO hice mas arriba
var_tamanio_contexto = cant_vars_ant; // recuperamos nuestro tamanio de contexto anterior cortesia de la variable cant_vars_ant creada para el recupero del diccionario de variables ;)
if (retorno != -1) {
asignar(direccion_retornar, retorno); // el if es para reutilizar el reotornar en el finalizar omitiendo la asignacion
}
log_escribir(archLog,"Se termina de ejecutar una instruccion",INFO,"Se ejecuto retornar");
free(punts_contx_ant);
printf("retornar\n");
}
//Setea el valor de una variable compartida
void set_var_value(char* var_name, int value){
if(dictionary_has_key(vars_control_dictionary, var_name)){
dictionary_remove(vars_control_dictionary, var_name);
dictionary_put(vars_control_dictionary, var_name, value);
}
}
pcb_t* recibirPCBdeCPU(int socket,int pidLocal){
pcb_t* pcb_Recibido = malloc(sizeof(pcb_t));
pcb_Recibido->PID = recibirCpu(socket,sizeof(int),pidLocal);
pidLocal = *(pcb_Recibido->PID);
pcb_Recibido->PC = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->PCI = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->SP = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->paginasDisponible = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->indice_codigo = dictionary_create();
pcb_Recibido->indice_funciones = list_create();
pcb_Recibido->indice_stack = dictionary_create();
int* tamanioIC = recibirCpu(socket, sizeof(int),pidLocal);
int* tamanioStack = recibirCpu(socket, sizeof(int),pidLocal);
int* tamanioIF = recibirCpu(socket, sizeof(int),pidLocal);
int i;
//RECIBO INDICE DE CODIGO
for(i=0;i<*tamanioIC && *tamanioIC != 0;i++){
int* nuevaPagina = malloc(sizeof(int));
*nuevaPagina = i;
direccionMemoria* nuevaDireccionMemoria = recibirCpu(socket,sizeof(direccionMemoria),pidLocal);
dictionary_put(pcb_Recibido->indice_codigo,nuevaPagina,nuevaDireccionMemoria);
}
free(tamanioIC);
//RECIBO INDICE FUNCIONES
for(i=0;i<*tamanioIF && *tamanioIF!=0;i++){
funcionTemp* funcion = recibirCpu(socket,sizeof(funcionTemp),pidLocal);
char* funcionNombre = recibirCpu(socket,funcion->tamanioNombreFuncion,pidLocal);
funcion_sisop* new_funcion = malloc(sizeof(new_funcion));
new_funcion->funcion = funcionNombre;
new_funcion->posicion_codigo = malloc(sizeof(int));
*(new_funcion->posicion_codigo) = funcion->posicionPID;
list_add_in_index(pcb_Recibido->indice_funciones,i,new_funcion);
}
free(tamanioIF);
//RECIBO STACK
for(i=0;i<*tamanioStack && *tamanioStack!=0;i++){
stack* stackNuevo = malloc(sizeof(stack));
//Argumentos
int* tamArgs = recibirCpu(socket, sizeof(int),pidLocal);
if(*tamArgs==-1)
stackNuevo->args = NULL;
else
stackNuevo->args = list_create();
//Variables
int* tamVars = recibirCpu(socket, sizeof(int),pidLocal);
if(*tamVars==-1)
stackNuevo->vars = NULL;
else
stackNuevo->vars = list_create();
//Retorno PID del renglon stack
int* RetornoPID = recibirCpu(socket, sizeof(int),pidLocal);
if(*RetornoPID == -1)
stackNuevo->pos_ret = NULL;
else
stackNuevo->pos_ret = RetornoPID;
//Retorno
direccionMemoria* memoriaRetorno = recibirCpu(socket, sizeof(direccionMemoria),pidLocal);
if(memoriaRetorno->offset == -1)
memoriaRetorno = NULL;
stackNuevo->memoriaRetorno = memoriaRetorno;
int j;
for(j=0;j<*tamArgs;j++){
direccionMemoria* new_direc = recibirCpu(socket, sizeof(direccionMemoria),pidLocal);
list_add_in_index(stackNuevo->args,j,new_direc);
}
free(tamArgs);
for(j=0;j<*tamVars;j++){
direccionStack* new_direc = recibirCpu(socket, sizeof(direccionStack),pidLocal);
list_add_in_index(stackNuevo->vars,j,new_direc);
}
free(tamVars);
int* key = malloc(sizeof(int));
*key = i;
dictionary_put(pcb_Recibido->indice_stack,key,stackNuevo);
}
//recibo quantum y quantumSleep
return pcb_Recibido;
}
void finalizar() {
if (SEG_flag == 1)
return;
printf("finalizar\n");
uint32_t prog_counter_ant; //vamos a pedir los 8 bytes que guardamos en el stack para volver al cntxt anterior.
uint32_t cursor_contexto_ant;
uint32_t cant_vars_ant;
//Se checkea el cursor del stack
if (temp_cursor_stack == 0) {
//Si es 0
int cant_var = var_tamanio_contexto;
int i = 0;
int incremento = 0;
while (i < cant_var) { //aca deberiamos imprimir las variables con sus valores.
//Se arma estructura de solicitar bytes para la UMV
t_struct_sol_bytes * sol_var = malloc(sizeof(t_struct_sol_bytes));
sol_var->base = var_seg_stack;
sol_var->offset = 0 + incremento;
sol_var->tamanio = sizeof(char) + sizeof(int);
//Se envia solicitar bytes a la UMV
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, sol_var);
void * structRecibido;
t_tipoEstructura tipoStruct;
//Se recibe respuesta de la UMV
socket_recibir(sockUMV, &tipoStruct, &structRecibido);
//Se valida la respuesta
if (tipoStruct != D_STRUCT_RESPUESTA_UMV) {
printf("Respuesta en finalziar (por parte de UMV) incorrecta\n");
//return 0;
}
int offset;
int* valor_var = malloc(sizeof(int));
char* nombre_var = malloc(sizeof(char));
int tamanio_instruccion;
tamanio_instruccion = ((t_struct_respuesta_umv*) structRecibido)->tamano_buffer;
if (tamanio_instruccion == sizeof(int)) {
int*respuesta = malloc(sizeof(int));
memcpy(respuesta, ((t_struct_respuesta_umv*) structRecibido)->buffer, tamanio_instruccion);
int valor1 = *respuesta;
if (valor1 < 0) {
excepcion_UMV(0);
return;
}
}
memcpy(nombre_var, ((t_struct_respuesta_umv*) structRecibido)->buffer, offset = sizeof(char));
memcpy(valor_var, ((t_struct_respuesta_umv*) structRecibido)->buffer + offset, sizeof(int));
char key = *nombre_var;
char keyaImprimir[3] = { key, ':', '\0' };
int valoraImprimir = *valor_var;
imprimirTexto(keyaImprimir);
imprimir(valoraImprimir);
log_escribir(archLog,"Se termina de ejecutar una instruccion",INFO,"Se ejecuto finalizar");
i++;
incremento = incremento + (sol_var->tamanio);
//Se libera espacio alocado
free(((t_struct_respuesta_umv*) structRecibido)->buffer);
free(structRecibido);
free(sol_var);
free(valor_var);
free(nombre_var);
}
//Enviamos el PCB actualizado
t_struct_pcb * PCB_finalizado = malloc(sizeof(t_struct_pcb));
PCB_finalizado->pid = temp_id;
PCB_finalizado->c_stack = temp_cursor_stack;
PCB_finalizado->index_codigo = temp_ind_codigo;
PCB_finalizado->index_etiquetas = var_ind_etiquetas;
PCB_finalizado->program_counter = 0;
PCB_finalizado->codigo = temp_seg_codigo;
PCB_finalizado->stack = var_seg_stack;
PCB_finalizado->tamanio_contexto = var_tamanio_contexto;
PCB_finalizado->tamanio_indice = var_tamanio_etiquetas;
PCB_finalizado->estado=FIN;
printf("Estado de pcb_fin:%d\n", PCB_finalizado->estado);
socket_enviar(sockKernel, D_STRUCT_PCB, PCB_finalizado);
free(PCB_finalizado);
fin_PCB = 1;
log_escribir(archLog, "END: ",INFO, "El PCB id: %d ha finalizado su ejecucion", temp_id);
}
else {
//prueba fallida de invocacion a retornar, no parece funcionar por q el finalizar tiene 2 punteros a retornar, el retornar tiene 3
//int no_return = -1; // verificar si -1 es un posible valor de retorno en ansisop, de ser posible... buscar otro valor que sirve como filtro
//retornar(no_return); // pasando como para metro un null, evito la asignacion del retornar, y como aparte de eso, el retornar haria exactamente lo mismo, evito la repeticion de codigo.
//Se arma estructura para solicitar bytes en la UMV
t_struct_sol_bytes * punts_contx_ant = malloc(sizeof(t_struct_sol_bytes));
punts_contx_ant->base = var_seg_stack;
//punts_contx_ant->offset=(temp_cursor_stack-8)-var_seg_stack; //restamos el cursor actual - 8(xq es el tamaño de los punteros q guarde en la umv) - el inicio del stack.
punts_contx_ant->offset = (temp_cursor_stack - (2 * sizeof(uint32_t))); //var_tamanio_contexto*5;
punts_contx_ant->tamanio = 2 * sizeof(uint32_t);
//Se envia la solicitud de bytes a la UMV
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, punts_contx_ant);
void * structRecibido;
t_tipoEstructura tipoStruct;
//Se recibe la respuesta de la UMV
socket_recibir(sockUMV, &tipoStruct, &structRecibido);
//Se valida la respuesta
if (tipoStruct != D_STRUCT_RESPUESTA_UMV) {
printf("%d\n", tipoStruct);
}
int tmanio_respuesta, offset;
tmanio_respuesta = ((t_struct_respuesta_umv*) structRecibido)->tamano_buffer; //esto esta al pedo
memcpy(&cursor_contexto_ant, ((t_struct_respuesta_umv*) structRecibido)->buffer, offset = sizeof(uint32_t));
memcpy(&prog_counter_ant, ((t_struct_respuesta_umv*) structRecibido)->buffer + offset, sizeof(uint32_t));
free(((t_struct_respuesta_umv*) structRecibido)->buffer);
free(structRecibido);
dictionary_clean_and_destroy_elements(dicc_variables, free); // debemos limpiar el diccionario y rellenarlo con las variables del contexto anterior
cant_vars_ant = ((punts_contx_ant->offset) - cursor_contexto_ant) / 5;
int i = 0;
int incremento = 0;
int posicion = 1;
while (i < cant_vars_ant) // con esto volvemos a llenar el dicc_variables con las variables del contexto anterior
{
int valor_var;
char nombre_var;
t_struct_sol_bytes * sol_var_ant = malloc(sizeof(t_struct_sol_bytes));
sol_var_ant->base = var_seg_stack;
sol_var_ant->offset = cursor_contexto_ant + incremento;
sol_var_ant->tamanio = sizeof(char) + sizeof(int);
socket_enviar(sockUMV, D_STRUCT_SOL_BYTES, sol_var_ant);
void * structRecibido2;
t_tipoEstructura tipoStruct2;
socket_recibir(sockUMV, &tipoStruct2, &structRecibido2);
if (tipoStruct2 != D_STRUCT_RESPUESTA_UMV) {
printf("%d\n", tipoStruct2);
}
void * bufferAux = ((t_struct_respuesta_umv*) structRecibido2)->buffer;
memcpy(&nombre_var, bufferAux, 1);
memcpy(&valor_var, bufferAux + 1, 4); // no es necesario este valor
char key = nombre_var;
char keyABuscar[2] = { key, '\0' };
int* posicion_variable = malloc(sizeof(int));
*posicion_variable = posicion;
dictionary_put(dicc_variables, keyABuscar, posicion_variable);
incremento = incremento + (sol_var_ant->tamanio);
i++;
posicion++;
free(sol_var_ant);
free(structRecibido2);
free(bufferAux);
//free(posicion_variable);
}
temp_counter = prog_counter_ant; //aca ya cargamos PCounter del cntxt que guradamos en la UMV.
temp_cursor_stack = cursor_contexto_ant; //aca cargo elcursor del cntxt anterior q se guardo en la UMV.
var_tamanio_contexto = cant_vars_ant;
free(punts_contx_ant);
}
}
uint32_t crearSegmento(uint32_t pid, size_t size, t_msg_id* id) {
uint16_t numSegmento;
uint16_t cantPaginas = divRoundUp(size,PAG_SIZE);
if (size > SEG_MAX_SIZE) {
*id = INVALID_SEG_SIZE;
return 0;
}
if (CantPaginasDisponibles >= cantPaginas) {
int pag;
t_segmento *tablaLocal;
char *stringPID = string_uitoa(pid);
if ((tablaLocal = tablaDelProceso(stringPID)) == NULL) {
dictionary_put(TablaSegmentosGlobal, stringPID, tablaLocal = malloc(NUM_SEG_MAX * sizeof(t_segmento))); /* Creo la tabla local del proceso PID */
for (numSegmento = 0; numSegmento < NUM_SEG_MAX; ++numSegmento) /* Inicializo la Tabla Local de Segmentos */
tablaLocal[numSegmento].limite = 0;
}
if ((numSegmento = primerEntradaLibre(tablaLocal)) == NUM_SEG_MAX) {
*id = MAX_SEG_NUM_REACHED;
return 0;
}
CantPaginasDisponibles -= cantPaginas;
tablaLocal[numSegmento].limite = size;
tablaLocal[numSegmento].bytesOcupados = 0;
tablaLocal[numSegmento].tablaPaginas = malloc(cantPaginas * sizeof(t_pagina));
/* Marco las páginas como NO en Memoria Principal */
for (pag = 0; pag < cantPaginas && CantPaginasEnSwapDisponibles; ++pag, --CantPaginasEnSwapDisponibles)
paginaEnMemoria(tablaLocal, numSegmento, pag) = false;
if (CantPaginasEnSwapDisponibles == 0) {
pthread_mutex_lock(&LogMutex);
log_trace(Logger, "Espacio de intercambio llleno.");
pthread_mutex_unlock(&LogMutex);
}
/* Si la SWAP se llena reservo marcos de Memoria Principal para el resto de las páginas */
for (; pag < cantPaginas; ++pag, --CantPaginasEnMemoriaDisponibles) {
MemoriaPrincipal[marcoDePagina(tablaLocal, numSegmento, pag) = marcoVacio()].ocupado = true;
MemoriaPrincipal[marcoDePagina(tablaLocal, numSegmento, pag)].pid = pid;
paginaEnMemoria(tablaLocal, numSegmento, pag) = true;
AgregarPaginaAEstructuraSustitucion(pid, numSegmento, pag);
pthread_mutex_lock(&LogMutex);
log_trace(Logger, "Marco %u asignado al proceso %s.", marcoDePagina(tablaLocal, numSegmento, pag), stringPID);
pthread_mutex_unlock(&LogMutex);
}
free(stringPID);
if (CantPaginasEnMemoriaDisponibles == 0) {
pthread_mutex_lock(&LogMutex);
log_trace(Logger, "Memoria Principal lllena.");
pthread_mutex_unlock(&LogMutex);
}
}
else {
*id = FULL_MEMORY;
return 0;
}
*id = OK_CREATE;
return generarDireccionLogica(numSegmento,0,0);
}