int
pedirSegmento(int * error, int tamanio, int pid)
{
int tam = tamanio;
t_datosEnviar * paquete;
void * pedidoSegmentoUMV = malloc(3 * sizeof(int));
memcpy(pedidoSegmentoUMV, &pid, sizeof(int));
memcpy(pedidoSegmentoUMV + sizeof(int), &tam, sizeof(int));
paquete = pedirPaquete(pedidoSegmentoUMV, KERNEL_PEDIR_SEGMENTO_UMV, //Pedir Segmento
2 * sizeof(int));
common_send(socketUMV, paquete, NULL );
free(paquete->data);
paquete = common_receive(socketUMV, NULL );
if (paquete->codigo_Operacion == ERROR_NO_CREO_SEGMENTO)
{
*error = 1;
}
memcpy(&tam, paquete->data, sizeof(int));
destruirPaquete(paquete);
free(pedidoSegmentoUMV);
return tam; //Guardado la base
}
void *
threadPLP(void* vacio)
{
int PIDActual = 0;
setvbuf(stdout, NULL, _IONBF, 0);
log_info(log_kernel,"Se inicio el PLP");
pthread_t hilo_PLP_destruccion;
pthread_create(&hilo_PLP_destruccion, NULL, hiloDestruccion, NULL );
int socketEscucha;
socketEscucha = setup_listen(configuration.ipKernel,configuration.puertoProg);
log_info(log_kernel,"El PLP escucha en el socket %d",socketEscucha);
while (1)
{
t_datosEnviar * paquete;
listen(socketEscucha, 1000);
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
int socketCliente;
socketCliente = accept(socketEscucha, (struct sockaddr *) &addr,
&addrlen);
log_info(log_kernel,"Se recibio una script nueva en el socket %d",socketCliente);
paquete = common_receive(socketCliente, NULL );
atenderProgramaEntrante(paquete, socketCliente, &PIDActual);
}
pthread_join(hilo_PLP_destruccion, NULL );
return NULL ;
}
void doHandshakeUMV() {
t_datosEnviar* paquete = pedirPaquete("a", HANDSHAKE_UMV, 2);
common_send(umvSocket, paquete, destroyOnConnectionFailure);
destruirPaquete(paquete);
paquete = common_receive(umvSocket, NULL );
if (paquete->codigo_Operacion != UMV_CONTESTA_CPU_EXITO) {
log_debug(logger, "Failure handshaking umv");
destruirPaquete(paquete);
destroyOnConnectionFailure();
}
log_debug(logger, "Successful handshake with UMV");
destruirPaquete(paquete);
}
void
startCommunicationWithUMV()
{
t_datosEnviar *mensaje = pedirPaquete("OK", UMV_ACEPTA_KERNEL, 3);
socketUMV = connect_to(configuration.ipUMV, configuration.puertoUMV);
common_send(socketUMV, mensaje, NULL );
mensaje = common_receive(socketUMV, NULL );
if (mensaje->codigo_Operacion != UMV_ACEPTA_KERNEL)
{
shutdownKernel();
log_error(log_kernel,
"No se pudo conectar con la UMV, cerrando el Kernel");
}
log_info(log_kernel, "Se conecto exitosamente con la UMV");
}
t_pcb* onWaitGetProcessFromCPU(int socket)
{
t_datosEnviar* respuesta = common_receive(socket, NULL );
if (respuesta->codigo_Operacion == CPU_PCP_PROCESS_WAITING)
{
debugTrackPCP("Received PCB, proceeding to update...");
t_pcb* nuevo = unserializePCB(respuesta);
debugTrackPCP("DEBUG DEBUG DEBUG PROCESS ID %d",nuevo->pid);
destruirPaquete(respuesta);
return nuevo;
}
debugTrackPCP(
"Received an incorrect Operation Code from PCB at waitRequest");
destruirPaquete(respuesta);
return NULL ;
}
t_datos_kernel doHandshakeKernel() {
int pidCPU = getpid();
t_datosEnviar* paquete = pedirPaquete(&pidCPU, HANDSHAKE, sizeof(int));
common_send(pcpSocket, paquete, destroyOnConnectionFailure);
destruirPaquete(paquete);
paquete = common_receive(pcpSocket, NULL );
if (paquete->codigo_Operacion != PCP_CPU_OK) {
log_debug(logger, "Failure handshaking kernel");
destruirPaquete(paquete);
destroyOnConnectionFailure();
}
log_debug(logger, "Successful handshake with Kernel");
t_datos_kernel kernelData = getKernelData(paquete->data);
destruirPaquete(paquete);
return kernelData;
}
void *
threadPLP(void* vacio)
{
int PIDActual = 0;
setvbuf(stdout, NULL, _IONBF, 0);
puts("[KERNEL] - [PLP] - ESCUCHANDO\n");
pthread_t hilo_PLP_destruccion;
pthread_t hilo_PLP_multiprogramacion;
pthread_create(&hilo_PLP_destruccion, NULL, hiloDestruccion, NULL );
pthread_create(&hilo_PLP_multiprogramacion, NULL, hiloMultiprogramacion,
NULL );
int socketEscucha;
socketEscucha = setup_listen(configuration.puertoProg);
while (1)
{
setvbuf(stdout, NULL, _IONBF, 0);
t_datosEnviar * paquete;
listen(socketEscucha, 1000);
struct sockaddr_in addr;
socklen_t addrlen = sizeof(addr);
int socketCliente;
socketCliente = accept(socketEscucha, (struct sockaddr *) &addr,
&addrlen);
paquete = common_receive(socketCliente, NULL );
atenderProgramaEntrante(paquete, socketCliente, &PIDActual);
}
pthread_join(hilo_PLP_destruccion, NULL );
pthread_join(hilo_PLP_multiprogramacion, NULL );
return NULL ;
}
void
atenderProgramaEntrante(t_datosEnviar* paquete, int socketCliente,
int * PIDActual)
{
if (paquete->codigo_Operacion == HANDSHAKE)
{
destruirPaquete(paquete);
t_datosEnviar *paqueteEscribir;
void *dataGenerica;
paquete = pedirPaquete("K", PLP_PROGRAMA_CONFIRMAR_CONECCION, 2);
common_send(socketCliente, paquete, NULL );
destruirPaquete(paquete);
paquete = common_receive(socketCliente, NULL );
if (paquete->codigo_Operacion == ENVIAR_SCRIPT)
{
debugTrackPLP(
"[Achievement] Programa autenticado, recibiendo script");
char* programa = malloc(paquete->data_size);
memcpy(programa, paquete->data, paquete->data_size);
t_metadata_program * metadataDelPrograma;
metadataDelPrograma = metadata_desde_literal((const char*) programa);
int peso;
peso = metadataDelPrograma->cantidad_de_funciones * 3
+ metadataDelPrograma->cantidad_de_etiquetas * 5
+ metadataDelPrograma->instrucciones_size;
int error = 0;
t_pcb * pcbNuevo = malloc(sizeof(t_pcb));
pcbNuevo->pid = generarPid(PIDActual);
int direccionStack, direccionCodigo, direccionIndiceEtiquetas,
direccionIndiceCodigo;
destruirPaquete(paquete);
error = 0;
debugTrackPLP("[Accion] Pidiendo segmentos en a la UMV");
direccionCodigo = pedirSegmento(&error, strlen(programa) + 1,
pcbNuevo->pid);
direccionStack = pedirSegmento(&error, configuration.tamanio_pila,
pcbNuevo->pid);
direccionIndiceEtiquetas = pedirSegmento(&error,
metadataDelPrograma->etiquetas_size, pcbNuevo->pid);
direccionIndiceCodigo = pedirSegmento(&error,
metadataDelPrograma->instrucciones_size * sizeof(t_intructions),
pcbNuevo->pid);
if (error == 1)
{
debugTrackPLP(
"[Error] No se pudo crear la totalidad de segmentos");
paquete = pedirPaquete("A", PLP_PROGRAMA_NO_SE_PUDO_CREAR, 2);
common_send(socketCliente, paquete, NULL );
destruirPaquete(paquete);
void * pidMomentaneo = malloc(sizeof(int));
memcpy(pidMomentaneo, &(pcbNuevo->pid), sizeof(int));
paquete = pedirPaquete(pidMomentaneo,
KERNEL_DESTRUIR_SEGMENTOS_PROGRAMA, sizeof(int));
common_send(socketUMV, paquete, NULL );
debugTrackPLP(
"[Accion] Eliminando el resto de los segmentos pedidos");
PIDActual--;
destruirPaquete(paquete);
free(pidMomentaneo);
}
else
{
debugTrackPLP(
"[PID:%d]-[Achievement] Se pudo alocar todos los segmentos para el proceso ",
pcbNuevo->pid);
pcbNuevo->codeIndex = direccionIndiceCodigo;
pcbNuevo->codeSegment = direccionCodigo;
pcbNuevo->indiceEtiquetas = direccionIndiceEtiquetas;
pcbNuevo->programCounter =
metadataDelPrograma->instruccion_inicio;
pcbNuevo->tamanioIndiceEtiquetas =
metadataDelPrograma->etiquetas_size;
pcbNuevo->currentStack.base = direccionStack;
pcbNuevo->currentStack.contextSize = 0;
pcbNuevo->currentStack.size = configuration.tamanio_pila;
pcbNuevo->currentStack.stack_pointer = direccionStack;
if (pcbNuevo->codeSegment != -1)
{
debugTrackPLP(
"[PID:%d]-[Achievement] Alocado segmento de codigo en la direccion virtual %d",
pcbNuevo->pid, pcbNuevo->codeSegment);
dataGenerica = malloc(
3 * sizeof(uint32_t) + strlen(programa) + 1);
int tamanioData = strlen(programa) + 1;
memcpy(dataGenerica, &(pcbNuevo->pid), sizeof(uint32_t));
memcpy(dataGenerica + sizeof(uint32_t), &tamanioData,
sizeof(uint32_t));
memcpy(dataGenerica + 2 * sizeof(uint32_t),
&(pcbNuevo->codeSegment), sizeof(uint32_t));
memcpy(dataGenerica + 3 * sizeof(uint32_t), programa,
tamanioData);
paqueteEscribir = pedirPaquete(dataGenerica,
KERNEL_ESCRIBIR_SEGMENTO_UMV,
3 * sizeof(uint32_t) + strlen(programa) + 1);
common_send(socketUMV, paqueteEscribir, NULL );
destruirPaquete(paqueteEscribir);
paqueteEscribir = common_receive(socketUMV, NULL );
free(dataGenerica);
destruirPaquete(paqueteEscribir);
}
if (pcbNuevo->codeIndex != -1)
{
debugTrackPLP(
"[PID:%d]-[Achievement] Alocado segmento de indice de codigo en la direccion virtual %d",
pcbNuevo->pid, pcbNuevo->codeIndex);
int tamanioData = metadataDelPrograma->instrucciones_size
* sizeof(t_intructions);
paqueteEscribir = pedirPaquete(&(pcbNuevo->pid),
KERNEL_ESCRIBIR_SEGMENTO_UMV, sizeof(int));
aniadirAlPaquete(paqueteEscribir, &(tamanioData),
sizeof(int));
aniadirAlPaquete(paqueteEscribir, &(pcbNuevo->codeIndex),
sizeof(int));
aniadirAlPaquete(paqueteEscribir,
metadataDelPrograma->instrucciones_serializado,
tamanioData);
common_send(socketUMV, paqueteEscribir, NULL );
destruirPaquete(paqueteEscribir);
paqueteEscribir = common_receive(socketUMV, NULL );
destruirPaquete(paqueteEscribir);
}
if (pcbNuevo->indiceEtiquetas != -1)
{
debugTrackPLP(
"[PID:%d]-[Achievement] Alocado segmento de indice de etiquetas en la direccion virtual %d",
pcbNuevo->pid, pcbNuevo->indiceEtiquetas);
int tamanioData = metadataDelPrograma->etiquetas_size;
dataGenerica = malloc(
(tamanioData + 1) * sizeof(char) + 3 * sizeof(int));
memcpy(dataGenerica, &(pcbNuevo->pid), sizeof(int));
memcpy(dataGenerica + sizeof(int), &tamanioData, sizeof(int));
memcpy(dataGenerica + 2 * sizeof(int),
&(pcbNuevo->indiceEtiquetas), sizeof(int));
memcpy(dataGenerica + 3 * sizeof(int),
metadataDelPrograma->etiquetas, tamanioData);
paqueteEscribir = pedirPaquete(dataGenerica,
KERNEL_ESCRIBIR_SEGMENTO_UMV, (tamanioData + 1) * sizeof(char) + 3 * sizeof(int));
common_send(socketUMV, paqueteEscribir, NULL );
destruirPaquete(paqueteEscribir);
paqueteEscribir = common_receive(socketUMV, NULL );
destruirPaquete(paqueteEscribir);
free(dataGenerica);
}
debugTrackPLP("[PID:%d]-[Achievement] PCB listo para encolarse",
pcbNuevo->pid);
paquete = pedirPaquete("A", PLP_PROGRAMA_ENCOLADO, 2);
common_send(socketCliente, paquete, NULL );
free(programa);
encolarPCB(pcbNuevo, peso, socketCliente);
}
}
else
{
destruirPaquete(paquete);
pedirPaquete("NK", PROGRAMA_CERRAR, 3);
puts("No Validado");
common_send(socketCliente, paquete, NULL );
destruirPaquete(paquete);
}
}
}
pcpSocket = connect_to(IPKernel, puertoKernel);
if (pcpSocket == -1) {
log_debug(logger, "Failure connecting to Kernel");
destroyOnConnectionFailure();
}
return doHandshakeKernel();
}
t_datos_kernel setupConnections() {
connectToUMV();
return connectToKernel();
}
t_pcb* getNewPCB() {
t_pcb* new = conitos_malloc(sizeof(t_pcb));
t_datosEnviar* recepcion_PCB = common_receive(pcpSocket, NULL );
if (recepcion_PCB->codigo_Operacion != PCP_CPU_PROGRAM_TO_EXECUTE) {
log_debug(logger, "Failure delivering PCB...");
estado = END_PROCESS;
return NULL ;
}
*new = *(t_pcb*) recepcion_PCB->data;
destruirPaquete(recepcion_PCB);
log_debug(logger, "PCB Received correctly. Starting to execute process %d",
new->pid);
return new;
}
void resetContextFrom0() {
recreate_variable_dictionary();
traer_segmento_etiquetas();
