void _atiendo_crear_segmento(sock_t* sock, char* msg){
pedido_de_crear_segmento_t* pedido_crear = deserializar_pedido_de_crear_segmento_t(msg);
loggear_trace("Atiendo solicitud de Crear Segmento.\nPID: %d\nBytes: %d",
pedido_crear->pid, pedido_crear->tamano);
resultado_t* resultado = malloc(sizeof(resultado_t));
direccion dir_base = crear_segmento(pedido_crear->pid, pedido_crear->tamano, resultado);
respuesta_de_crear_segmento_t* respuesta_crear = malloc(sizeof(respuesta_de_crear_segmento_t));
respuesta_crear->direccion_virtual = dir_base;
respuesta_crear->flag = TOMA_SEGMENTO;
respuesta_crear->resultado = *(resultado);
free(resultado);
char* msg_respuesta_crear = serializar_respuesta_de_crear_segmento_t(respuesta_crear);
uint32_t len_msg_crear = tamanio_respuesta_de_crear_segmento_t_serializado();
enviar(sock,msg_respuesta_crear, &len_msg_crear);
free(pedido_crear);
free(respuesta_crear);
free(msg_respuesta_crear);
}
void consola (void* param)
{
cantidad_dumps = 0;
char comando[50];
char comando2[50];
int flag_comandoOK;
int flag_comandoOK2;
int nuevo_valor;
int valor_numerico;
int valor_numerico2;
int valor_numerico3;
int proc_id = -1;
int respuesta;
int dir_fisica;
char *buffer;
log_info(logger, "Se lanzo el hilo de consola");
printw("-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n");
printw(" Bienvenido a la consola de UMV \n");
printw("-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n");
refresh();
int i;
int cant_num_leidos;
int *buffer_int;
int tecla_ingresada;
int tecla_ingresada2;
// Bucle principal esperando peticiones del usuario
for(;;)
{
flag_comandoOK = 0;
flag_comandoOK2 = 0;
fflush(stdin);
printw("Ingrese el comando: \n");
printw(">");
refresh();
getstr(comando);
if (flag_comandoOK == 0 && strcmp(comando, "operacion") == 0)
{
printw("Operaciones disponibles: \n");
printw("\tcrear segmento\n");
printw("\tsolicitar memoria\n");
printw("\tescribir memoria\n");
printw("\tdestruir segmentos\n");
printw("Ingrese la operacion: \n");
printw(">");
refresh();
getstr(comando2);
if (flag_comandoOK2 == 0 && strcmp(comando2, "crear segmento") == 0)
{
printw("Ingrese proceso: \n");
printw(">");
refresh();
scanw("%d", &proc_id);
respuesta = verificar_proc_id(proc_id);
if (respuesta == 0)
{
printw("El proceso ingresado no existe en memoria.\n");
printw("Ingrese un proceso que exista en memoria para crear un segmento.\n");
refresh();
}
else
{
printw("Ingrese tamanio del segmento: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico);
pthread_mutex_lock(&semCompactacion);
respuesta = crear_segmento(proc_id, valor_numerico);
pthread_mutex_unlock(&semCompactacion);
switch(respuesta)
{
case -1:
printw("No hay memoria disponible para ese tamanio de segmento.\n");
printw("El segmento no fue creado.\n");
refresh();
break;
default:
log_info(logger, "Segmento de proceso %d creado.", proc_id);
printw("El segmento fue creado.\n");
dir_fisica = transformar_direccion_en_fisica(respuesta, proc_id);
printw("Posicion en memoria del segmento: %d\n", dir_fisica);
refresh();
break;
}
}
flag_comandoOK2 = 1;
}
if (flag_comandoOK2 == 0 && strcmp(comando2, "solicitar memoria") == 0)
{
printw("Ingrese proceso: \n");
printw(">");
refresh();
scanw("%d", &proc_id);
respuesta = verificar_proc_id(proc_id);
if (respuesta == 0)
{
printw("El proceso ingresado no existe en memoria.\n");
printw("Ingrese un proceso que exista en memoria.\n");
refresh();
}
else
{
printw("Ingrese base: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico);
printw("Ingrese offset: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico2);
printw("Ingrese cantidad de bytes a leer: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico3);
buffer = (char *)malloc(valor_numerico3);
valor_numerico = transformar_direccion_en_logica(valor_numerico, proc_id);
pthread_mutex_lock(&semProcesoActivo);
pthread_mutex_lock(&semCompactacion);
respuesta = atender_solicitud_bytes(valor_numerico, valor_numerico2, valor_numerico3, 0, &buffer);
pthread_mutex_unlock(&semCompactacion);
pthread_mutex_unlock(&semProcesoActivo);
switch(respuesta)
{
case PROGRAMA_INVALIDO:
printw("El proceso es invalido.\n");
refresh();
break;
case SEGMENTATION_FAULT:
printw("Segmentation fault.\n");
refresh();
break;
default:
printw("Posicion de memoria solicitada: %d\n", respuesta);
printw("Contenido: ");
for (i = 0; i < valor_numerico3; i++)
{
printw("%c", buffer[i]);
}
printw("\n");
refresh();
free(buffer);
break;
}
}
flag_comandoOK2 = 1;
}
if (flag_comandoOK2 == 0 && strcmp(comando2, "solicitar memoria int") == 0)
{
printw("Ingrese proceso: \n");
printw(">");
refresh();
scanw("%d", &proc_id);
respuesta = verificar_proc_id(proc_id);
if (respuesta == 0)
{
printw("El proceso ingresado no existe en memoria.\n");
printw("Ingrese un proceso que exista en memoria.\n");
refresh();
}
else
{
printw("Ingrese base: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico);
printw("Ingrese offset: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico2);
printw("Ingrese cantidad de bytes a leer: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico3);
buffer_int = (int *)malloc(valor_numerico3);
valor_numerico = transformar_direccion_en_logica(valor_numerico, proc_id);
pthread_mutex_lock(&semProcesoActivo);
pthread_mutex_lock(&semCompactacion);
respuesta = atender_solicitud_bytes_int(valor_numerico, valor_numerico2, valor_numerico3, 0, &buffer_int);
pthread_mutex_unlock(&semCompactacion);
pthread_mutex_unlock(&semProcesoActivo);
switch(respuesta)
{
case PROGRAMA_INVALIDO:
printw("El proceso es invalido.\n");
refresh();
break;
case SEGMENTATION_FAULT:
printw("Segmentation fault.\n");
refresh();
break;
default:
printw("Posicion de memoria solicitada: %d\n", respuesta);
printw("Contenido: \n");
cant_num_leidos = (int)valor_numerico3 / 4;
for (i = 0; i < cant_num_leidos; i++)
{
printw("%d\n", buffer_int[i]);
}
refresh();
free(buffer);
break;
}
}
flag_comandoOK2 = 1;
}
if (flag_comandoOK2 == 0 && strcmp(comando2, "escribir memoria") == 0)
{
printw("Ingrese proceso: \n");
printw(">");
refresh();
scanw("%d", &proc_id);
respuesta = verificar_proc_id(proc_id);
if (respuesta == 0)
{
printw("El proceso ingresado no existe en memoria.\n");
printw("Ingrese un proceso que exista en memoria.\n");
refresh();
}
else
{
printw("Ingrese base: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico);
printw("Ingrese offset: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico2);
printw("Ingrese cantidad de bytes a escribir: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico3);
valor_numerico = transformar_direccion_en_logica(valor_numerico, proc_id);
pthread_mutex_lock(&semProcesoActivo);
pthread_mutex_lock(&semCompactacion);
respuesta = atender_envio_bytes(valor_numerico, valor_numerico2, valor_numerico3, 0);
pthread_mutex_unlock(&semCompactacion);
pthread_mutex_unlock(&semProcesoActivo);
switch(respuesta)
{
case 0:
printw("Se escribio la memoria satisfactoriamente.\n");
refresh();
break;
case PROGRAMA_INVALIDO:
printw("El proceso es invalido.\n");
refresh();
break;
case SEGMENTATION_FAULT:
printw("Segmentation fault.\n");
refresh();
break;
}
}
flag_comandoOK2 = 1;
}
if (flag_comandoOK2 == 0 && strcmp(comando2, "destruir segmentos") == 0)
{
printw("Ingrese proceso: \n");
printw(">");
refresh();
scanw("%d", &proc_id);
pthread_mutex_lock(&semCompactacion);
respuesta = destruir_segmentos(proc_id);
pthread_mutex_unlock(&semCompactacion);
if (respuesta == 1)
{
log_info(logger, "Segmentos de proceso %d destruidos satisfactoriamente.", proc_id);
printw("Los segmentos del programa fueron destruidos satisfactoriamente.\n");
refresh();
}
else
{
printw("El programa ingresado no es valido.\n");
refresh();
}
flag_comandoOK2 = 1;
}
flag_comandoOK = 1;
}
if (flag_comandoOK == 0 && strcmp(comando, "retardo") == 0)
{
log_info(logger, "Se cambio el valor de retardo por consola.");
printw("Nuevo valor de retardo: ");
refresh();
scanw("%d", &nuevo_valor);
printw("Valor anterior de retardo: %d\n", retardo);
cambiar_retardo(nuevo_valor);
printw("Valor actual de retardo: %d\n", retardo);
refresh();
flag_comandoOK = 1;
}
if (flag_comandoOK == 0 && strcmp(comando, "algoritmo") == 0)
{
log_info(logger, "Se cambio el algoritmo por consola.");
printw("Se cambio el algoritmo.\n");
printw("Algoritmo anterior: %s\n", algoritmo);
cambiar_algoritmo();
printw("Algoritmo actual: %s\n", algoritmo);
refresh();
flag_comandoOK = 1;
}
if (flag_comandoOK == 0 && strcmp(comando, "compactacion") == 0)
{
log_info(logger, "Se pidio compactar memoria por consola.");
pthread_mutex_lock(&semCompactacion);
compactar_memoria();
pthread_mutex_unlock(&semCompactacion);
flag_comandoOK = 1;
}
if (flag_comandoOK == 0 && strcmp(comando, "dump procesos") == 0)
{
log_info(logger, "Se pidio dump de procesos.");
printw("¿Desea mostrar la informacion de todos los procesos? (s/n): ");
tecla_ingresada = getch();
printw("\n");
refresh();
printw("¿Desea guardar los datos del dump en un archivo en disco? (s/n): ");
tecla_ingresada2 = getch();
printw("\n");
refresh();
if (tecla_ingresada != 115)
{
printw("Ingrese el id del proceso que desea mostrar informacion: ");
refresh();
scanw("%d", &proc_id);
respuesta = verificar_proc_id(proc_id);
if (respuesta == 0)
{
printw("El proceso ingresado no existe en memoria.\n");
printw("Ingrese un proceso que exista en memoria.\n");
refresh();
}
else
{
pthread_mutex_lock(&semCompactacion);
dump_proceso(proc_id, tecla_ingresada2);
pthread_mutex_unlock(&semCompactacion);
}
}
else
{
pthread_mutex_lock(&semCompactacion);
dump_memoria(tecla_ingresada2);
pthread_mutex_unlock(&semCompactacion);
}
flag_comandoOK = 1;
}
if (flag_comandoOK == 0 && strcmp(comando, "dump memoria") == 0)
{
printw("¿Desea guardar los datos del dump en un archivo en disco? (s/n): ");
tecla_ingresada = getch();
printw("\n");
printw("Ingrese direccion de memoria de comienzo: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico);
printw("Ingrese cantidad de bytes a leer: \n");
printw(">");
refresh();
scanw("%d", &valor_numerico2);
if (valor_numerico + valor_numerico2 <= space && valor_numerico >= 0 && valor_numerico2 >= 0)
{
pthread_mutex_lock(&semCompactacion);
mostrar_memoria(valor_numerico, valor_numerico2, tecla_ingresada);
pthread_mutex_unlock(&semCompactacion);
}
printw("\n");
flag_comandoOK = 1;
}
if (flag_comandoOK == 0 && strcmp(comando, "help") == 0)
{
printw("Los unicos comandos habilitados son: \n");
printw("\toperacion\n");
printw("\tretardo\n");
printw("\talgoritmo\n");
printw("\tcompactacion\n");
printw("\tdump memoria\n");
printw("\tdump procesos\n");
refresh();
flag_comandoOK = 1;
}
if(flag_comandoOK == 0)
{
printw("Por favor verifique la sintaxis de los comandos utilizados.\n");
printw("Los unicos comandos habilitados son: \n");
printw("\toperacion\n");
printw("\tretardo\n");
printw("\talgoritmo\n");
printw("\tcompactacion\n");
printw("\tdump memoria\n");
printw("\tdump procesos\n");
refresh();
}
}
}
void atender_kernel(int sock)
{
t_mensaje mensaje;
if (recv(sock, &mensaje, sizeof(t_mensaje), 0) == 0)
{
log_error(logger, "Kernel desconectado.");
depuracion(SIGINT);
}
t_msg_destruir_segmentos msg;
t_msg_crear_segmento msg2;
t_msg_envio_bytes msg3;
int respuesta;
switch(mensaje.tipo)
{
case DESTRUIRSEGMENTOS:
pthread_mutex_lock(&semRetardo);
usleep(retardo);
pthread_mutex_unlock(&semRetardo);
pthread_mutex_lock(&semCompactacion);
if (recv(sock, &msg, sizeof(t_msg_destruir_segmentos), 0) == 0)
{
log_error(logger, "Kernel desconectado.");
depuracion(SIGINT);
}
log_info(logger, "Se recibio peticion para destruir segmentos de kernel.");
mensaje.datosNumericos = destruir_segmentos(msg.id_programa);
pthread_mutex_unlock(&semCompactacion);
send(sock, &mensaje, sizeof(t_mensaje), 0);
log_info(logger, "Se eliminaron segmentos de programa %d", msg.id_programa);
break;
case CREARSEGMENTO:
pthread_mutex_lock(&semRetardo);
usleep(retardo);
pthread_mutex_unlock(&semRetardo);
pthread_mutex_lock(&semCompactacion);
if (recv(sock, &msg2, sizeof(t_msg_crear_segmento), 0) == 0)
{
log_error(logger, "Kernel desconectado.");
depuracion(SIGINT);
}
log_info(logger, "Se recibe peticion para crear segmento de kernel.");
mensaje.datosNumericos = crear_segmento(msg2.id_programa, msg2.tamanio);
pthread_mutex_unlock(&semCompactacion);
mensaje.id_proceso = UMV;
send(sock, &mensaje, sizeof(t_mensaje), 0);
log_info(logger, "Se creo segmento de programa %d", msg2.id_programa);
break;
case ENVIOBYTES:
pthread_mutex_lock(&semRetardo);
usleep(retardo);
pthread_mutex_unlock(&semRetardo);
pthread_mutex_lock(&semProcesoActivo);
pthread_mutex_lock(&semCompactacion);
if (recv(sock, &msg, sizeof(t_msg_cambio_proceso_activo), 0) == 0)
{
log_error(logger, "Kernel desconectado.");
depuracion(SIGINT);
}
proceso_activo = msg.id_programa;
if (recv(sock, &msg3, sizeof(t_msg_envio_bytes), 0) == 0)
{
log_error(logger, "Kernel desconectado.");
depuracion(SIGINT);
}
log_info(logger, "Se recibio envio de bytes de kernel.");
respuesta = atender_envio_bytes(msg3.base, msg3.offset, msg3.tamanio, sock);
if (respuesta != 0)
{
mensaje.tipo = respuesta;
mensaje.id_proceso = proceso_activo;
send(sock, &mensaje, sizeof(t_mensaje), 0);
}
log_info(logger, "Se recibieron %d bytes de programa %d", msg3.tamanio, msg.id_programa);
pthread_mutex_unlock(&semCompactacion);
pthread_mutex_unlock(&semProcesoActivo);
break;
}
}
