Esempio n. 1
0
/*
 * @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 {
Esempio n. 2
0
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;
}
Esempio n. 3
0
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);
}
Esempio n. 4
0
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;
}
Esempio n. 5
0
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++;
	}
}
Esempio n. 7
0
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"));

}
Esempio n. 13
0
//----------------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");
}
Esempio n. 14
0
//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);
	}
}
Esempio n. 18
0
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);
}