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;
}
}
