void inicializar_memoria() {
memoria_size = umc_config->frames_size * umc_config->cant_frames;
// memoria_principal = malloc(memoria_size);
// memset(memoria_principal, 0, memoria_size);
memoria_principal = (void *) calloc(umc_config->cant_frames,
umc_config->frames_size);
// log_trace(logger, "Se ha creado el espacio de memoria de %d bytes",
// memoria_size);
frames_memoria = list_create();
int indice_frame = 0;
for (indice_frame = 0; indice_frame < umc_config->cant_frames;
indice_frame++) {
t_mem_frame * frame = malloc(sizeof(t_mem_frame));
frame->pagina = -1;
frame->pid = -1;
frame->libre = 1;
list_add_in_index(frames_memoria, indice_frame, frame);
}
}
void iniciar(uint8_t idProc, uint8_t cantPag, int socketCPU) {
uint8_t contador;
t_TablaDePaginas* tablaDePag;
t_PID * estructuraEnvio;
estructuraEnvio = crearPID();
for (contador = 0; contador < cantPag; contador++) {
tablaDePag = iniciarTablaDePaginas();
tablaDePag->idProc = idProc;
tablaDePag->paginaDelProceso = contador;
tablaDePag->idMarco = variableIdMarco;
tablaDePag->bitPagModificada = 0;
tablaDePag->bitPresencia = 0;
pthread_mutex_lock(&mutexTablaPags);
list_add(listaTablaDePag, tablaDePag);
pthread_mutex_unlock(&mutexTablaPags);
variableIdMarco++;
}
estructuraEnvio->PID = idProc;
uint8_t* cero = malloc(sizeof(uint8_t));
*cero = 0;
list_add_in_index(listaIndices, idProc, cero);
enviarRtaIniciarOkCPU(estructuraEnvio, socketCPU);
}
void list_add_order_by(t_list* list, void* data, int(*isBigger)(void*,void*)){
int index=0;
if(list_is_empty(list)){
list_add_in_index(list,0,data);
return;
}
while((index<list_size(list)))
if ((*isBigger)((void*)list_get(list,index), data))
index++;
else
break;
list_add_in_index(list,index,data);
return;
}
void leerRegistroDeUltimoArchivoQueEntregoRegistro(ArchivoApareado *archivo)
{
list_remove(archivo->listaRegistrosLeidos, archivo->indiceArchivoQueEntregaRegistro);
Archivo *ultimoArchivoQueEntregoRegistro = list_get(archivo->listaArchivos,
archivo->indiceArchivoQueEntregaRegistro);
list_add_in_index(archivo->listaRegistrosLeidos,
archivo->indiceArchivoQueEntregaRegistro,
obtenerRegistro(ultimoArchivoQueEntregoRegistro));
}
void ubico_al_principio(pagina_t* pag){
//lock_lista_indice_paginas();
uint64_t id_inicial = pag->id_en_indice;
list_remove(get_indice_paginas(), id_inicial);
list_add_in_index(get_indice_paginas(), 0, pag);
//unlock_lista_indice_paginas();
// reasigno id en indice de los demas
_reasigno_indices(id_inicial);
pag->id_en_indice = 0;
}
infoNodo* avanzarClock(infoNodo* worker, t_list* listaNodos){
bool nodoConNumero(infoNodo* nodo){
return nodo->numero == worker->numero;
}
infoNodo* siguienteWorker = malloc(sizeof(infoNodo));
list_remove_by_condition(listaNodos, (void*)nodoConNumero);
list_add_in_index(listaNodos, list_size(listaNodos), worker);
siguienteWorker = list_get(listaNodos, 0);
return siguienteWorker;
}
//nodo ordenado por PID
void insertarNodoOrdenadoEnTLB(t_tlb*unNodo) {
int contador = 0;
if (list_size(TLB) == 0)
list_add(TLB, unNodo);
else {
t_tlb*nodoActual = list_get(TLB, contador);
while (!(nodoActual->pid < unNodo->pid || contador < list_size(TLB))) {
contador++;
if (contador == list_size(TLB)) {
list_add(TLB, unNodo);
break;
}
nodoActual = list_get(TLB, contador);
}
if (contador != list_size(TLB))
list_add_in_index(TLB, contador, unNodo);
}
}
int almacenar_particion(t_memoria segmento, char id, int tamanio, t_memoria contenido) {
// TODO: ver si no hay otro posible error.
if(obtenerPorId(listaParticiones, id) != NULL || tamanio > tamanioTotal) {
return ASIGNAR_MEMORIA_ERROR;
}
int inicio = buscarEspacio(listaParticiones, tamanio);
if(NO_HAY_PARTICION_LIBRE == inicio) {
return ASIGNAR_MEMORIA_SIN_LUGAR;
}
int index = buscarIndiceEnBaseAlInicio(listaParticiones, inicio);
t_particion* nuevaParticion = (t_particion*) malloc(sizeof(t_particion));
(*nuevaParticion).id = id;
(*nuevaParticion).inicio = inicio;
(*nuevaParticion).tamanio = tamanio;
(*nuevaParticion).dato = (char*) (segmento + inicio);
(*nuevaParticion).libre = OCUPADO;
// Copiamos el contenido:
int pos;
for(pos = 0; pos < tamanio; pos++) {
*((*nuevaParticion).dato + pos) = *(contenido + pos);
}
t_particion* hueco = (t_particion*) list_replace(listaParticiones, index, (void*) nuevaParticion);
// Si queda lugar libre, se genera un nuevo hueco:
if((*hueco).tamanio > tamanio) {
t_particion* nuevoHueco = (t_particion*) malloc(sizeof(t_particion));
(*nuevoHueco).id = ID_UNDEFINED;
(*nuevoHueco).inicio = inicio + tamanio;
(*nuevoHueco).tamanio = (*hueco).tamanio - tamanio;
(*nuevoHueco).dato = (char*) (segmento + tamanio + inicio);
(*nuevoHueco).libre = LIBRE;
list_add_in_index(listaParticiones, index + 1, (void*) nuevoHueco);
}
free(hueco);
return ASIGNAR_MEMORIA_SUCCESS;
}
void terminaDeFormaAbortiva(int pid_local) {
//Ak aviso a consola
int esEl_Pid(pcb_t* pcb_compara) {
return (*pcb_compara->PID == pid_local);
}
printf("Se termino un CPU de forma abortiva\n");
if (pid_local == -1) {
} else {
t_sock_mje* socketConsola;
pthread_mutex_lock(&sem_l_Exec);
pcb_t* pcb_elegido = list_remove_by_condition(proc_Exec,
(void*) esEl_Pid);
pthread_mutex_unlock(&sem_l_Exec);
if(pcb_elegido == NULL){
pthread_mutex_lock(&sem_temp);
pcb_elegido = list_remove_by_condition(temp,
(void*) esEl_Pid);
pthread_mutex_unlock(&sem_temp);
pthread_mutex_lock(&sem_l_Ready);
list_add_in_index(proc_Ready, 0, pcb_elegido);
log_debug(logger,"PCB con PID %d pasado al principio de READY xfin CPU",pid_local);
pthread_mutex_unlock(&sem_l_Ready);
}else{
log_debug(logger, "PCB con PID %d sacado de EXEC xfin Proceso",
pid_local);
pthread_mutex_unlock(&sem_l_Exec);
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXIT xfin Proceso",
pid_local);
pthread_mutex_unlock(&sem_l_Reject);
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola, &pid_local);
pthread_mutex_unlock(&sem_pid_consola);
free(socketConsola->mensaje);
socketConsola->mensaje = strdup("123456");
sem_post(&sem_REJECT_dispo);}
}
int a = 100;
pthread_exit(&a);
}
int almacenar_particion(t_memoria segmento, char id, int tamanio, char* contenido) {
/* Crea una particion dentro del segmento de memoria de tamaño,
identificador y contenido especificado. Devuelve el valor numerico -1
en caso de error (ej: tamaño de la particion mayor que el tamaño total
del segmento, id duplicado, etc.), 1 en caso de exito y 0 en caso de
no encontrar una particion libre lo suficientemente grande para
almacenar la solicitud. */
int i, indexParticionMayor, total;
t_particion* particionAux;
t_particion particionMayor;
t_particion* particion;
t_particion* particionRestante;
t_particion* ptrAEliminar;
//particionAux = malloc(sizeof(t_particion)); //no hace falta recive un valor ya allocado en la lista
particion = malloc(sizeof(t_particion));
particionRestante = malloc(sizeof(t_particion));
//Inicializo particionMayor con un tamaño de 0 para después saber si encontré otra mayor, o ninguna disponible
particionMayor.tamanio = 0;
if (tamanio > tamanioTotal) {
//printf("El tamaño de la partición supera el tamaño del segmento. Abortando...\n");
return 0;
}
total = list_size(list_particiones);
for (i = 0; i < total; i++) {
particionAux = list_get(list_particiones, i);
if (particionAux->id == id) {
//printf("Ya existe una partición con ID = %c. Abortando...\n", id);
return -1;
}
}
for (i = 0; i < total; i++) {
particionAux = list_get(list_particiones, i);
if (particionAux->libre == false) {
//printf("La partición %c está ocupada\n", particionAux->id);
} else {
if (tamanio > particionAux->tamanio) {
//printf("La partición %c no es lo suficientemente grande (%d a almacenar vs. %d disponible)\n", particionAux->id, tamanio, particionAux->tamanio);
} else {
//printf("El tamaño de la partición actual es %d\n", particionAux->tamanio);
//printf("El tamaño de la mayor partición guardada es %d\n", particionMayor.tamanio);
if (particionAux->tamanio > particionMayor.tamanio) {
particionMayor = *particionAux;
indexParticionMayor = i;
}
}
}
}
if (particionMayor.tamanio == 0) {
//printf("O no había ninguna partición libre, o niguna tenía suficiente espacio para almacenar la nueva partición. Abortando...\n");
return 0;
}
//Saco la partición anterior
ptrAEliminar = list_remove(list_particiones, indexParticionMayor);
free(ptrAEliminar);
//Inicializo la particion
particion->id = id;
particion->inicio = particionMayor.inicio;
particion->tamanio = tamanio;
particion->dato = &segmento[particion->inicio];
particion->libre = false;
//Agrego la partición a la lista
list_add_in_index(list_particiones, indexParticionMayor, particion);
//Grabo el dato en memoria la particion
memcpy(particion->dato, contenido, particion->tamanio);
//Inicializo la particion restante
particionRestante->id = '\0';
particionRestante->inicio = particion->inicio + particion->tamanio;
particionRestante->tamanio = particionMayor.tamanio - particion->tamanio;
particionRestante->dato = &segmento[particion->inicio + particion->tamanio];
particionRestante->libre = true;
//Agrego la partición restante a la lista si tengo lugar
if(particionRestante->inicio == tamanioTotal){
//printf("No tengo más lugar en mi segmento, así que no agregué partición restante a la lista\n");
} else {
list_add_in_index(list_particiones, indexParticionMayor, particionRestante);
}
//Grabo el dato en memoria la particion restante
//printf("Grabo el dato en memoria la particion restante\n");
//memcpy(particionRestante->dato, contenido, particionRestante->tamanio);
return 1;
}
int leerPersistencia()
{
pthread_mutex_init(&mPersistFile, NULL);
sem_init(&sPersistencia, 0, 0);
persistFile = fopen("./FileSystem.persist", "r");
if (persistFile == NULL) return EXIT_SUCCESS;
char* linea = malloc(MAX_BUFF_SIZE);
int ret = 0;
int index = 1; //El 0 es el directorio raiz que esta por default
if (buscarSeccion(SECCION_LISTA_DIRS) == EXIT_SUCCESS)
{
ret = fgets(linea,MAX_BUFF_SIZE,persistFile);
while((ret != NULL) && (strstr(linea,"#") == NULL))
{
char** lDir = string_split(linea,";");
t_reg_directorio* dir = malloc(sizeof(t_reg_directorio));
strcpy(dir->directorio,lDir[0]);
dir->padre = atoi(lDir[1]);
list_add_in_index(listaDirs,index,dir);
ret = fgets(linea,MAX_BUFF_SIZE,persistFile);
index++;
}
}
if (buscarSeccion(SECCION_LISTA_CONEXIONES) == EXIT_SUCCESS)
{
ret = fgets(linea,MAX_BUFF_SIZE,persistFile);
while((ret != NULL) && (strstr(linea,"#") == NULL))
{
char** lConexion = string_n_split(linea, 4, ";");
Conexion_t* conexion = malloc(sizeof(Conexion_t));
strcpy(conexion->nombre, lConexion[0]);
conexion->estado = NO_DISPONIBLE;
conexion->sockfd = -1;
conexion->totalBloques = atoi(lConexion[2]);
conexion->estadoBloques = calloc(conexion->totalBloques,sizeof(bool));
sem_init(&(conexion->respuestasR),0,1);
sem_init(&(conexion->respuestasP),0,0);
pthread_mutex_init(&(conexion->mSocket), NULL);
pthread_mutex_init(&(conexion->mEstadoBloques), NULL);
for (int i=0;i<conexion->totalBloques;i++)
{
if (lConexion[3][i] == '1')
{
conexion->estadoBloques[i] = true;
}else
{
conexion->estadoBloques[i] = false;
}
}
list_add(conexiones,conexion);
ret = fgets(linea,MAX_BUFF_SIZE,persistFile);
}
}
if (buscarSeccion(SECCION_LISTA_ARCHIVOS) == EXIT_SUCCESS)
{
ret = fgets(linea,MAX_BUFF_SIZE,persistFile);
while((ret != NULL) && (strstr(linea,"#") == NULL))
{
char** lArchivo = string_n_split(linea,5,";");
char** lBloques = string_split(lArchivo[4],"//");
t_reg_archivo* archivo = malloc(sizeof(t_reg_archivo));
list_add(listaArchivos,archivo);
strcpy(archivo->nombre,lArchivo[0]);
archivo->dirPadre = atoi(lArchivo[1]);
archivo->estado = NO_DISPONIBLE;
archivo->tamanio = atoll(lArchivo[3]);
pthread_mutex_init(&(archivo->mBloques),NULL);
archivo->bloques = list_create();
int i = 0;
char** lUbicaciones;
while(lBloques[i] != NULL)
{
t_list* ubicaciones = list_create();
list_add_in_index(archivo->bloques, i, ubicaciones);
lUbicaciones = string_n_split(lBloques[i],3,";");
while (lUbicaciones[0] != NULL)
{
t_ubicacion_bloque* ubicacion = malloc(sizeof(t_ubicacion_bloque));
ubicacion->nodo = getConexionByNombre(lUbicaciones[0]);
ubicacion->bloque = atoi(lUbicaciones[1]);
list_add(ubicaciones,ubicacion);
if ((lUbicaciones[2] != NULL) && (strcmp(lUbicaciones[2],"\n") != 0))
{
lUbicaciones = string_n_split(lUbicaciones[2],3,";");
}else
{
lUbicaciones[0] = NULL;
}
}
i++;
}
ret = fgets(linea,MAX_BUFF_SIZE,persistFile);
}
}
return EXIT_SUCCESS;
}
pcb_t* recibirPCBdeCPU(int socket,int pidLocal){
pcb_t* pcb_Recibido = malloc(sizeof(pcb_t));
pcb_Recibido->PID = recibirCpu(socket,sizeof(int),pidLocal);
pidLocal = *(pcb_Recibido->PID);
pcb_Recibido->PC = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->PCI = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->SP = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->paginasDisponible = recibirCpu(socket,sizeof(int),pidLocal);
pcb_Recibido->indice_codigo = dictionary_create();
pcb_Recibido->indice_funciones = list_create();
pcb_Recibido->indice_stack = dictionary_create();
int* tamanioIC = recibirCpu(socket, sizeof(int),pidLocal);
int* tamanioStack = recibirCpu(socket, sizeof(int),pidLocal);
int* tamanioIF = recibirCpu(socket, sizeof(int),pidLocal);
int i;
//RECIBO INDICE DE CODIGO
for(i=0;i<*tamanioIC && *tamanioIC != 0;i++){
int* nuevaPagina = malloc(sizeof(int));
*nuevaPagina = i;
direccionMemoria* nuevaDireccionMemoria = recibirCpu(socket,sizeof(direccionMemoria),pidLocal);
dictionary_put(pcb_Recibido->indice_codigo,nuevaPagina,nuevaDireccionMemoria);
}
free(tamanioIC);
//RECIBO INDICE FUNCIONES
for(i=0;i<*tamanioIF && *tamanioIF!=0;i++){
funcionTemp* funcion = recibirCpu(socket,sizeof(funcionTemp),pidLocal);
char* funcionNombre = recibirCpu(socket,funcion->tamanioNombreFuncion,pidLocal);
funcion_sisop* new_funcion = malloc(sizeof(new_funcion));
new_funcion->funcion = funcionNombre;
new_funcion->posicion_codigo = malloc(sizeof(int));
*(new_funcion->posicion_codigo) = funcion->posicionPID;
list_add_in_index(pcb_Recibido->indice_funciones,i,new_funcion);
}
free(tamanioIF);
//RECIBO STACK
for(i=0;i<*tamanioStack && *tamanioStack!=0;i++){
stack* stackNuevo = malloc(sizeof(stack));
//Argumentos
int* tamArgs = recibirCpu(socket, sizeof(int),pidLocal);
if(*tamArgs==-1)
stackNuevo->args = NULL;
else
stackNuevo->args = list_create();
//Variables
int* tamVars = recibirCpu(socket, sizeof(int),pidLocal);
if(*tamVars==-1)
stackNuevo->vars = NULL;
else
stackNuevo->vars = list_create();
//Retorno PID del renglon stack
int* RetornoPID = recibirCpu(socket, sizeof(int),pidLocal);
if(*RetornoPID == -1)
stackNuevo->pos_ret = NULL;
else
stackNuevo->pos_ret = RetornoPID;
//Retorno
direccionMemoria* memoriaRetorno = recibirCpu(socket, sizeof(direccionMemoria),pidLocal);
if(memoriaRetorno->offset == -1)
memoriaRetorno = NULL;
stackNuevo->memoriaRetorno = memoriaRetorno;
int j;
for(j=0;j<*tamArgs;j++){
direccionMemoria* new_direc = recibirCpu(socket, sizeof(direccionMemoria),pidLocal);
list_add_in_index(stackNuevo->args,j,new_direc);
}
free(tamArgs);
for(j=0;j<*tamVars;j++){
direccionStack* new_direc = recibirCpu(socket, sizeof(direccionStack),pidLocal);
list_add_in_index(stackNuevo->vars,j,new_direc);
}
free(tamVars);
int* key = malloc(sizeof(int));
*key = i;
dictionary_put(pcb_Recibido->indice_stack,key,stackNuevo);
}
//recibo quantum y quantumSleep
return pcb_Recibido;
}
//------------------------------------------------------------------------------------------
// ---------------------------------- atender_CPU -----------------------------------------
//Esta funcion representa un thread que trabaja con un CPU conectado por socket
//------------------------------------------------------------------------------------------
void *atender_CPU(int* socket_desc) {
//void perdioLaConexion();
//signal(SIGPIPE,perdioLaConexion);
int socket_local = *socket_desc;
//Empieza handshake
int* recibido = recibirCpu(socket_local, sizeof(int),-1);
if (*recibido == CPU) {
log_debug(logger, "Se ha conectado correctamente CPU: %d",socket_local);
}
//Confirmo conexio a cpu
int ok = OK;
enviarCPU(socket_local,sizeof(int),&ok,-1);
//Lo libero ya q era un malloc de atender_conexion_CPU
free(socket_desc);
int CpuActivo = 1; // 0 desactivado - 1 activado
int cambioPcb = 0; // 0 desactivado - 1 activado
pcb_t* pcb_elegido;
int pid_local = 0;
int* estado_proceso;
t_sock_mje* socketConsola;
int esEl_Pid(pcb_t* pcb_compara) {
return (*pcb_compara->PID==pid_local);
}
while (CpuActivo) {
//////////////////////////////////////////////
//Le otorgo un pcb para tarabajar/////////////
//////////////////////////////////////////////
pid_local = -1;
sem_wait(&sem_READY_dispo); // espero que haya un proceso en READY disponible
pthread_mutex_lock(&sem_l_Ready);
pcb_elegido = list_remove(proc_Ready, 0); //Agarro el pcb
pid_local = *(pcb_elegido->PID);
log_debug(logger, "PCB con PID %d sacado de READY", pid_local);
pthread_mutex_unlock(&sem_l_Ready);
pthread_mutex_lock(&sem_temp);
list_add(temp,pcb_elegido); //Agarro el pcb
pthread_mutex_unlock(&sem_temp);
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
cambioPcb = 0;
if (socketConsola->proc_status!=0){ //verifico si se cerro la consola del proceso
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a REJECT xfin de consola",pid_local);
pthread_mutex_unlock(&sem_l_Reject);
sem_post(&sem_REJECT_dispo);
cambioPcb = 1;
}
if(!cambioPcb){
enviarPCB(pcb_elegido, socket_local, reg_config.quantum, reg_config.quantum_sleep);
//Guardo pcb en la lista de ejecutandose
pthread_mutex_lock(&sem_temp);
list_remove_by_condition(temp, (void*) esEl_Pid);
pthread_mutex_unlock(&sem_temp);
pthread_mutex_lock(&sem_l_Exec);
list_add(proc_Exec, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXEC", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
}
while (!cambioPcb && CpuActivo){
estado_proceso = recibirCpu(socket_local,sizeof(int),pid_local);
switch (*estado_proceso) {
case FIN_QUANTUM:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC x fin Quantum",pid_local);
pthread_mutex_unlock(&sem_l_Exec);
//
pthread_mutex_lock(&sem_l_Ready);
list_add(proc_Ready, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a READY x fin Quantum",pid_local);
pthread_mutex_unlock(&sem_l_Ready);
sem_post(&sem_READY_dispo);
cambioPcb = 1;//activo el cambio del pcb ya q termino el quantum
}
break;
case FIN_PROC:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC xfin Proceso", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
//
pthread_mutex_lock(&sem_l_Exit);
list_add(proc_Exit, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXIT xfin Proceso",pid_local);
pthread_mutex_unlock(&sem_l_Exit);
cambioPcb = 1;//activo el cambio del pcb ya q termino el proceso
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
free(socketConsola->mensaje);
socketConsola->mensaje = strdup("Proceso_Finalizado_Correctamente");
sem_post(&sem_EXIT_dispo);
}
break;
case FIN_CPU:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC xfin CPU", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
//
pthread_mutex_lock(&sem_l_Ready);
list_add_in_index(proc_Ready, 0, pcb_elegido);
log_debug(logger,"PCB con PID %d pasado al principio de READY xfin CPU",pid_local);
pthread_mutex_unlock(&sem_l_Ready);
sem_post(&sem_READY_dispo);
CpuActivo = 0;
}
//LIBERAR PCB
//BORAR CONSOLA DEL DICCIONARIO
break;
case SOLIC_IO: //es la primitiva entradaSalida
{
ansisop_entradaSalida(socket_local, pid_local);
cambioPcb = 1;//activo el cambio del pcb ya q se bloqueo el proceso
}
break;
case OBT_VALOR: //es la primitiva obtenerValorCompartida
ansisop_obtenerValorCompartida (socket_local,pid_local);
break;
case GRABA_VALOR: //es la primitiva asignarValorCompartida
ansisop_asignarValorCompartida (socket_local,pid_local);
break;
case WAIT_SEM: // es la primitiva wait
{
cambioPcb = ansisop_wait (socket_local, pid_local);
enviarCPU(socket_local,sizeof(int),&cambioPcb,pid_local);
// si cambioPcb es 0 significa que el wait no bloqueo y el cpu puede seguir procesando,
// si es 1 entonces el proceso se bloqueo y el CPU debe tomar otro PCB
break;
}
case SIGNAL_SEM: // es la primitiva signal
ansisop_signal(socket_local,pid_local);
break;
case IMPRIMIR: // es la primitiva imprimir
{
int* valoraImprimir = recibirCpu(socket_local,sizeof(int),pid_local);
/* t_sock_mje* */ socketConsola = dictionary_get(dict_pid_consola,&pid_local);
int envVar = 100;
if(socketConsola->proc_status == 0){
enviarCPUConHeader(socketConsola->socket_dest,envVar,sizeof(int),valoraImprimir,pid_local);
}
free(valoraImprimir);
break;
}
case IMPRIMIR_TXT: // es la primitiva imprimirTexto
{
/* t_sock_mje* */ socketConsola = dictionary_get(dict_pid_consola,&pid_local);
int* tamanioAImprimir = recibirCpu(socket_local,sizeof(int),pid_local);
void* mensaje = recibirCpu(socket_local,*tamanioAImprimir,pid_local);
int envTexto = 101;
if(socketConsola->proc_status == 0){
enviarCPUConHeader(socketConsola->socket_dest,envTexto,sizeof(int),tamanioAImprimir,pid_local);
enviarCPU(socketConsola->socket_dest,*tamanioAImprimir,mensaje,pid_local);
}
free(tamanioAImprimir);
free(mensaje);
break;
}
case SEG_FAULT:
{
pcb_elegido = recibirPCBdeCPU(socket_local,pid_local);
pthread_mutex_lock(&sem_l_Exec);
list_remove_by_condition(proc_Exec, (void*) esEl_Pid);
log_debug(logger, "PCB con PID %d sacado de EXEC xfin Proceso", pid_local);
pthread_mutex_unlock(&sem_l_Exec);
pthread_mutex_lock(&sem_l_Reject);
list_add(proc_Reject, pcb_elegido);
log_debug(logger, "PCB con PID %d pasado a EXIT xfin Proceso",pid_local);
pthread_mutex_unlock(&sem_l_Reject);
cambioPcb = 1;//activo el cambio del pcb ya q termino el proceso
pthread_mutex_lock(&sem_pid_consola);
socketConsola = dictionary_get(dict_pid_consola,&pid_local);
pthread_mutex_unlock(&sem_pid_consola);
free(socketConsola->mensaje);
socketConsola->mensaje = strdup("Proceso_Produjo_SEG_FAULT");
sem_post(&sem_REJECT_dispo);
break;
}
default:
break;
}
free(estado_proceso);
}
}
}
