char* informarEntradaSalida(t_pcb* pcb, int32_t tiempo, char* resultadosDeEjecuciones,sock_t* socketPlanificador){
int32_t status;
int32_t cabecera = ENTRADA_SALIDA;
uint32_t offset=0;
int medidaAMandar;
char* mensaje = string_new();
string_append(&mensaje,resultadosDeEjecuciones);
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pcb->idProceso));
string_append(&mensaje, " en entrada-salida de tiempo ");
string_append(&mensaje, string_itoa(tiempo));
string_append(&mensaje, "\n");
uint32_t longitudMensaje = strlen(mensaje);
uint32_t tamanioenteros, tamaniopath, path;
tamanioenteros = 4 * sizeof(uint32_t); //codigo+4 int de pcb
tamaniopath = sizeof(uint32_t);
path = strlen(pcb->path);
uint32_t tamanio = sizeof(cabecera) + sizeof(tiempo) + sizeof(uint32_t) + longitudMensaje + tamanioenteros + tamaniopath + path;
char* paqueteSerializado = malloc(tamanio);
/* Envio Cabecera-Retardo-MensajeALog */
medidaAMandar = sizeof(int32_t);
memcpy(paqueteSerializado, &cabecera,medidaAMandar);
offset += medidaAMandar;
medidaAMandar = sizeof(tiempo);
memcpy(paqueteSerializado + offset, &tiempo, medidaAMandar);
offset += medidaAMandar;
medidaAMandar = sizeof(uint32_t);
memcpy(paqueteSerializado + offset, &longitudMensaje, medidaAMandar); //longitud mensaje
offset += medidaAMandar;
medidaAMandar = longitudMensaje;
memcpy(paqueteSerializado + offset, mensaje, medidaAMandar);
offset += medidaAMandar;
/* Envio PCB */
medidaAMandar = sizeof(pcb->idProceso);
memcpy(paqueteSerializado + offset, &(pcb->idProceso),medidaAMandar);
offset += medidaAMandar;
medidaAMandar = sizeof(pcb->estadoProceso);
memcpy(paqueteSerializado + offset, &(pcb->estadoProceso), medidaAMandar);
offset += medidaAMandar;
medidaAMandar = sizeof(pcb->contadorPuntero);
memcpy(paqueteSerializado + offset, &(pcb->contadorPuntero), medidaAMandar);
offset += medidaAMandar;
medidaAMandar = sizeof(pcb->cantidadInstrucciones);
memcpy(paqueteSerializado + offset, &(pcb->cantidadInstrucciones),
medidaAMandar);
offset += medidaAMandar;
medidaAMandar = sizeof(uint32_t);
memcpy(paqueteSerializado + offset, &path, medidaAMandar);
offset += medidaAMandar;
medidaAMandar = path;
memcpy(paqueteSerializado + offset, pcb->path, medidaAMandar);
offset += medidaAMandar;
char* mensajeEnviar = malloc(tamanio);
memcpy(mensajeEnviar, paqueteSerializado, tamanio);
status = send(socketPlanificador->fd,mensajeEnviar,tamanio,0);
free(paqueteSerializado);
return "FIN";
}
char* generar_nombre_archivo_swap(uint32_t pid, uint16_t id_segmento, uint16_t id_pagina)
{
char *nombre_archivo;
nombre_archivo=concat_string(string_itoa(pid),string_itoa(id_segmento));
nombre_archivo=concat_string(nombre_archivo,string_itoa(id_pagina));
return nombre_archivo;
}
/*************************************************************************************************************************
F_SECUNDARIA: Obteniendo el VALOR dlong int IP, puerto o numBloque para una copiaX de un bloque X TESTEADO =)
****************************/
long int getValorDeUnaCopia_ArchivoDB (const bson_t * documento_X, int numBloque, int numDeCopia, char * claveRequerida)
{
bson_iter_t punteroDeBusqueda;
bson_iter_t valorEncontrado;
long int valorRequerido;
// GENERO LA CLAVE DE BUSQUEDA
//Ejemplo "Bloqlong int.IP" Bloques.numBloque.ArrayDeCopias.numDeCopia.claveRequerida (clavlong int IP o puerto o numDeBloque)
char *claveGenerada = string_new();
string_append(&claveGenerada, "Bloques");
string_append(&claveGenerada, ".");
string_append(&claveGenerada, string_itoa(numBloque));
string_append(&claveGenerada, ".copias.");
string_append(&claveGenerada, string_itoa(numDeCopia-1));
string_append(&claveGenerada, ".");
string_append(&claveGenerada, claveRequerida);
if (documento_X != NULL &&
bson_iter_init (&punteroDeBusqueda, documento_X) &&
bson_iter_find_descendant (&punteroDeBusqueda, claveGenerada, &valorEncontrado) &&
BSON_ITER_HOLDS_INT32 (&valorEncontrado))
{
valorRequerido = bson_iter_int32 (&valorEncontrado);
}
free(claveGenerada);
return valorRequerido;
}
void aplicarMapABloque(char *script_mapper, int nro_bloque, char *ruta_tmp,
int nombre_job) {
bloque_mapeado *datos_bloque = getBloque(nro_bloque);
char *comando_map, *resultado_script, *info_map;
char *p = string_itoa(nro_bloque);
char *pepe = string_itoa(nombre_job);
comando_map = malloc(strlen(script_mapper) + strlen(" |sort") + 1); //el +7 es por el | sort
resultado_script = malloc(strlen(ruta_tmp) + strlen("/resultadoMapBloque-") + 4 + strlen(".txt") + 1);
strcpy(resultado_script, ruta_tmp);
strcat(resultado_script, "/resultadoMapBloque-");
strcat(resultado_script, p);
strcat(resultado_script, ".txt");
strcpy(comando_map, script_mapper);
strcat(comando_map, " |sort");
info_map = malloc(strlen("Finalizacion con exito Map en bloque ") + 4 +strlen(" -> Job-")+4+1);
strcpy(info_map, "Finalizacion con exito Map en bloque ");
strcat(info_map, p);
strcat(info_map," -> Job-");
strcat(info_map,pepe);
free(pepe);
free(p);
ejecutarScriptMap(comando_map, datos_bloque, resultado_script);
pthread_mutex_lock(&mutex_actualizacion_listas);
actualizarEstadoBloques(resultado_script, nro_bloque, nombre_job);
pthread_mutex_unlock(&mutex_actualizacion_listas);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_TRACE, info_map);
free(datos_bloque);
free(comando_map);
free(info_map);
return;
}
void replanificarMapFallado(t_job* job, t_map* map){
int idNodoNuevo = *(map->idNodoOpcion2);
int idBloqueNuevo = *(map->idBloqueOpcion2);
bool by_idNodo(t_nodo* n) {
return (*(n->id) == idNodoNuevo);
}
t_nodo* nodo = list_find(nodosList, (void*)by_idNodo);
//guardo valores anteriores
int idNodoViejo = *(map->idNodo);
int idBloqueViejo = *(map->idBloque);
//actualizo el map
*(map->idNodo) = idNodoNuevo;
*(map->idBloque) = idBloqueNuevo;
list_add(job->maps, map);
char* mensajeAJob = string_new();
string_append(&mensajeAJob, MAP);
string_append(&mensajeAJob, "*");
char* resultFileName = string_new();
string_append(&resultFileName, TEMPLATE);
string_append(&mensajeAJob, nodo->ip);
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, nodo->puerto);
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, string_itoa(idNodoNuevo));
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, string_itoa(idBloqueNuevo));
string_append(&mensajeAJob, ",");
string_append(&mensajeAJob, string_duplicate(resultFileName));
string_append(&mensajeAJob, string_itoa(idNodoNuevo));
string_append(&mensajeAJob, string_itoa(idBloqueNuevo));
if(strlen(mensajeAJob) > 999){
char* nuevoheader = string_new();
string_append(&nuevoheader, SOY_MARTA); //1 digito
string_append(&nuevoheader, string_itoa(strlen(mensajeAJob)));//4 digitos
enviar(*(job->socket), "9999", 4); //falso header
enviar(*(job->socket), nuevoheader, 5); //header de 5
}else{
sendHeader(SOY_MARTA, strlen(mensajeAJob), *(job->socket));
}
enviar(*(job->socket), mensajeAJob, strlen(mensajeAJob));
printf("Replanificacion nodo %d, bloque %d enviada a job.\nNuevo map en nodo %d, bloque %d\n", idNodoViejo, idBloqueViejo, idNodoNuevo, idBloqueNuevo);
}
//Corre una funcion de otro proceso
bool runFunction(int socket, char * name, int n, ...)
{
/* ESTRUCTURA = [n],[name],[size(Ar_1)],[size(Ar_2)],...,[size(Ar_n)][Ar_1][Ar_2]...[Ar_n]
* n = cantidad de argumentos a enviar
* name = nombre de la funcion a ejecutar
* Ar_n = Argumento n
* size(Ar_n) = dimension del argumento n
*/
//Creacion de lista de argumentos dinamicos
va_list arguments;
va_start(arguments, n);
char * arg;
char * tmp;
int i;
char * packet_head = string_itoa(n); /* Cabeza del packete, lo inicio con la cantidad de argumentos que tendrá */
string_append(&packet_head, ","); /* Continuo con coma */
string_append(&packet_head, name); /* Continuo con el nombre de la funcion */
string_append(&packet_head, ","); /* Continuo con coma */
char * packet_boody = string_new(); /* Cuerpo del packete */
//Recorro argumentos recibidos
for (i = 0; i < n; i++)
{
arg = va_arg(arguments, char*); /* Extraigo argumento */
if(arg == NULL)
{
printf("Error, no se encuentran los parametos indicados");
exit(1);
}
//Agreo las dimensiones de cada argumento y las separo por comas (en el cabezal)
tmp = string_itoa(strlen(arg));
string_append(&packet_head, tmp);
free(tmp);
string_append(&packet_head, ",");
//Junto todos los argumentos sin separadores (en el cuerpo)
string_append(&packet_boody, arg);
}
//eliminación de lista de argumentos dinamicos
va_end(arguments);
//Dejo en el head el packete final
string_append(&packet_head, packet_boody);
free(packet_boody);
return sendMessage(socket, packet_head);
}
char* informarAdminMemoriaComandoEscribir(int32_t pid, int32_t numeroPagina,char* texto,sock_t* socketMemoria){
int32_t status;
int32_t entero;
int32_t cabecera = ESCRIBIR;
uint32_t longitudMensaje= strlen(texto);
uint32_t offset=0;
uint32_t tamanio = sizeof(cabecera) + sizeof(pid) + sizeof(numeroPagina) + longitudMensaje + sizeof(uint32_t);
char* message = malloc(tamanio);
memcpy(message, &cabecera, sizeof(cabecera));
offset = sizeof(cabecera);
memcpy(message + offset, &pid, sizeof(pid));
offset = offset + sizeof(pid);
memcpy(message + offset, &numeroPagina, sizeof(numeroPagina));
offset = offset + sizeof(numeroPagina);
memcpy(message + offset,&longitudMensaje, sizeof(uint32_t));
offset = offset + sizeof(uint32_t);
memcpy(message + offset, texto, longitudMensaje);
offset = offset + sizeof(longitudMensaje);
status = send(socketMemoria->fd,message,tamanio,0);
free(message);
if(!status) {
printf("No se envió el mensaje escribir al Administrador de Memoria.\n");
}
//Recibe respuesta
entero = deserializarEntero(socketMemoria);
cabecera = RESPUESTA_PLANIFICADOR_LOGEAR;
char* mensaje = string_new();
if(entero==PEDIDO_ERROR){//mProc X - Fallo Escritura
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje, " - Fallo Escritura.\n");
log_error(CPULog,"El pedido de escritura no fue exitoso.\n");
}else if(entero==ABORTAR){
log_warning(CPULog,"[PID:%s] El pedido de escritura abortó el proceso.\n",string_itoa(pid));
string_append(&mensaje, "ABORTAR");
}else{
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje, " - Página ");
string_append(&mensaje, string_itoa(numeroPagina));
string_append(&mensaje, " escrita: ");
string_append(&mensaje, texto);
string_append(&mensaje, "\n");
log_info(CPULog,"[PID:%s] [Página:%d] Se escribió %s\n", string_itoa(pid), numeroPagina, texto);
}
return mensaje;
}
void imprimir(t_valor_variable valor_mostrar){
if(!huboSegFault){
char *string_int = string_itoa(valor_mostrar);
enviar_men_comun_destruir(socketKernel, IMPRIMIR_VALOR, string_int, string_length(string_int)+BARRA_CERO);
char *aux_string = string_itoa(pcb->id);
enviar_men_comun_destruir(socketKernel, ID_PROG, aux_string, string_length(aux_string)+BARRA_CERO);
free(aux_string);
recibir_resp_kernel(R_IMPRIMIR);
txt_write_in_file(cpu_file_log, " Imprimiendo valor\n");
printf(" Imprimiendo valor: %s\n", string_int);
free(string_int);
}
}
//Devuelve un num positivo o Devuelve 0 si hay error
int getCantidadDeCopiasDe1Bloque_ArchivoDB(const bson_t * documento_X, int numBloque)
{
bson_iter_t punteroDeBusqueda;
bson_iter_t valorEncontrado;
int CantidadDeCopias = 0;
char *claveGenerada = string_new();
string_append(&claveGenerada, "Bloques");
string_append(&claveGenerada, ".");
string_append(&claveGenerada, string_itoa(numBloque));
string_append(&claveGenerada, ".");
string_append(&claveGenerada, "cantidadDeCopias");
if (documento_X != NULL &&
bson_iter_init (&punteroDeBusqueda, documento_X) &&
bson_iter_find_descendant (&punteroDeBusqueda, claveGenerada, &valorEncontrado) &&
BSON_ITER_HOLDS_INT32 (&valorEncontrado))
{
CantidadDeCopias = bson_iter_int32 (&valorEncontrado);
}
free(claveGenerada);
return CantidadDeCopias;
}
void imprimir(t_valor_variable valor_mostrar) {
log_info(logger,"Primitiva: Imprimir");
char* textoImprimir = string_itoa(valor_mostrar);
int longitud = strlen(textoImprimir)+1;
enviarImprimir(textoImprimir,pcb->PID,longitud);
free(textoImprimir);
}
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);
}
t_valor_variable asignarValorCompartida(t_nombre_compartida variable, t_valor_variable valor){
//le mando al kernel el nombre de la variable compartida
//le mando el valor que le quiero asignar
enviar_men_comun_destruir(socketKernel, GRABAR_VALOR, variable, string_length(variable)+BARRA_CERO);
t_men_comun *men_resp = socket_recv_comun(socketKernel);
if(men_resp->tipo == VAR_INEX){
txt_write_in_file(cpu_file_log, "Acceso a variable global inexistente \n");
printf(" Error en acceso a la variable %s, no existe", variable);
finalizarContexto(VAR_INEX);
destruir_men_comun(men_resp);
return -1;
}
if(men_resp->tipo == R_GRABAR_VALOR){
destruir_men_comun(men_resp);
char *c = string_itoa(valor);
enviar_men_comun_destruir(socketKernel, VALOR_ASIGNADO, c, string_length(c)+BARRA_CERO);
free(c);
men_resp = socket_recv_comun(socketKernel);
destruir_men_comun(men_resp);
return valor;
}
printf(" ERROR el kernel me mando:%i y se esperaba otro tipo\n",men_resp->tipo);
return -1;
}
void loguearSalidaJob(int nombreJob){
bool estaEnLaLista(trabajoPorJob *job_aux) {
return job_aux->nombre_job == nombreJob;
}
trabajoPorJob* resultado = list_find(trabajos_de_jobs,
(void*) estaEnLaLista);
if(resultado->ya_mostre_que_estoy==1){
char * mostrar_salida = malloc(strlen("Finalizacion trabajo -> Job-")+4+1);
strcpy(mostrar_salida,"Finalizacion trabajo -> Job-");
char*p=string_itoa(nombreJob);
strcat(mostrar_salida,p);
free(p);
loguearme(PATH_LOG, "Proceso Nodo", 1, LOG_LEVEL_INFO,mostrar_salida);
free(mostrar_salida);
resultado->ya_mostre_que_estoy=0;
}
return;
}
void cambiarNombre(int numero) {
char *archivo_mapeado;
int tamanio_archivo = 0;
int file_descriptor;
char*convertido;
file_descriptor = open(PATH, O_RDWR);
struct stat file;
fstat(file_descriptor, &file);
tamanio_archivo = file.st_size;
archivo_mapeado = mmap((caddr_t) 0, tamanio_archivo, PROT_WRITE, MAP_SHARED,
file_descriptor, 0);
convertido = string_itoa(numero);
archivo_mapeado[tamanio_archivo - 2] = convertido[0];
archivo_mapeado[tamanio_archivo - 1] = convertido[1];
free(convertido);
munmap(archivo_mapeado, tamanio_archivo);
}
char* juntarTodasLasRutasDeRecibidos(char* ruta_tmp, int nombreJob) {
rutas_temporales * rutas = crearDirectorioTemporal(ruta_tmp, nombreJob);
bool estaEnLaLista(trabajoPorJob *job_aux) {
return job_aux->nombre_job == nombreJob;
}
trabajoPorJob* job_aux = list_find(trabajos_de_jobs,
(void *) estaEnLaLista);
char* ruta_para_cat = malloc(
(strlen(rutas->ruta_recibido) + strlen("/recibido-") + 5
+ strlen(".txt ") + 1) * job_aux->recibido);
strcpy(ruta_para_cat,"");
int i = 0;
while (i < job_aux->recibido) {
strcat(ruta_para_cat, rutas->ruta_recibido);
strcat(ruta_para_cat, "/recibido-");
char*r = string_itoa(i);
strcat(ruta_para_cat, r);
free(r);
strcat(ruta_para_cat, ".txt ");
i++;
}
return ruta_para_cat;
}
char* informarAdminMemoriaComandoLeer(int32_t pid, char* pagina, sock_t* socketMemoria){
int32_t status;
int32_t numeroPagina = atoi(pagina);
int32_t cabecera = LEER;
uint32_t offset=0;
uint32_t tamanio = sizeof(cabecera) + sizeof(pid) + sizeof(numeroPagina);
char* message = malloc(tamanio);
memcpy(message, &cabecera, sizeof(cabecera));
offset = sizeof(cabecera);
memcpy(message + offset, &pid, sizeof(pid));
offset = offset + sizeof(pid);
memcpy(message + offset, &numeroPagina, sizeof(numeroPagina));
offset = offset + sizeof(numeroPagina);
status = send(socketMemoria->fd,message,tamanio,0);
free(message);
if(!status) {
printf("No se envió el mensaje leer Administrador de Memoria.\n");
}
char* mensaje = string_new();
int32_t lectura = deserializarEntero(socketMemoria);
if(lectura==PEDIDO_ERROR){
log_error(CPULog,"El pedido de lectura no fue exitoso.\n");
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje," - El pedido de lectura no fue exitoso.\n");
}else if(lectura==ABORTAR){
log_warning(CPULog,"[PID:%s] El pedido de lectura abortó el proceso.\n",string_itoa(pid));
string_append(&mensaje, "ABORTAR");
}else{
char* contenido = recibirMensaje(socketMemoria);
log_info(CPULog,"[PID:%s] Lectura realizada. Contenido: %s",string_itoa(pid),contenido);
//mProc 10 - Pagina 2 leida: contenido
cabecera = RESPUESTA_PLANIFICADOR_LOGEAR;
offset = 0;
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje, " - Pagina ");
string_append(&mensaje, pagina);
string_append(&mensaje," leida: ");
string_append(&mensaje,contenido);
string_append(&mensaje,"\n");
}
return mensaje;
}
int hiloCPU() {
t_cpu* cpu = crearCPU();
list_add(procCPU->listaCPU, cpu);
pthread_mutex_lock(&mutexCPULogs);
log_info(logger, identificaCPU(queHiloSoy()));
log_info(logger, "comienza ejecucion de un HILO ");
log_info(logger,
string_from_format("Me estoy levantando soy la cpu , %s \n",
cpu->nombre));
pthread_mutex_unlock(&mutexCPULogs);
// printf("Me estoy levantando soy la cpu , %s", cpu->nombre);
// printf("Creando CPU la id del hilo es %lu \n", cpu->idCPU);
//conexiones = dictionary_create();
int socketPlanificador;
int socketMemoria;
int resultConexion_mem = 0;
int resultConexion_planif = 0;
resultConexion_planif = conectar(configuracion->vg_ipPlanificador,
string_itoa(configuracion->vg_puertoPlanificador),
&socketPlanificador);
if (resultConexion_planif == -1)
pthread_mutex_lock(&mutexCPULogs);
log_info(logger, identificaCPU(queHiloSoy()));
log_error(logger, "[ERROR]no se conecto el CPU al Planificador");
pthread_mutex_unlock(&mutexCPULogs);
//dictionary_put(conexiones, "Planificador", string_itoa(socketPlanificador));
cpu->socketPlanificador = socketPlanificador;
enviarStruct(socketPlanificador, HANDSHAKE_CPU, getNombre());
resultConexion_mem = conectar(configuracion->vg_ipMemoria,
string_itoa(configuracion->vg_puertoMemoria), &socketMemoria);
if (resultConexion_mem == -1)
log_info(logger, identificaCPU(queHiloSoy()));
log_error(logger, "[ERROR]no se conecto el CPU a la memoria");
//dictionary_put(conexiones, "Memoria", string_itoa(socketMemoria));
cpu->socketMemoria = socketMemoria;
escucharConexiones("0", socketPlanificador, socketMemoria, 0,
procesarMensajes, NULL, logger);
return 0;
}
void logear_char(FILE* destino,char un_char){
if (un_char == '\0'){
char *aux_string = "\\0";
txt_write_in_file(destino, aux_string);
}else{
char *aux_string = string_itoa((int)un_char);
txt_write_in_file(destino, aux_string);
free(aux_string);
}
txt_write_in_file(destino,"-");
}
char* generarNombreRandom(){
char* nombreAleatorio;
nombreAleatorio = string_new();
int numero;
srand(rdtsc()); //semilla para crear el nro random
numero = rand();
nombreAleatorio = string_itoa(numero);
return nombreAleatorio;
}
void enviarPorcentaje(){
while (1) {
sem_wait(&semCpuPadre);
pthread_mutex_lock(&mutexListaCpus);
int32_t cabecera = PORCENTAJES_CPU;
int32_t offset = 0;
int32_t status;
char* listaTemporal = string_new();
t_CPUsConectados* temporal;
int32_t indice = 0;
while (indice < configuracion->cantidadHilos) {
temporal = list_get(listaCPU, indice);
string_append(&listaTemporal, "CPU:");
string_append(&listaTemporal, string_itoa(temporal->numeroCPU));
string_append(&listaTemporal, ", Porcentaje de uso:");
string_append(&listaTemporal, string_itoa(temporal->porcentajeProcesado));
string_append(&listaTemporal, "\n");
indice++;
}
int32_t tamListaTemp = strlen(listaTemporal);
int32_t tamanio = sizeof(int32_t) + sizeof(int32_t) + tamListaTemp;
char* message = malloc(tamanio);
memcpy(message, &cabecera, sizeof(int32_t));
offset = sizeof(int32_t);
memcpy(message + offset, &tamListaTemp, sizeof(int32_t));
offset = offset + sizeof(int32_t);
memcpy(message + offset, listaTemporal, tamListaTemp);
offset = offset + tamListaTemp;
status = send(socketPlanificadorPadre->fd,message,tamanio,0);
if (status <= 0) {
printf("Error al enviar el porcentaje a Planificador");
}
free(message);
free(listaTemporal);
pthread_mutex_unlock(&mutexListaCpus);
sem_post(&semPorcentaje);
}
}
/** Función que crea un socket para enviar la notificacion al Admin
* de Memoria, cuando se solicitó el comando "iniciar"
* @param cantidad de páginas
* @return int
* -1 Fallo: falta de espacio
* 1 Fallo: otro motivo
* 0 Exitoso
*/
char* informarAdminMemoriaComandoIniciar(char* cantidadPaginas, int32_t pid,sock_t* socketMemoria){
int32_t status;
int32_t entero;
//Envia aviso al Adm de Memoria: comando Iniciar.
int32_t cabecera = INICIAR;
int32_t paginas = atoi(cantidadPaginas);
uint32_t offset=0;
uint32_t tamanio = sizeof(cabecera) + sizeof(pid) + sizeof(paginas);
char* message = malloc(tamanio);
memcpy(message, &cabecera, sizeof(cabecera));
offset = sizeof(cabecera);
memcpy(message + offset, &pid, sizeof(pid));
offset = offset + sizeof(pid);
memcpy(message + offset, &paginas, sizeof(paginas));
offset = offset + sizeof(paginas);
status = send(socketMemoria->fd,message,tamanio,0);
free(message);
if(!status) {
printf("No se envió el mensaje iniciar al Administrador de Memoria.\n");
}
//Recibe respuesta
status = recv(socketMemoria->fd,&entero,sizeof(int32_t),0);
cabecera = RESPUESTA_PLANIFICADOR_LOGEAR;
char* mensaje = string_new();
if(entero==PEDIDO_ERROR){//mProc X - Fallo
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje, " - Fallo.\n");
log_error(CPULog,"Error por falta de memoria. Se finalizará el proceso.","ERROR");
}else{//mProc X - Iniciado
string_append(&mensaje, "mProc ");
string_append(&mensaje, string_itoa(pid));
string_append(&mensaje, " - Iniciado.\n");
printf("inicio correctamente\n");
}
return mensaje;
}
char* header(int numero){ //Recibe numero de bytes, y lo devuelve en 4 bytes (Ej. recibe "2" y devuelve "0002")
char* asd=string_new();
char* num_char = string_itoa(numero);
num_char = string_reverse(num_char);
string_append(&asd,num_char);
free(num_char);
string_append(&asd,"0000");
char* longitud=string_substring(asd,0,4);
free(asd);
char* longitudPosta=string_reverse(longitud);
free(longitud);
return longitudPosta;
}
void entradaSalida(t_nombre_dispositivo dispositivo, int tiempo){
enviar_men_comun_destruir(socketKernel, IO_ID, dispositivo, string_length(dispositivo)+BARRA_CERO);
char *aux_tiempo = string_itoa(tiempo);
enviar_men_comun_destruir(socketKernel, IO_CANT_UNIDADES,aux_tiempo , string_length(aux_tiempo)+BARRA_CERO);
free(aux_tiempo);
enviar_pcb_destruir();
fueFinEjecucion = 1;
entre_io =1;
txt_write_in_file(cpu_file_log, "Saliendo a IO en dispositivo\n");
printf(" Saliendo a IO ID:%s, cant. unidades:%d\n", dispositivo, tiempo);
}
bloque_mapeado* enviarMap(int nombreJob, int num_map) {
pthread_mutex_lock(&mutex_actualizacion_listas);
loguearSalidaJob(nombreJob);
pthread_mutex_unlock(&mutex_actualizacion_listas);
bloque_mapeado* bloque = malloc(sizeof(bloque_mapeado));
bool estaEnLaLista(trabajoPorJob *job_aux) {
return job_aux->nombre_job == nombreJob;
}
trabajoPorJob* resultado = list_find(trabajos_de_jobs,
(void*) estaEnLaLista);
int file_descriptor;
file_descriptor = open(resultado->trabajo_bloques[num_map], O_RDWR);
struct stat file;
fstat(file_descriptor, &file);
bloque->tamanio_bloque = file.st_size;
char* envio = malloc(file.st_size);
char *bloque_mapeado;
bloque_mapeado = mmap((caddr_t) 0, bloque->tamanio_bloque, PROT_WRITE,
MAP_SHARED, file_descriptor, 0);
memcpy(envio, bloque_mapeado, file.st_size);
bloque->bloque = envio;
munmap(bloque_mapeado, bloque->tamanio_bloque);
char * logueo_map_enviado=malloc(strlen("Envio Map ") + 4 + strlen(" al Nodo Principal")+1);
strcpy(logueo_map_enviado,"Envio Map ");
char * p = string_itoa(num_map);
strcat(logueo_map_enviado,p);
free(p);
strcat(logueo_map_enviado," al Nodo Principal");
loguearme(PATH_LOG, "Proceso Nodo", 0, LOG_LEVEL_INFO,logueo_map_enviado);
free(logueo_map_enviado);
return bloque;
}
void imprimirTexto(char* texto){
char *texto_sin_esc = sacar_caracteres_escape(texto);
enviar_men_comun_destruir(socketKernel, IMPRIMIR_TEXTO, texto_sin_esc, string_length(texto_sin_esc)+BARRA_CERO);
char *aux_string = string_itoa(pcb->id);
enviar_men_comun_destruir(socketKernel, ID_PROG, aux_string, string_length(aux_string)+BARRA_CERO);
free(aux_string);
recibir_resp_kernel(R_IMPRIMIR);
txt_write_in_file(cpu_file_log, " Imprimiendo texto\n");
printf(" Imprimiendo texto: %s\n", texto_sin_esc);
free(texto_sin_esc);
}
void printVariable(t_nodo_proceso_ejecutando* procesoEjecutando,
struct pollfd** socketsCPU, int* cantSocketsCpu, t_datosEnviar* paquete)
{
debugTrackPCP(" Request to print variable: %d", *(int*)paquete->data);
log_info(log_kernel,
"Request to print variable \" %d \", requested by the CPU with pid %d\n",
paquete->data, procesoEjecutando->cpu.pid);
char* traduccion = string_itoa(*((int*) paquete->data));
t_datosEnviar* mensaje = pedirPaquete(traduccion,
PROGRAMA_PAQUETE_PARA_IMPRIMIR, string_length(traduccion) + 1);
common_send(procesoEjecutando->proceso.soquet_prog, mensaje, NULL );
destruirPaquete(mensaje);
free(traduccion);
}
void aceptacionDeProceso(char* nombreProceso, int socket){
t_log_level nivel;
t_log* archivoDeLog;
nivel = LOG_LEVEL_INFO;
archivoDeLog = log_create("LogNodo", "Nodo", 0, nivel);
char *unaPalabra = string_new();
string_append(&unaPalabra, "Aceptacion de ");
string_append(&unaPalabra, nombreProceso);
string_append(&unaPalabra, " usando el socket ");
string_append(&unaPalabra, string_itoa(socket));
log_info(archivoDeLog,unaPalabra);
free(unaPalabra);
log_destroy(archivoDeLog);
}
void jlog_Desconexion(t_log* logger, char* Nombre, char* Ip, int Puerto) {
char* message;
message = string_new();
string_append(&message, "Desconectado: ");
string_append(&message, Nombre);
string_append(&message, ", IP: ");
string_append(&message, Ip);
string_append(&message, ", PORT: ");
string_append(&message, string_itoa(Puerto));
string_append(&message, '\n');
jlog_Info(logger, message);
free(message);
return;
}
void loguearLecturaDeBloques(int indiceDelBloque){
t_log_level nivel;
t_log* archivoDeLog;
nivel = LOG_LEVEL_INFO;
archivoDeLog = log_create("LogNodo", "Nodo", 0, nivel);
char *unaPalabra = string_new();
string_append(&unaPalabra, "Lectura del bloque: ");
string_append(&unaPalabra, string_itoa(indiceDelBloque));
log_info(archivoDeLog,unaPalabra);
free(unaPalabra);
free(unaPalabra);
log_destroy(archivoDeLog);
}
rutas_temporales *crearDirectorioTemporal(char *path_dir, int nombre_job) {
rutas_temporales *rutas = malloc(sizeof(rutas_temporales));
struct stat st = { 0 };
char *path_temp = malloc(strlen(path_dir) + strlen("/Job-") + 4);
strcpy(path_temp, path_dir);
strcat(path_temp, "/Job-");
char *p = string_itoa(nombre_job);
strcat(path_temp, p);
free(p);
if (stat(path_temp, &st) == -1) {
mkdir(path_temp, 0700);
}
char * recibido = malloc(strlen(path_temp) + strlen("/Recibido") + 1);
strcpy(recibido, path_temp);
strcat(recibido, "/Recibido");
struct stat sta = { 0 };
if (stat(recibido, &sta) == -1) {
mkdir(recibido, 0700);
}
rutas->ruta_recibido = recibido;
rutas->ruta_temp = path_temp;
return rutas;
}
