char* leerEnTLB(int PID, int pagina, int posicion, int tamanio) { accesosTLB++; int habilitada = tlbHabilitada(); char* buffer = malloc(sizeof(char) * tamanio); int j = 0; while (j != tamanio) { buffer[j] = '\0'; j++; } if (habilitada != 0) { t_tlb * entradaTLB = buscarEnTLB(PID, pagina); if (entradaTLB != NULL) { log_info(umclog, "Acierto de TLB en el frame %d y pagina %d", entradaTLB->frameTLB, entradaTLB->pagina); entradaTLB->momentoEntrada = accesosTLB; int inicioLectura = entradaTLB->frameTLB * marco_Size + posicion; int i; for (i = 0; i < tamanio; i++) { buffer[i] = memoriaReal[inicioLectura]; inicioLectura++; } return buffer; } } return solicitarBytes(PID, pagina, posicion, tamanio); }
int deserializarYejecutar(char** package, int sock, int* tipoProceso, int* procesoActivo) { //int *operacion; int operacion; int offset = 0; int respuestaINT; char algo[1]; int i; /*algo[0] = *package[0]; operacion = algo[0];*/ char * bufferRespuesta; memcpy(&algo, (*package + offset), sizeof(uint32_t)); //log_debug(ptrLog, "Ejecutamos la operacion:%d", operacion); operacion = algo[0]; char* respuestaOperacion = malloc(sizeof(int)); /*memory leak * * VERIFICAR * * deberia hacer un free de respuesOperacion cada vez que entra en cada case * * * */ //Compruebo que me haya hecho el handshake //if (*tipoProceso != KERNEL || *tipoProceso != CPU) { //le asigno -1 para que cuando vaya al case, caiga en el default //return -1; //} switch (operacion) { case 1: log_info(ptrLog, "En el case (SERVIDOR)"); log_debug(ptrLog, "Solicitar Bytes"); log_debug(ptrLog, "Operacion : %u ", *(*package)); log_debug(ptrLog, "Base : %u ", *(*package + sizeof(uint32_t))); log_debug(ptrLog, "Offset : %u ", *(*package + sizeof(uint32_t) + sizeof(uint32_t))); log_debug(ptrLog, "Tamanio: %u ", *(*package + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t))); t_solicitarBytes *estructuraSolicitarBytes = deserializarSolicitarBytes( package); log_debug(ptrLog, "Antes de ejecutar la fn solicitarBytes - Imprimiendo la estructura"); log_debug(ptrLog, "Base : %u ", estructuraSolicitarBytes->base); log_debug(ptrLog, "Offset : %u ", estructuraSolicitarBytes->offset); log_debug(ptrLog, "Tamanio : %u ", estructuraSolicitarBytes->tamanio); if (*tipoProceso == KERNEL || *tipoProceso == CPU) { //bufferRespuesta=malloc(estructuraSolicitarBytes->tamanio); bufferRespuesta = solicitarBytes(estructuraSolicitarBytes, procesoActivo); if (bufferRespuesta[0] == -1) { log_error(ptrLog, "SEGFAULT"); enviarDatos(sock, &bufferRespuesta, estructuraSolicitarBytes->tamanio, 0); } else { enviarDatos(sock, &bufferRespuesta, estructuraSolicitarBytes->tamanio, 0); log_debug(ptrLog, "Lo que se obtuvo es: "); for (i = 0; i < estructuraSolicitarBytes->tamanio; ++i) log_debug(ptrLog, "%x ", bufferRespuesta[i]); log_info(ptrLog, "SolicitarBytes en server correcto"); } free(bufferRespuesta); free(estructuraSolicitarBytes); free(respuestaOperacion); return 1; } else { log_error(ptrLog, "Se quiere ejecutar una operacion donde no hay una CPU o un Kernel"); log_error(ptrLog, "Se envia la respuesta fallida"); bufferRespuesta = malloc(4); respuestaINT = -1; memcpy(bufferRespuesta, &respuestaINT, sizeof(int)); enviarDatos(sock, &bufferRespuesta, sizeof(int), 0); free(estructuraSolicitarBytes); free(bufferRespuesta); free(respuestaOperacion); return 1; //VERIFICAR } case 2: log_debug(ptrLog, "En el case (SERVIDOR)"); log_debug(ptrLog, "Enviar Bytes"); log_debug(ptrLog, "Operacion: %u", *(*package)); log_debug(ptrLog, "Base: %u", *(*package + sizeof(uint32_t))); log_debug(ptrLog, "Offset: %u", *(*package + sizeof(uint32_t) + sizeof(uint32_t))); log_debug(ptrLog, "Tamanio: %u", *(*package + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t))); log_debug(ptrLog, "%u", *(*package + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t))); t_enviarBytes *estructuraEnviarBytes = deserializarEnviarBytes(package); log_debug(ptrLog, "Antes de ejecutar la fn enviarBytes - Imprimiendo la estructura"); log_debug(ptrLog, "Base: %u ", estructuraEnviarBytes->base); log_debug(ptrLog, "Offset: %u ", estructuraEnviarBytes->offset); log_debug(ptrLog, "Tamanio: %u ", estructuraEnviarBytes->tamanio); log_debug(ptrLog, "Se recibio en el buffer lo siguiente:"); for (i = 0; i < estructuraEnviarBytes->tamanio; ++i) log_debug(ptrLog, "%x ", estructuraEnviarBytes->buffer[i]); bufferRespuesta = malloc(sizeof(int)); if (*tipoProceso == KERNEL || *tipoProceso == CPU) { log_info(ptrLog, "Se procede a enviar bytes"); bufferRespuesta = enviarBytes(estructuraEnviarBytes, *procesoActivo); if (bufferRespuesta[0] == -1) { log_error(ptrLog, "SEGFAULT"); enviarDatos(sock, &bufferRespuesta, sizeof(int), 0); } else { enviarDatos(sock, &bufferRespuesta, sizeof(int), 0); log_info(ptrLog, "Se envio bytes"); } free(bufferRespuesta); free(estructuraEnviarBytes->buffer); free(estructuraEnviarBytes); free(respuestaOperacion); return 1; } else { log_error(ptrLog, "Se quiere ejecutar una operacion donde no hay una CPU o un Kernel"); log_error(ptrLog, "Se envia la respuesta fallida"); bufferRespuesta = malloc(4); respuestaINT = -1; memcpy(bufferRespuesta, &respuestaINT, sizeof(int)); enviarDatos(sock, &bufferRespuesta, sizeof(int), 0); free(estructuraEnviarBytes); free(estructuraEnviarBytes->buffer); free(bufferRespuesta); free(respuestaOperacion); return 1; //VERIFICAR } case 3: log_debug(ptrLog, "En el case (SERVIDOR)"); log_debug(ptrLog, "Handshake"); log_debug(ptrLog, "Tipo de cliente: %u", *(*package + sizeof(uint32_t))); //log_debug(ptrLog, "%u", // *(*package + sizeof(uint32_t) + sizeof(uint32_t))); handshake(deserializarHandshake(package), tipoProceso); //Ejecutar funcion Handshake free(respuestaOperacion); return 1; case 4: log_debug(ptrLog, "En el case (SERVIDOR)"); log_debug(ptrLog, "Cambio de proceso activo"); log_debug(ptrLog, "PID: %u", **package + sizeof(uint32_t)); if (*tipoProceso == KERNEL || *tipoProceso == CPU) { log_info(ptrLog, "Se procede a cambiar el PID activo"); cambiarProcesoActivo(deserializarCambiarProcesoActivo(package), procesoActivo); free(respuestaOperacion); return 1; } else { log_error(ptrLog, "Se quiere ejecutar una operacion donde no hay una CPU o un Kernel"); free(respuestaOperacion); return 1; } case 5: log_debug(ptrLog, "En el case (SERVIDOR)"); log_debug(ptrLog, "Crear segmento"); log_debug(ptrLog, "PID %u", *(*package + sizeof(uint32_t))); //log_debug(ptrLog, "%u", // *(*package + sizeof(uint32_t) + sizeof(uint32_t))); if (*tipoProceso == KERNEL) { log_info(ptrLog, "Se procede a atender la solicitud de crear segmento del kernel"); respuestaINT = crearSegmento((deserializarCrearSegmento(package))); memcpy(respuestaOperacion, &respuestaINT, sizeof(int)); //Envio tamaño de la respuesta de la funcion enviarDatos(sock, &respuestaOperacion, sizeof(int), 0); free(respuestaOperacion); return 1; } else { respuestaINT = -1; memcpy(respuestaOperacion, &respuestaINT, sizeof(int)); enviarDatos(sock, &respuestaOperacion, sizeof(int), 0); log_error(ptrLog, "Se quiere ejecutar una operacion donde no hay una CPU o un Kernel"); free(respuestaOperacion); return 1; } case 6: log_debug(ptrLog, "En el case (SERVIDOR)"); log_debug(ptrLog, "Destruir segmento"); log_debug(ptrLog, "PID %u", *(*package + sizeof(uint32_t))); if (*tipoProceso == KERNEL) { respuestaINT = destruirSegmento( deserializarDestruirSegmento(package)); memcpy(respuestaOperacion, &respuestaINT, sizeof(int)); enviarDatos(sock, &respuestaOperacion, sizeof(int), 0); free(respuestaOperacion); log_info(ptrLog, "Se realizo la destruccion del segmento"); return 1; } else { respuestaINT = -1; memcpy(respuestaOperacion, &respuestaINT, sizeof(int)); enviarDatos(sock, &respuestaOperacion, sizeof(int), 0); free(respuestaOperacion); log_error(ptrLog, "Se quiere ejecutar una operacion donde no hay una CPU o un Kernel"); return 1; } default: log_debug(ptrLog, "En el case (SERVIDOR)"); log_error(ptrLog, "No llego la opción correcta. OPERACION INCORRECTA."); return -1; } }