void dibujarPantalla(t_list* personajes, t_list* recursos) {
borrarTodo();
list_iterate(personajes, crearGuiPersonajes);
list_iterate(recursos, crearGuiRecursos);
nivel_gui_dibujar(listaItems);
}
void estadoDeProceso(imagen_proceso_t proceso)
{
puts("---------------------------------------------------");
printf("ID = %d\n",proceso.PCB_proceso.PID);
printf("PC = %d\n",proceso.PCB_proceso.ProgramCounter);
puts("---------------Estructura de código----------------");
estadoVar = &estadoVariable;
list_iterate(proceso.segmentoDeDatos,estadoVar);
puts("---------------Estructura del stack----------------");
estadoCall = &estadoLlamada;
list_iterate(proceso.segmentoDeStack->elements,estadoCall);
puts("---------------------------------------------------");
}
void mostrarEstadoNodos (t_list* listaNodos)
{
printf(" Informacion nodos \n");
printf("\n");
list_iterate(listaNodos,(void*)&imprimirIpYEstado);
printf("\n");
};
void mostrarArchivo(t_archivo *unArchivo) {
printf("Estado: %d\n", unArchivo->estado);
printf("Nombre: %s\n", unArchivo->nombre);
printf("Padre: %d\n", unArchivo->padre);
printf("Tamanio: %f\n", unArchivo->tamanio);
list_iterate((unArchivo->bloquesDeArch), (void*) mostrarBloqueArch);
}
bool contiguos_necesarios(int posicion_actual, int cantidad_necesaria) {
bool hay_contiguos = false;
if ((posicion_actual + cantidad_necesaria) >= swap_config->cant_paginas)
return hay_contiguos;
t_list * siguientes = NULL;
siguientes = list_create();
int i;
for (i = 0; i < cantidad_necesaria; i++) {
list_add(siguientes, list_get(bitmap, posicion_actual));
posicion_actual++;
}
int n = 0;
void contar_libres(void * bloque) {
if (((int) bloque) == 0)
n++;
}
list_iterate(siguientes, (void *) contar_libres);
if (n == cantidad_necesaria)
hay_contiguos = true;
free(siguientes);
return hay_contiguos;
}
/*
* ns_set_value_from_string() sets the passed in kvp in the passed in printer
* structure.
*/
int
ns_set_value_from_string(const char *key, const char *string,
ns_printer_t *printer)
{
if (printer == NULL)
return (-1);
if (key == NULL)
list_iterate((void **)printer->attributes,
(VFUNC_T)ns_kvp_destroy);
else {
ns_kvp_t *kvp;
if (((kvp = list_locate((void **)printer->attributes,
(COMP_T)ns_kvp_match_key,
(void *)key)) == NULL) &&
((kvp = calloc(1, sizeof (*kvp))) != NULL)) {
kvp->key = strdup(key);
printer->attributes = (ns_kvp_t **)
list_append((void **)printer->attributes, kvp);
}
if (string != NULL)
kvp->value = strdup(string);
else
kvp->value = NULL;
}
return (0);
}
void socket_multiplex(t_list* sockets) {
struct epoll_event events[list_size(sockets)];
int epollfd = epoll_create(list_size(sockets));
void _add_elements(t_socket* socket) {
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLRDHUP;
ev.data.fd = socket->socket;
epoll_ctl(epollfd, EPOLL_CTL_ADD, socket->socket, &ev);
}
list_iterate(sockets, (void*) _add_elements);
int nfds = epoll_wait(epollfd, events, list_size(sockets), -1);
for (int i = 0; i < nfds; ++i) {
int sock_epoll = events[i].data.fd;
uint32_t event = events[i].events;
bool _search_by_socket(t_socket* socket) {
return sock_epoll == socket->socket;
}
if (event & EPOLLRDHUP) {
t_socket* sock_found = list_remove_by_condition(sockets, (void*) _search_by_socket);
if (sock_found->handler_closed != NULL) {
sock_found->handler_closed(sock_found);
}
free(sock_found);
} else if (event & EPOLLIN) {
t_socket* sock_found = list_find(sockets, (void*) _search_by_socket);
sock_found->handler(sock_found);
}
}
close(epollfd);
}
/*
* job_free() frees up memory mmapped for malloced
* being used by the structure.
*/
void
job_free(job_t *job)
{
if (job == NULL)
return;
syslog(LOG_DEBUG, "job_free(%d, %s, %s)", job->job_id,
(job->job_printer ? job->job_printer : "NULL"),
(job->job_server ? job->job_server : "NULL"));
if (job->job_printer) free(job->job_printer);
if (job->job_server) free(job->job_server);
if (job->job_user) free(job->job_user);
if (job->job_host) free(job->job_host);
if (job->job_cf)
_job_file_free(job->job_cf);
(void) list_iterate((void *)job->job_df_list, (VFUNC_T)_vjob_file_free);
if (job->job_df_list)
free(job->job_df_list);
if (job->job_spool_dir)
free(job->job_spool_dir);
free(job);
}
/*
* start_daemon() - check for jobs queued, check if the lock is free. If
* so, start a daemon either by forking and execing or just execing
* depending on the flag passed in.
*/
void
start_daemon(int do_fork)
{
int lock;
job_t **jobs = NULL;
if ((jobs = job_list_append(NULL, NULL, NULL, SPOOL_DIR)) == NULL)
return;
list_iterate((void **)jobs, (VFUNC_T)job_free);
free(jobs);
close(lock = get_lock(MASTER_LOCK, 0));
if (lock < 0)
return;
if (do_fork == 0) {
(void) execle("/usr/bin/lp", MASTER_NAME, NULL, NULL);
syslog(LOG_ERR, "start_daemon() - execl: %m");
exit(-1);
} else
switch (fork()) {
case -1:
syslog(LOG_ERR, "start_daemon() - fork: %m");
exit(-1);
/* NOTREACHED */
case 0:
break;
default:
(void) execl("/usr/bin/lp", MASTER_NAME, NULL);
syslog(LOG_ERR, "start_daemon() - execl: %m");
exit(-1);
/* NOTREACHED */
}
}
void mostrarTareasPendientesJob (t_list* listaJobs)
{
printf(" Informacion jobs \n");
printf("\n");
if(list_size(listaJobs) > 0)
list_iterate(listaJobs,(void*)&imprimirIpPendientesDeMappingYPendientesDeReduce);
printf("\n");
};
value_t *evaluate_program_fos(env_t *env, program_t *program)
{
global_env = env;
list_iterate(program->bindings, add_binding_i, NULL);
// Evaluate the 'main' expression in the global environment.
return e_expr(global_env, program->main);
}
// This is where most of the strict/lazy distinction is.
static value_t *e_fncall(env_t *env, expr_t *expr)
{
eli_closure_t c;
binding_t *fn;
// Call-by-value (strict function calls): evaluate each argument to
// a value in the given environment.
c.env = env;
c.list = list_empty();
list_iterate(fncall_args(expr), e_expr_list_i, &c);
list_reverse(c.list);
switch (fncall_fn(expr)->type) {
case p_var:
// The function is literally the name of a function, and is
// defined in the global environment.
fn = (binding_t *)env_lookup(global_env, var_name(fncall_fn(expr)));
assert(fn != NULL);
// We must have exactly as many arguments as parameters.
assert(list_length(c.list) == list_length(fn->params));
// Bind the function's parameters to the given arguments in a new
// scope derived from the global scope.
env = global_env;
env_new_scope(&env);
list_zip_with(fn->params,
c.list,
e_bind_params_i, env);
// Evaluate the function's body in the new environment.
return e_expr(env, fn->body);
case p_datacons:
{
value_t *result;
result = alloc_value(v_datacons);
datacons_tag(result) = datacons_tag(fncall_fn(expr));
datacons_params(result) = c.list;
// FIXME we'd like to assert that we got the right number of
// arguments, but we don't know how many the data constructor
// wanted.
return result;
}
default:
fprintf(stdout, "e_fncall: expression:\n");
pp_expr(stdout, fncall_fn(expr), 2);
fprintf(stdout, "\non line %d is not a function-variable or a data constructor.\n", fn->line_num);
error("");
return NULL;
}
}
int cantidadDePaginasDisponibles(t_list* listaDeHuecosLibres){
int paginasLibres = 0;
if (list_size(listaDeHuecosLibres) != 0) {
void contarPaginasLibres(tipoHuecoLibre* huecoLibre){
paginasLibres += huecoLibre->cantidadDePaginasQueOcupa;
}
list_iterate(listaDeHuecosLibres,(void*)contarPaginasLibres);
}
void freeJob(t_job *job) {
list_iterate(job->maps, (void *) removeMapNode);
list_destroy_and_destroy_elements(job->files, (void *) freeFile);
list_destroy_and_destroy_elements(job->maps, (void *) freeMap);
list_destroy_and_destroy_elements(job->partialReduces, (void *) freeReduce);
freeReduce(job->finalReduce);
free(job->resultFile);
free(job);
}
void
job_destroy(job_t *job)
{
char *name = NULL;
jobfile_t *cf;
if (job == NULL)
return;
syslog(LOG_DEBUG, "job_destroy(%d, %s, %s)", job->job_id,
job->job_printer, job->job_server);
if (chdir(job->job_spool_dir) < 0)
return;
(void) list_iterate((void *)job->job_df_list,
(VFUNC_T)_job_unlink_data_file);
/* lose privilege temporarily */
(void) seteuid(get_user_id(job->job_user));
if ((cf = job->job_cf) != NULL) {
for (name = cf->jf_data; name != NULL;
name = strchr(name, '\n')) {
if (name[0] == '\n')
name++;
if (name[0] == CF_UNLINK) {
struct stat st;
char *path = strcdup(&name[1], '\n'),
*p;
if (stat(path, &st) < 0) {
free(path);
continue;
}
if (st.st_uid == getuid()) {
(void) unlink(path);
free(path);
continue;
}
p = strdup(path);
if ((p = strrchr(p, '/')) != NULL)
*++p = NULL;
if (access(p, W_OK) == 0)
(void) unlink(path);
free(path);
}
}
}
(void) seteuid(0); /* get back privilege */
(void) unlink(cf->jf_src_path);
(void) _job_unlink_data_file(cf);
job_free(job);
}
void incrementar_bit_tlb() { //TODO ver que onda esto porque puede bloquear al pedo.....
pthread_mutex_lock(&mutex_tlb);
void incrementar_bit(t_tlb * entry) {
entry->referencebit++;
}
list_iterate(tabla_tlb, (void *) incrementar_bit);
pthread_mutex_unlock(&mutex_tlb);
}
void *list_find(struct list_head *head, void* key)
{
char *node = NULL;
while ((node = list_iterate(head, node))) {
if ( memcmp( node+head->key_node_offset, key, head->key_length ) == 0)
return node;
}
return NULL;
}
int supera_limite_frames(int pid) {
int cargados_en_memoria = 1;
void es_del_proceso(t_mem_frame * f) {
if (f->pid == pid)
cargados_en_memoria++;
}
list_iterate(frames_memoria, (void *) es_del_proceso);
return (cargados_en_memoria > umc_config->frame_x_prog);
}
bool filesystem_format() {
log_info(mdfs_logger, "Format FS.");
if (mongo_dir_deleteAll() && mongo_file_deleteAll()) {
t_list *nodes = mongo_node_getAll();
list_iterate(nodes, (void *) filesystem_formatNode);
list_destroy_and_destroy_elements(nodes, (void *) node_free);
return 1;
}
return 0;
}
void *comienzaPCP() {
listaVarCompartidas = list_create(); // Lista de las variables compartidas
listaSemaforos = list_create(); // Lista de Semaforos
listaIO = list_create(); // Lista de los Dispositivos IO
listaBloqueados = list_create(); //Lista de procesos bloqueados por semaforo
config = config_create(getenv("CONFIG_KERNEL"));
log_pcp = creacionLog(config_get_string_value(config, "LOG_KERNEL"), "PCP");
log_debug(log_pcp, "Inicia el proceso PCP..");
log_trace(log_pcp, "Creado log del PCP");
log_trace(log_pcp, "Cargado el archivo de configuracion");
// ######################## Cargo Archivo de config ######################## //
// Cargo QUANTUM y retardo Quantum en estructuraInicial
estructuraInicial = malloc(sizeof(t_EstructuraInicial));
estructuraInicial->Quantum = config_get_int_value(config, "QUANTUM");
estructuraInicial->RetardoQuantum = config_get_int_value(config, "RETARDO");
log_trace(log_pcp, "Cargado el Quantum: %d , retardoQuantum:%d",
estructuraInicial->Quantum, estructuraInicial->RetardoQuantum);
cpuAcerrar=0;
// Cargo las varCompartidas en listaVarCompartidas asi es mas comodo manejarlas
cargoVarCompartidasEnLista();
// Cargo los semaforos en listaSemaforos
cargoSemaforosEnLista();
// Cargo los IO en listaIO
cargoIOenLista();
pthread_t hiloIO, hiloPCB; //hilo por IO y PCB
sem_init(&semClienteOcioso, 1, 0); // Semaforo para clientes ociosos
//Creo hilo por cada dispositivo
void _creoHilos(void* entradaSalida) {
if (pthread_create(&hiloIO, NULL, hiloPorIO, (void*) entradaSalida)
!= 0) {
perror("could not create thread");
}
}
list_iterate(listaIO, (void*) _creoHilos);
// creo hilo para manejar programas que se cierren inesperadamente
if (pthread_create(&hiloPCB, NULL, (void*) hiloPCBaFinalizar, NULL ) != 0) {
perror("could not create thread");
}
// ######################## Fin loading ######################## //
server_cpu();
config_destroy(config);
log_destroy(log_pcp);
list_destroy_and_destroy_elements(listaVarCompartidas, free);
list_destroy_and_destroy_elements(listaIO, free);
list_destroy_and_destroy_elements(listaSemaforos, free);
return 0;
}
void imprimirProcesos(t_colaSincronizada* colaProcesosNuevos){
system("clear");
printf("-----------------PROCESOS NUEVOS-------------------\n");
printf("\n");
pthread_mutex_lock(colaProcesosNuevos->mutex);
list_iterate(colaProcesosNuevos->cola,imprimirProceso);
pthread_mutex_unlock(colaProcesosNuevos->mutex);
printf("\n");
printf("---------------------------------------------------\n");
}
static void update_all_catalogs(struct datagram *outgoing_dgram)
{
char text[DATAGRAM_PAYLOAD_MAX];
int length;
length = sprintf(text, "type catalog\nversion %d.%d.%s\nurl http://%s:%d\nname %s\nowner %s\nstarttime %lu\nport %d\n", CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO, preferred_hostname, port, preferred_hostname, owner, (long)starttime, port);
if(!length)
return;
list_iterate(outgoing_host_list, update_one_catalog, text);
}
uint32_t cantidad_marcos_libre(){
uint32_t cant_marcos = 0;
void _marco_libre(marco_t *m) {
if(!m->ocupado){
cant_marcos++;
}
}
//lock_lista_marcos();
list_iterate(get_lista_marcos(), (void*) _marco_libre);
//unlock_lista_marcos();
return cant_marcos;
}
static value_t *e_tuple(env_t *env, expr_t *expr)
{
value_t *result;
eli_closure_t c;
c.env = env;
c.list = list_empty();
list_iterate(tuple_val(expr), thunk_list_i, &c);
list_reverse(c.list);
result = alloc_value(v_tuple);
tuple_val(result) = c.list;
return result;
}
void fin_programa(int pid) {
int i = 0;
finalizar_en_archivo(pid);
void limpio_todo(t_swap * reg) {
if (reg->pid == pid) {
list_replace(bitmap, reg->posicion_en_swap, (void *) 0);
list_remove_and_destroy_element(list_swap, i, (void *) free);
} else {
i++;
}
}
list_iterate(list_swap, (void *) limpio_todo);
}
int main(void) {
t_list* tareas;
t_list* lista_De_Nodos;
elementTarea tarea;
tarea.numJob=1;
tarea.numTarea=2;
lista_De_Nodos=list_create();
agregarNodoALaLista(lista_De_Nodos,"NodoA");
agregarNodoALaLista(lista_De_Nodos,"NodoB");
agregarNodoALaLista(lista_De_Nodos,"NodoC");
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoA",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoA",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoB",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoC",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoC",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoC",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
agregarTareaAlNodo(lista_De_Nodos,"NodoB",tarea);
list_iterate(lista_De_Nodos,mostrarNodo);
printf("\n");
int i=BuscarNodoEnLista(lista_De_Nodos,"NodoB");
elementNodo *nodo;
nodo = list_get(lista_De_Nodos,i);
printf("El tamaño del nodoB es de :%d\n",list_size(nodo->listaDeTareas));
printf("respuesta %s %d\n",(i+1)?"encontro":"no encontro",i);
return 1;
}
void planMaps(t_job *job) {
log_info(logger, "|JOB %d| Planning", job->id);
int filesAvailables = 1;
void requestBlocks(t_file *file) {
if (!requestFileBlocks(file))
filesAvailables = 0;
}
list_iterate(job->files, (void *) requestBlocks);
void fileMap(t_file *file) {
void mapPlanning(t_list *copies) {
t_node* selectedNode = NULL;
uint16_t numBlock;
void selectNodeToMap(t_copy *copy) {
selectNode(copy, &selectedNode, &numBlock);
}
static void update_all_catalogs()
{
struct jx *j = jx_object(0);
jx_insert_string(j,"type","catalog");
jx_insert(j, jx_string("version"), jx_format("%d.%d.%d", CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO));
jx_insert_string(j,"owner",owner);
jx_insert_integer(j,"starttime",starttime);
jx_insert_integer(j,"port",port);
jx_insert(j,
jx_string("url"),
jx_format("http://%s:%d",preferred_hostname,port)
);
char *text = jx_print_string(j);
jx_delete(j);
list_iterate(outgoing_host_list, (list_op_t) catalog_query_send_update, text);
free(text);
}
infoNodo* obtenerProximoWorkerConBloque(t_list* listaNodos,int bloque,int numWorkerActual){
bool nodoBloqueConNumero(infoBloque* bloquee){
return bloquee->numeroBloque == bloque;
}
bool nodoConNumero(infoNodo* nodo){
return nodo->numero != numWorkerActual && list_any_satisfy(nodo->bloques, (void*) nodoBloqueConNumero) && (nodo->disponibilidad>0);
}
void restaurarDisp(infoNodo* nodo){
if(nodo->numero != numWorkerActual){
nodo->disponibilidad += getDisponibilidadBase();
}
}
infoNodo* nodoEncontrado = list_find(listaNodos, (void*) nodoConNumero);
if(nodoEncontrado == NULL){
list_iterate(listaNodos,(void*) restaurarDisp);
return list_find(listaNodos, (void*) nodoConNumero);
}
return nodoEncontrado;
}
/*
* FUNCTION:
* char *ns_printer_name_list(const ns_printer_t *printer)
* INPUT:
* const ns_printer_t *printer - printer object to generate list from
* OUTPUT:
* char * (return) - a newly allocated string containing the names of
* the printer
*/
char *
ns_printer_name_list(const ns_printer_t *printer)
{
char buf[BUFSIZ];
if ((printer == NULL) || (printer->name == NULL))
return (NULL);
if (snprintf(buf, sizeof (buf), "%s|", printer->name) >= sizeof (buf)) {
syslog(LOG_ERR, "ns_printer_name:buffer overflow");
return (NULL);
}
list_iterate((void **)printer->aliases,
(VFUNC_T)_ns_append_printer_name, buf, sizeof (buf));
buf[strlen(buf) - 1] = (char)NULL;
return (strdup(buf));
}