void gestionarDeadLock() {
int i;
t_list* bloqueados = obtenerPersonajesEnDL(listaRecursos, listaPersonajes);
ITEM_NIVEL * temp = NULL;
ITEM_NIVEL * menor = NULL;
if (list_is_empty(bloqueados) || bloqueados->elements_count == 1) {
list_destroy_and_destroy_elements(bloqueados, (void *) free);
return;
}
logBloqueados(bloqueados);
if (!configObj->recovery) {
return;
}
menor = list_get(bloqueados, 0);
for (i = 0; i < list_size(bloqueados); i++) {
temp = list_get(bloqueados, i);
if (temp->socket < menor->socket) {
menor = temp;
}
}
log_info(logFile, "Victima DeadLock: %c", menor->id);
notificarMuertePersonaje(menor->id, VICTIMA_DEADLOCK);
list_destroy_and_destroy_elements(bloqueados, (void *) free);
}
void liberaMemoriaMarta(t_estructuraMarta* ptrMarta) {
list_destroy_and_destroy_elements(ptrMarta->listaArchivosProcesados,
(void*)liberaMemoriaArchivoProcesado);
list_destroy_and_destroy_elements(ptrMarta->listaInformacionDelArchivo,
(void*)liberaMemoriaInformacionArchivo);
list_destroy_and_destroy_elements(ptrMarta->listaSolicitudes,
(void*)liberaMemoriaSolicitud);
free(ptrMarta);
}
void freeJob(t_job *job) {
list_iterate(job->maps, (void *) removeMapNode);
list_destroy_and_destroy_elements(job->files, (void *) freeFile);
list_destroy_and_destroy_elements(job->maps, (void *) freeMap);
list_destroy_and_destroy_elements(job->partialReduces, (void *) freeReduce);
freeReduce(job->finalReduce);
free(job->resultFile);
free(job);
}
void finalizar_panel(void)
{
if(proceso_tipo == KERNEL) {
list_destroy_and_destroy_elements(kernel_cpus_conectadas, (void *) free);
list_destroy_and_destroy_elements(kernel_consolas_conectadas, (void *) free);
}
log_destroy(logger);
}
void liberaMemoriaJob(t_job* ptrJob) {
list_destroy_and_destroy_elements(ptrJob->listaSolicitudDeTrabajo,
(void*) liberaMemoriaSolicitudDeTrabajo);
list_destroy_and_destroy_elements(ptrJob->listasTareasMap,
(void*) liberaMemoriaTareaMap);
list_destroy_and_destroy_elements(ptrJob->listasTareasReduce,
(void*) liberaMemoriaTareaReduce);
free(ptrJob);
}
void *comienzaPCP() {
listaVarCompartidas = list_create(); // Lista de las variables compartidas
listaSemaforos = list_create(); // Lista de Semaforos
listaIO = list_create(); // Lista de los Dispositivos IO
listaBloqueados = list_create(); //Lista de procesos bloqueados por semaforo
config = config_create(getenv("CONFIG_KERNEL"));
log_pcp = creacionLog(config_get_string_value(config, "LOG_KERNEL"), "PCP");
log_debug(log_pcp, "Inicia el proceso PCP..");
log_trace(log_pcp, "Creado log del PCP");
log_trace(log_pcp, "Cargado el archivo de configuracion");
// ######################## Cargo Archivo de config ######################## //
// Cargo QUANTUM y retardo Quantum en estructuraInicial
estructuraInicial = malloc(sizeof(t_EstructuraInicial));
estructuraInicial->Quantum = config_get_int_value(config, "QUANTUM");
estructuraInicial->RetardoQuantum = config_get_int_value(config, "RETARDO");
log_trace(log_pcp, "Cargado el Quantum: %d , retardoQuantum:%d",
estructuraInicial->Quantum, estructuraInicial->RetardoQuantum);
cpuAcerrar=0;
// Cargo las varCompartidas en listaVarCompartidas asi es mas comodo manejarlas
cargoVarCompartidasEnLista();
// Cargo los semaforos en listaSemaforos
cargoSemaforosEnLista();
// Cargo los IO en listaIO
cargoIOenLista();
pthread_t hiloIO, hiloPCB; //hilo por IO y PCB
sem_init(&semClienteOcioso, 1, 0); // Semaforo para clientes ociosos
//Creo hilo por cada dispositivo
void _creoHilos(void* entradaSalida) {
if (pthread_create(&hiloIO, NULL, hiloPorIO, (void*) entradaSalida)
!= 0) {
perror("could not create thread");
}
}
list_iterate(listaIO, (void*) _creoHilos);
// creo hilo para manejar programas que se cierren inesperadamente
if (pthread_create(&hiloPCB, NULL, (void*) hiloPCBaFinalizar, NULL ) != 0) {
perror("could not create thread");
}
// ######################## Fin loading ######################## //
server_cpu();
config_destroy(config);
log_destroy(log_pcp);
list_destroy_and_destroy_elements(listaVarCompartidas, free);
list_destroy_and_destroy_elements(listaIO, free);
list_destroy_and_destroy_elements(listaSemaforos, free);
return 0;
}
void limpiar_estructuras_swap() {
log_destroy(loggerDebug);
log_destroy(loggerError);
log_destroy(loggerInfo);
list_destroy_and_destroy_elements(metricas, free);
list_destroy_and_destroy_elements(espacioLibre, free);
list_destroy_and_destroy_elements(espacioOcupado, free);
sem_destroy(&sem_mutex_libre);
sem_destroy(&sem_mutex_ocupado);
free(arch);
clean_socket(socketServidor);
}
void liberaMemoriaUbicacionBloque(t_ubicacionBloque* ptrUbicacionBloque) {
list_destroy_and_destroy_elements(
ptrUbicacionBloque->listaRelacionesNodoBloque,
(void*) liberaMemoriaRelacionNodoBloque);
free(ptrUbicacionBloque);
}
void recibirOrdenReduce(int socketQueEscribe){
uint32_t longNombreEnDondeGuardarlo;
recibir(socketQueEscribe,&longNombreEnDondeGuardarlo,sizeof(uint32_t));
char* nombreEnDondeGuardarlo = malloc(longNombreEnDondeGuardarlo);
recibir(socketQueEscribe,nombreEnDondeGuardarlo,longNombreEnDondeGuardarlo);
//uint32_t tamanioPaquete;
//recv(socketQueEscribe, &tamanioPaquete, sizeof(tamanioPaquete),0);
//printf("recibi el tamanioPaquete: %d\n", tamanioPaquete);
//char* mensajeSerializado = malloc(tamanioPaquete);
//recibir(socketQueEscribe,mensajeSerializado, tamanioPaquete);
//t_list* listaNodoNombres = deserializarOrdenDeReduce(mensajeSerializado);
t_list* listaNodoNombres = recibirEstructurasDelNodo(socketQueEscribe);
char* identificador = string_itoa(socketQueEscribe);
char* nombre = "reducer.pl";
//logearOrdenReduce(identificador,nombre);
string_append(&identificador,nombre);
char respuesta = ejecutarReduce(identificador,nombreEnDondeGuardarlo,listaNodoNombres);
enviarRespuestaDelMapAlJob(respuesta,socketQueEscribe);
free(nombreEnDondeGuardarlo);
list_destroy_and_destroy_elements(listaNodoNombres, (void*) estructuraN_destroy);
}
void procesarReaddir(t_log *s_log,t_socket_client *client,void *buffer,Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs){
void *path;
uint32_t nroInodo;
size_t block_size = 1024 << sb->s_log_block_size;
t_list *listaDir;
SerReadDir_resp respuesta;
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito READDIR: %s",client->socket->desc,(char *)buffer);
pthread_mutex_unlock(&mt_log);
path = (char *)buffer; //payload = path
nroInodo = Dir_buscarPath(ext2fs,path,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
}else{
Sincro_monitorLock(nroInodo,listaInodos,TIPOREAD);
listaDir = Dir_listar(ext2fs,nroInodo,sb->s_inodes_per_group,bgdt,block_size);
Sincro_monitorUnlock(nroInodo,listaInodos);
respuesta = serializar_readdir_Rta(listaDir);
sockets_send(client,respuesta.paquete,respuesta.tamano+HEADERSIZE);
list_destroy_and_destroy_elements(listaDir,(void *) Dir_destroy);
free(respuesta.paquete);
}
free(path);
}
int removerPersonaje(header_t *header, datos_planificador_t *datosPlan,
char *motivo) {
int nbytes = 0;
char *data = malloc(header->length);
nbytes = recv(datosPlan->sockfdNivel, data, header->length, MSG_WAITALL);
char idPersonaje;
memcpy(&idPersonaje, data, sizeof(char));
t_list *recursosLiberados = listaRecursos_deserializer(data + sizeof(char),
header->length - sizeof(char));
free(data);
datos_personaje_t *personajeMuerto = removerPersonajePorSimbolo(datosPlan,
idPersonaje);
t_list *recursosUsados = desbloquearPersonajes(recursosLiberados,
datosPlan);
nbytes = informarRecursosUsados(recursosUsados, datosPlan);
list_destroy_and_destroy_elements(recursosUsados, (void *) free);
if (personajeMuerto == NULL )
log_warning(logFile, "Personaje %c muerto no encontrado.", idPersonaje);
else {
nbytes = notificarMuertePersonaje(personajeMuerto, datosPlan);
log_info(logFile, "Personaje %c muerto por %s.",
personajeMuerto->simbolo, motivo);
FD_CLR(personajeMuerto->sockfd, datosPlan->bagMaster);
close(personajeMuerto->sockfd);
datosPersonaje_destroy(personajeMuerto);
}
return nbytes;
}
int main(int argc, char*argv[]) {
pthread_mutex_init(&semModificadorDeVidas, NULL);
sem_init(&semReinicio, 0, 0);
sem_init(&semFinPlan, 0, 0);
// Inicializa el log.
logger = logInit(argv, "PERSONAJE");
if (signal(SIGINT, muertoPorSenial) == SIG_ERR) {
log_error(logger, "Error en el manejo de la senal de muerte del personaje.\n", stderr);
exit(EXIT_FAILURE);
}
if (signal(SIGTERM, restarVida) == SIG_ERR) {
log_error(logger, "Error en el manejo de la senal de restar vidas del personaje.\n", stderr);
exit(EXIT_FAILURE);
}
if (signal(SIGUSR1, sig_aumentar_vidas) == SIG_ERR) {
log_error(logger, "Error en el manejo de la senal de de aumentar vidas del personaje.\n", stderr);
exit(EXIT_FAILURE);
}
// Creamos el archivo de Configuración
cargarArchivoConfiguracion(argv[1]);
//Me conecto con la plataforma para despues de terminar todos los niveles correctamente avisarle
socketOrquestador = connectToServer(ip_plataforma, atoi(puerto_orq), logger);
log_debug(logger, "El personaje se conecto con el orquestador");
//vuelve a tirar todos los hilos por todos los niveles
do {
log_debug(logger, "Tiro los hilos para jugar en cada nivel");
reiniciar = false;
crearTodosLosHilos();
sem_wait(&semReinicio);
sem_wait(&semFinPlan);
//Ya terminaron todos los hilos. Si murio el ultimo me va a decir que reinicie o no.
if (reiniciar) {
liberarHilos();
log_debug(logger, "El personaje %c termina su conexion y reinicia todos los niveles", personaje.simbolo);
}
} while (reiniciar);
notificarFinPlanNiveles();
cerrarConexion(&socketOrquestador);
log_debug(logger, "El personaje se desconecto del orquestador");
log_destroy(logger);
config_destroy(configPersonaje);
list_destroy_and_destroy_elements(personaje.lPersonajes, (void*) _liberar_personaje_individual);
exit(EXIT_SUCCESS);
}
void openFileListDestroy(open_file_list_t* list) {
pthread_mutex_lock(&list->mutex);
list_destroy_and_destroy_elements(list->open_file_list,
open_file_destroyer);
pthread_mutex_unlock(&list->mutex);
pthread_mutex_destroy(&list->mutex);
free(list);
}
void freeFile(t_file *file) {
if (file->path) {
free(file->path);
}
list_destroy_and_destroy_elements(file->blocks, (void *) freeCopies);
free(file);
}
void liberaMemoriaInformacionArchivo(
t_informacionDelArchivo* ptrInformacionArchivo) {
free(ptrInformacionArchivo->nombreArchivo);
list_destroy_and_destroy_elements(
ptrInformacionArchivo->listaUbicacionBloques,
(void*) liberaMemoriaInformacionArchivo);
free(ptrInformacionArchivo);
}
void spock_destroy(t_spock* spock) {
if (spock != NULL) {
free(spock->nombre);
mascota_destroy(spock->mascota);
mision_destroy(spock->mision);
list_destroy_and_destroy_elements(spock->villanos, (void*) villano_destroy);
free(spock);
}
}
void finish(){
// crear una funcion que libere BIEN el job de la lista, que incluya diccionario..
list_destroy_and_destroy_elements(lista_jobs, (void*)free);
dictionary_clean_and_destroy_elements(mapa_nodos, (void*)free);
pthread_mutex_destroy(&mutex_mapa_nodos);
pthread_mutex_destroy(&mutex_lista_jobs);
log_destroy(LOGGER);
config_destroy(CONF);
}
void freeReduce(t_reduce *reduce) {
if (reduce->finalNode != NULL) {
free(reduce->finalNode);
}
if (reduce->nodeIP != NULL) {
free(reduce->nodeIP);
}
list_destroy_and_destroy_elements(reduce->temps, (void *) freeTemp);
free(reduce);
}
void freeMaRTA() {
if (cfgMaRTA->fsIP) {
free(cfgMaRTA->fsIP);
}
free(cfgMaRTA);
list_destroy_and_destroy_elements(nodes, (void *) freeNode);
pthread_mutex_destroy(&McantJobs);
pthread_mutex_destroy(&Mnodes);
log_destroy(logger);
exit(0);
}
bool filesystem_format() {
log_info(mdfs_logger, "Format FS.");
if (mongo_dir_deleteAll() && mongo_file_deleteAll()) {
t_list *nodes = mongo_node_getAll();
list_iterate(nodes, (void *) filesystem_formatNode);
list_destroy_and_destroy_elements(nodes, (void *) node_free);
return 1;
}
return 0;
}
int gestionarDesbloqueoPersonajes(header_t *header,
datos_planificador_t *datosPlan) {
int nbytes = 0;
if (header->length == 0) {
nbytes = informarRecursosUsados(NULL, datosPlan);
} else {
char *data = malloc(header->length);
nbytes = recv(datosPlan->sockfdNivel, data, header->length,
MSG_WAITALL);
t_list *recursosLiberados = listaRecursos_deserializer(data,
header->length);
free(data);
t_list *recursosUsados = desbloquearPersonajes(recursosLiberados,
datosPlan);
nbytes = informarRecursosUsados(recursosUsados, datosPlan);
list_destroy_and_destroy_elements(recursosUsados, (void *) free);
list_destroy_and_destroy_elements(recursosLiberados, (void *) free);
}
return nbytes;
}
int main(int argc, char** argv) {
//Verifico que se haya recibido por parámetro el archivo config.
printf("%s", argv[1]);
if (argc <= 1) {
perror(
"Se debe ingresar la dirección de un archivo de configuración\n");
return EXIT_FAILURE;
}
t_config *config = config_create(argv[1]);
//Verifico que estén todos los valores esperados en el config.
if (validarConfig(config)) {
config_destroy(config);
perror("El archivo de configuración no es correcto");
return EXIT_FAILURE;
}
//Cargo parámetros del config en variables de UMV.
cargarConfig(config);
//Creo Log.
logger = log_create("logUmv", "UMV", false, LOG_LEVEL_TRACE);
log_info(logger, "Comienza la ejecución de la UMV.");
baseUMV = malloc(tamanoUMV);
listaProcesos = list_create();
int* sinParametros=baseUMV;
//Creo hilo que atiende a la consola.
if (pthread_create(&atencion_consola, NULL, (void *) consola, (void*)sinParametros )) {
log_error(logger, "Hubo un error en la creación del hilo de consola");
} else {
log_info(logger, "El hilo de consola se creó correctamente");
}
//Creo hilo que creará hilos que atienden al kernel/cpu's.
if (pthread_create(&atencion_interna, NULL, (void *) atencionInterna,
(void*)sinParametros )) {
log_error(logger, "Hubo un error en la creación del hilo de atención interna");
} else {
log_info(logger, "El hilo de atención interna se creó correctamente");
}
pthread_join(atencion_consola,NULL);
pthread_join(atencion_interna,NULL);
list_destroy_and_destroy_elements(listaProcesos, (void*)free);
config_destroy(config);
log_info(logger, "El proceso UMV ha finalizado");
log_destroy(logger);
return EXIT_SUCCESS;
}
bool hayCaja(int x, int y){
int i = 0;
bool hay = false;
tRecursosNivel * recurso;
t_list * listaRecursosNivel = obtenerListaCajas();
while(i< list_size(listaRecursosNivel) && !hay){
recurso = list_get(listaRecursosNivel, i);
if (recurso->posX == x && recurso->posY == y)
hay = true;
i++;
}
list_destroy_and_destroy_elements(listaRecursosNivel, (void*)recurso_destroy);
return hay;
}
/**
* @NAME: finalizarPersonaje
* @DESC: Finaliza todas las variables y estructuras que fueron creadas para el proceso personaje
*/
void finalizarPersonaje() {
log_info(LOGGER, "FINALIZANDO PROCESO PERSONAJE\n");
reiniciar(false);
// TODO Bajar Hilos
finalizarHilosPersonaje();
pthread_mutex_destroy(&mutexEnvioMensaje);
pthread_mutex_destroy(&mutexVidas);
pthread_mutex_destroy(&mutexListaHilosxNivel);
pthread_mutex_destroy(&mutexReinicio);
list_destroy_and_destroy_elements(listaHilosxNivel, (void*)destruirEstructuraHiloPersonaje);
queue_destroy_and_destroy_elements(planDeNiveles, (void*)destruirObjetivosxNivel);
destruirConfigPersonaje();
log_destroy(LOGGER);
}
t_list * buscarPersonajesAtacables(){
int i;
int j;
t_personaje_niv1 * personaje;
tRecursosNivel * caja;
bool encontrado;
t_list * listaPersonajesAtacablesUbicaciones;
t_list * listaRecursosNivel;
t_list * lista = list_create();
listaPersonajesAtacablesUbicaciones = obtenerListaPersonajesAtacables();
listaRecursosNivel = obtenerListaCajas();
int cantPersonajesEnNivel = list_size(listaPersonajesAtacablesUbicaciones);
int cantCajas = list_size(listaRecursosNivel);
if (cantPersonajesEnNivel > 0){
for(i=0;i<cantPersonajesEnNivel;i++){
personaje = list_get(listaPersonajesAtacablesUbicaciones,i);
encontrado = false;
j=0;
while (j<cantCajas && !encontrado){
caja = list_get(listaRecursosNivel, j);
if (personajeEstaEnCaja(personaje, caja->posX, caja->posY))
encontrado = true;
j++;
}
if(!encontrado)
list_add(lista,personaje);
else
personaje_destroy(personaje);
}
}
list_destroy(listaPersonajesAtacablesUbicaciones);
list_destroy_and_destroy_elements(listaRecursosNivel, (void*)recurso_destroy);
return lista;
}
void tratarFinalizacionPersonaje(char* data) {
// TODO: REvisar con plataforma
char pId;
t_list* adquiridos = NULL;
// t_list* asignados = NULL;
pId = data[0];
log_info(logFile, "Matando personaje..");
adquiridos = getObjetosAdquiridosSerializable(listaPersonajes, pId);
log_error(logFile, "Saco %c de listaPersonajes.", pId);
matarPersonaje(listaPersonajes, listaRecursos, pId, logFile);
mandarRecursosLiberados(adquiridos);
// asignados = esperarRecursosAsignadosMain();
// actualizarEstado(asignados);
// listaRecursos_destroy(adquiridos);
// listaRecursos_destroy(asignados);
// log_info(logFile, "El personaje: %c, finalizo el nivel", pId);
// dibujar();
list_destroy_and_destroy_elements(adquiridos, (void *)free);
}
void handler_crear_segmento(uint32_t *respuesta, char *orden, t_param_memoria *parametros_memoria, char **savePtr1, t_log *logger)
{
char *id_prog = strtok_r(NULL, ",", savePtr1);
char *tamanio = strtok_r(NULL, ",", savePtr1);
pthread_mutex_lock(&op_atomica);
void *mem_ppal = parametros_memoria->mem_ppal;
uint32_t tamanio_mem_ppal = parametros_memoria->tamanio_mem_ppal;
t_list *lista_segmentos = parametros_memoria->listaSegmentos;
char *algoritmo_compactacion = parametros_memoria->algoritmo_comp;
t_list *espacios_libres = buscarEspaciosLibres(lista_segmentos, mem_ppal, tamanio_mem_ppal);
*respuesta = crearSegmento(atoi(id_prog), atoi(tamanio), espacios_libres, lista_segmentos, algoritmo_compactacion);
if(*respuesta == 0){
log_info(logger, "[ATENCION_CONN] No hay espacio para este segmento. Voy a intentar compactar.");
compactar(lista_segmentos, mem_ppal, tamanio_mem_ppal);
if (!list_is_empty(espacios_libres)) {
list_clean_and_destroy_elements(espacios_libres, eliminarEspacioLibre);
}
list_destroy(espacios_libres);
espacios_libres = buscarEspaciosLibres(lista_segmentos, mem_ppal, tamanio_mem_ppal);
*respuesta = crearSegmento(atoi(id_prog), atoi(tamanio), espacios_libres, lista_segmentos, algoritmo_compactacion);
if((*respuesta == 0) || (respuesta == NULL))
log_info(logger, "[ATENCION_CONN] No hay lugar para crear un segmento, incluso después de haber compactado la memoria.");
}
list_destroy_and_destroy_elements(espacios_libres, eliminarEspacioLibre);
pthread_mutex_unlock(&op_atomica);
if(respuesta == NULL)
log_info(logger, "[ATENCION_CONN] RESPUESTA ES NULL!!!! QUE CARAJO PASÓ???");
log_info(logger, "[ATENCION_CONN] La respuesta al comando crear_segmento será: %d.", *respuesta);
return;
}
int main(int argc, char *argv[]) {
logger = log_create("MaRTA.log", "MaRTA", 1, log_level_from_string("TRACE"));
cantJobs = 0;
if (argc != 2) {
log_error(logger, "Missing config file");
freeMaRTA();
return EXIT_FAILURE;
}
if (!initConfig(argv[1])) {
log_error(logger, "Config failed");
freeMaRTA();
return EXIT_FAILURE;
}
nodes = list_create();
signal(SIGINT, freeMaRTA);
initConnection();
list_destroy_and_destroy_elements(nodes, (void *) freeNode);
freeMaRTA();
return EXIT_SUCCESS;
}
void liberaMemoriaTareaMap(t_tareaMap* ptrTareaMap) {
free(&ptrTareaMap->dirMapExec);
list_destroy_and_destroy_elements(ptrTareaMap->listaRelacionNodoBloque,
(void*) liberaMemoriaRelacionNodoBloque);
free(ptrTareaMap);
}
void liberaMemoriaTareaReduce(t_tareaReduce* ptrTareaReduce) {
free(&ptrTareaReduce->dirReduceExec);
list_destroy_and_destroy_elements(ptrTareaReduce->listaRelacionNodoArchTemp,
(void*) liberaMemoriaRelacionNodoArchTemp);
free(ptrTareaReduce);
}
