static handle_ledger_t *get_or_add_handle_ledger(TROVE_coll_id coll_id) { handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; /* search for a matching entry */ hash_link = qhash_search(s_fsid_to_ledger_table,&(coll_id)); if (hash_link) { /* return it if it exists */ ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); } else { /* alloc, initialize, then return otherwise */ ledger = (handle_ledger_t *)malloc(sizeof(handle_ledger_t)); if (ledger) { ledger->coll_id = coll_id; ledger->have_valid_ranges = 0; ledger->ledger = trove_handle_ledger_init(coll_id,NULL); if (ledger->ledger) { qhash_add(s_fsid_to_ledger_table, &(coll_id),&(ledger->hash_link)); } else { free(ledger); ledger = NULL; } } } return ledger; }
static void handle_io_sched_compl( lsm_state_t *ns, tw_bf *b, lsm_message_t *m_in, tw_lp *lp) { if (LSM_DEBUG) printf("handle_io_sched_compl called\n"); ns->sched.active_count--; if (ns->sched.active_count) { lsm_sched_op_t *next = NULL; struct qlist_head *ent = NULL; for (int i = 0; i < ns->sched.num_prios; i++) { ent = qlist_pop(&ns->sched.queues[i]); if (ent != NULL) { next = qlist_entry(ent, lsm_sched_op_t, ql); m_in->prio = i; break; } } assert(next); handle_io_request(ns, b, &next->data, m_in, lp); // now done with this request metadata rc_stack_push(lp, next, free, ns->sched.freelist); } }
int trove_handle_peek( TROVE_coll_id coll_id, TROVE_handle *out_handle_array, int max_num_handles, int *returned_handle_count) { int ret = -TROVE_EINVAL; handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; if (!out_handle_array || !returned_handle_count) { return ret; } gen_mutex_lock(&trove_handle_mutex); hash_link = qhash_search(s_fsid_to_ledger_table,&(coll_id)); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); if (ledger && (ledger->have_valid_ranges == 1)) { ret = trove_ledger_peek_handles( ledger->ledger, out_handle_array, max_num_handles, returned_handle_count); } } gen_mutex_unlock(&trove_handle_mutex); return ret; }
TROVE_handle trove_handle_alloc_from_range( TROVE_coll_id coll_id, TROVE_handle_extent_array *extent_array) { handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; TROVE_handle handle = TROVE_HANDLE_NULL; int i = 0; gen_mutex_lock(&trove_handle_mutex); hash_link = qhash_search(s_fsid_to_ledger_table, &(coll_id)); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); if (ledger && (ledger->have_valid_ranges == 1)) { for(i = 0; i < extent_array->extent_count; i++) { handle = trove_ledger_handle_alloc_from_range( ledger->ledger, &(extent_array->extent_array[i])); if (handle != TROVE_HANDLE_NULL) { break; } } } } gen_mutex_unlock(&trove_handle_mutex); return handle; }
int trove_handle_mgmt_finalize() { int i; handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; gen_mutex_lock(&trove_handle_mutex); /* this is an exhaustive and slow iterate. speed this up if 'finalize' is something that will be done frequently. */ for (i = 0; i < s_fsid_to_ledger_table->table_size; i++) { do { hash_link = qhash_search_and_remove_at_index(s_fsid_to_ledger_table, i); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); assert(ledger); assert(ledger->ledger); trove_handle_ledger_free(ledger->ledger); free(ledger); } } while(hash_link); } qhash_finalize(s_fsid_to_ledger_table); s_fsid_to_ledger_table = NULL; gen_mutex_unlock(&trove_handle_mutex); return 0; }
/* trove_handle_get_statistics() * * retrieves handle usage statistics from given collection; right now * this simply means returning the count of free handles * * returns 0 on success, -1 on error */ int trove_handle_get_statistics(TROVE_coll_id coll_id, uint64_t* free_count) { handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; gen_mutex_lock(&trove_handle_mutex); hash_link = qhash_search(s_fsid_to_ledger_table,&(coll_id)); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); if (ledger) { trove_handle_ledger_get_statistics(ledger->ledger, free_count); gen_mutex_unlock(&trove_handle_mutex); return(0); } else { gen_mutex_unlock(&trove_handle_mutex); return(-PVFS_ENOENT); } } else { gen_mutex_unlock(&trove_handle_mutex); return(-PVFS_ENOENT); } }
int id_gen_safe_unregister(BMI_id_gen_t new_id) { int ret = -EINVAL; id_gen_safe_t *id_elem = NULL; struct qlist_head *hash_link = NULL; if (ID_GEN_SAFE_INITIALIZED()) { gen_mutex_lock(&s_id_gen_safe_mutex); hash_link = qhash_search_and_remove( s_id_gen_safe_table, &new_id); if (hash_link) { id_elem = qlist_entry(hash_link, id_gen_safe_t, hash_link); assert(id_elem); id_elem->item = NULL; free(id_elem); ret = 0; } gen_mutex_unlock(&s_id_gen_safe_mutex); } return ret; }
dbpf_queued_op_t *dbpf_op_queue_shownext(dbpf_op_queue_p op_queue) { while (op_queue->next != op_queue) { return qlist_entry(op_queue->next, dbpf_queued_op_t, link); } return NULL; }
void fcfs_next_rc( void * sched, void * rc_event_save, model_net_sched_rc * rc, tw_lp * lp){ mn_sched_queue *s = sched; if (rc->rtn == -1){ // no op } else{ if (s->is_recv_queue){ dprintf("%lu (mn): rc receiving message\n", lp->gid); s->method->model_net_method_recv_msg_event_rc(lp); } else { dprintf("%lu (mn): rc issuing packet\n", lp->gid); s->method->model_net_method_packet_event_rc(lp); } if (rc->rtn == 0){ // just get the front and increment rem mn_sched_qitem *q = qlist_entry(s->reqs.next, mn_sched_qitem, ql); // just increment rem q->rem += q->req.packet_size; } else if (rc->rtn == 1){ // re-create the q item mn_sched_qitem *q = malloc(sizeof(mn_sched_qitem)); assert(q); q->req = rc->req; q->sched_params = rc->sched_params; q->rem = (q->req.is_pull ? PULL_MSG_SIZE : q->req.msg_size) % q->req.packet_size; if (q->rem == 0){ // processed exactly a packet's worth of data q->rem = q->req.packet_size; } void * e_dat = rc_event_save; if (q->req.remote_event_size > 0){ q->remote_event = malloc(q->req.remote_event_size); memcpy(q->remote_event, e_dat, q->req.remote_event_size); e_dat = (char*) e_dat + q->req.remote_event_size; } else { q->remote_event = NULL; } if (q->req.self_event_size > 0) { q->local_event = malloc(q->req.self_event_size); memcpy(q->local_event, e_dat, q->req.self_event_size); } else { q->local_event = NULL; } // add back to front of list qlist_add(&q->ql, &s->reqs); s->queue_len++; } else { assert(0); } } }
static int hash_key_compare(void *key, struct qlist_head *link) { id_gen_safe_t *id_elem = NULL; BMI_id_gen_t id = *((BMI_id_gen_t *)key); id_elem = qlist_entry(link, id_gen_safe_t, hash_link); assert(id_elem); return (id_elem->id == id); }
/* hash_key_compare() * * performs a comparison of a hash table entry to a given key * (used for searching) * * returns 1 if match found, 0 otherwise */ static int hash_key_compare(void *key, struct qlist_head *link) { mmap_ra_cache_elem_t *cache_elem = NULL; PVFS_object_ref *refn = (PVFS_object_ref *)key; cache_elem = qlist_entry(link, mmap_ra_cache_elem_t, hash_link); assert(cache_elem); return (((cache_elem->refn.handle == refn->handle) && (cache_elem->refn.fs_id == refn->fs_id)) ? 1 : 0); }
static int _compare(void *key, struct qhash_head *link) { assert(NULL != key); assert(NULL != link); cfio_io_val_t *val = qlist_entry(link, cfio_io_val_t, hash_link); if (0 == memcmp(key, val, sizeof(cfio_io_key_t))) { return 1; } return 0; }
void fcfs_add_rc(void *sched, model_net_sched_rc *rc, tw_lp *lp){ mn_sched_queue *s = sched; s->queue_len--; struct qlist_head *ent = qlist_pop_back(&s->reqs); assert(ent != NULL); mn_sched_qitem *q = qlist_entry(ent, mn_sched_qitem, ql); dprintf("%lu (mn): rc adding request from %lu to %lu\n", lp->gid, q->req.src_lp, q->req.final_dest_lp); // free'ing NULLs is a no-op free(q->remote_event); free(q->local_event); free(q); }
static int _compare_client_name(struct qhash_head *link, void *key) { assert(NULL != key); assert(NULL != link); cfio_id_client_name_t *name = qlist_entry(link, cfio_id_client_name_t, link); if(strcmp((char *)key, name->name) == 0) { return 1; } return 0; }
/* hash_fsid_compare() * * performs a comparison of a hash table entry to a given key * (used for searching) * * returns 1 if match found, 0 otherwise */ static int hash_fsid_compare(void *key, struct qlist_head *link) { handle_ledger_t *ledger = NULL; TROVE_coll_id *real_fsid = (TROVE_coll_id *)key; ledger = qlist_entry(link, handle_ledger_t, hash_link); assert(ledger); if (ledger->coll_id == *real_fsid) { return(1); } return(0); }
cfio_msg_t *cfio_recv_get_first() { cfio_msg_t *_msg = NULL, *msg; qlist_head_t *link; size_t size; debug(DEBUG_RECV, "client_get_index = %d", client_get_index); if(qlist_empty(&(msg_head[client_get_index].link))) { link = NULL; }else { link = msg_head[client_get_index].link.next; } if(NULL == link) { msg = NULL; }else { msg = qlist_entry(link, cfio_msg_t, link); cfio_recv_unpack_msg_size(msg, &size); if(msg->size == size) //only contain one single msg { qlist_del(link); _msg = msg; }else { msg->size -= size; _msg = cfio_msg_create(); _msg->addr = msg->addr; _msg->src = msg->src; _msg->dst = msg->dst; msg->addr += size; } client_get_index = (client_get_index + 1) % client_num; } if(_msg != NULL) { debug(DEBUG_RECV, "get msg size : %lu", _msg->size); } return _msg; }
static void handle_rev_io_sched_new( lsm_state_t *ns, tw_bf *b, lsm_message_t *m_in, tw_lp *lp) { if (LSM_DEBUG) printf("handle_rev_io_sched_new called\n"); ns->sched.active_count--; if (!ns->sched.active_count) handle_rev_io_request(ns, b, &m_in->data, m_in, lp); else { struct qlist_head *ent = qlist_pop_back(&ns->sched.queues[m_in->prio]); assert(ent); lsm_sched_op_t *op = qlist_entry(ent, lsm_sched_op_t, ql); free(op); } }
int trove_handle_peek_from_range( TROVE_coll_id coll_id, TROVE_handle_extent_array *extent_array, TROVE_handle *out_handle_array, int max_num_handles, int *returned_handle_count) { int ret = -TROVE_EINVAL, i = 0; handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; if (!extent_array || !out_handle_array || !returned_handle_count) { return ret; } gen_mutex_lock(&trove_handle_mutex); hash_link = qhash_search(s_fsid_to_ledger_table,&(coll_id)); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); if (ledger && (ledger->have_valid_ranges == 1)) { for(i = 0; i < extent_array->extent_count; i++) { ret = trove_ledger_peek_handles_from_extent( ledger->ledger, &(extent_array->extent_array[i]), out_handle_array, max_num_handles, returned_handle_count); /* if we get any handles back, just return, even if it's not the full amount requested */ if (ret == 0) { assert(*returned_handle_count > 0); break; } } } } gen_mutex_unlock(&trove_handle_mutex); return ret; }
static void thread_log_box(int fd, int flags, void *data) { UNUSED(fd); UNUSED(flags); int i, idx; qsignal_t *signal; qlist_t *list, *pos, *next; qlog_t *log; qthread_log_t *thread_log; signal = (qsignal_t*)data; for (i = 0; ; i++) { if (signal == g_log_thread->signals[i]) { idx = i; break; } } thread_log = g_server->thread_log[idx]; qthread_log_fetch(thread_log, &list); /* * -1 means destroy the log thread */ if (flags != -1) { qsignal_recv(signal); qsignal_active(signal, 0); } for (pos = list->next; pos != list; ) { log = qlist_entry(pos, qlog_t, entry); next = pos->next; qlist_del_init(&(log->entry)); log->n += sprintf(log->buff + log->n, " %s:%d ", log->file, log->line); vsprintf(log->buff + log->n, log->format, log->args); printf("%s\n", log->buff); if (flags == -1) { /* do flush I/O work */ } free(log); pos = next; } }
int trove_handle_free(TROVE_coll_id coll_id, TROVE_handle handle) { int ret = -1; handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; gen_mutex_lock(&trove_handle_mutex); hash_link = qhash_search(s_fsid_to_ledger_table,&(coll_id)); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); if (ledger) { ret = trove_ledger_handle_free(ledger->ledger, handle); } } gen_mutex_unlock(&trove_handle_mutex); return ret; }
TROVE_handle trove_handle_alloc(TROVE_coll_id coll_id) { handle_ledger_t *ledger = NULL; struct qlist_head *hash_link = NULL; TROVE_handle handle = TROVE_HANDLE_NULL; gen_mutex_lock(&trove_handle_mutex); hash_link = qhash_search(s_fsid_to_ledger_table,&(coll_id)); if (hash_link) { ledger = qlist_entry(hash_link, handle_ledger_t, hash_link); if (ledger && (ledger->have_valid_ranges == 1)) { handle = trove_ledger_handle_alloc(ledger->ledger); } } gen_mutex_unlock(&trove_handle_mutex); return handle; }
static qdict_node_t* find_strkey(qdict_t *dict, const char *key, int *idx) { int hash; qlist_t *list, *pos; qdict_node_t *node; hash = mainposition(dict, key); if (idx != NULL) { *idx = hash; } list = &(dict->buckets[hash]); qlist_for_each(pos, list) { node = qlist_entry(pos, qdict_node_t, entry); if (!qvalue_isstring(&(node->key))) { continue; } if (qstring_compare(node->key.data.str, key, strlen(key)) == 0) { return node; } }
void qdict_free(qdict_t *dict) { int i; qlist_t *list; qlist_t *pos, *next; qdict_node_t *node; for (i = 0; i < dict->hashsize; ++i) { list = &(dict->buckets[i]); pos = list->next; while (pos != list) { node = qlist_entry(pos, qdict_node_t, entry); next = pos->next; qvalue_free(&(node->key)); qvalue_free(&(node->value)); qfree(node); pos = next; } } qfree(dict); }
void *id_gen_safe_lookup(BMI_id_gen_t id) { void *ret = NULL; id_gen_safe_t *id_elem = NULL; struct qlist_head *hash_link = NULL; if (ID_GEN_SAFE_INITIALIZED()) { gen_mutex_lock(&s_id_gen_safe_mutex); hash_link = qhash_search(s_id_gen_safe_table, &id); if (hash_link) { id_elem = qlist_entry(hash_link, id_gen_safe_t, hash_link); assert(id_elem); assert(id_elem->id == id); assert(id_elem->item); ret = id_elem->item; } gen_mutex_unlock(&s_id_gen_safe_mutex); } return ret; }
int fcfs_next( tw_stime * poffset, void * sched, void * rc_event_save, model_net_sched_rc * rc, tw_lp * lp){ mn_sched_queue *s = sched; struct qlist_head *ent = s->reqs.next; if (ent == &s->reqs){ rc->rtn = -1; return -1; } mn_sched_qitem *q = qlist_entry(ent, mn_sched_qitem, ql); // issue the next packet int is_last_packet; uint64_t psize; if (q->req.packet_size >= q->rem) { psize = q->rem; is_last_packet = 1; } else{ psize = q->req.packet_size; is_last_packet = 0; } if (s->is_recv_queue){ dprintf("%lu (mn): receiving message of size %lu (of %lu) " "from %lu to %lu at %1.5e (last:%d)\n", lp->gid, psize, q->rem, q->req.src_lp, q->req.final_dest_lp, tw_now(lp), is_last_packet); *poffset = s->method->model_net_method_recv_msg_event(q->req.category, q->req.final_dest_lp, psize, q->req.is_pull, q->req.msg_size, 0.0, q->req.remote_event_size, q->remote_event, q->req.src_lp, lp); } else{ dprintf("%lu (mn): issuing packet of size %lu (of %lu) " "from %lu to %lu at %1.5e (last:%d)\n", lp->gid, psize, q->rem, q->req.src_lp, q->req.final_dest_lp, tw_now(lp), is_last_packet); *poffset = s->method->model_net_method_packet_event(q->req.category, q->req.final_dest_lp, psize, q->req.is_pull, q->req.msg_size, 0.0, &q->sched_params, q->req.remote_event_size, q->remote_event, q->req.self_event_size, q->local_event, q->req.src_lp, lp, is_last_packet); } // if last packet - remove from list, free, save for rc if (is_last_packet){ dprintf("last %spkt: %lu (%lu) to %lu, size %lu at %1.5e (pull:%d)\n", s->is_recv_queue ? "recv " : "send ", lp->gid, q->req.src_lp, q->req.final_dest_lp, q->req.is_pull ? PULL_MSG_SIZE : q->req.msg_size, tw_now(lp), q->req.is_pull); qlist_pop(&s->reqs); s->queue_len--; rc->req = q->req; rc->sched_params = q->sched_params; void *e_dat = rc_event_save; if (q->req.remote_event_size > 0){ memcpy(e_dat, q->remote_event, q->req.remote_event_size); e_dat = (char*) e_dat + q->req.remote_event_size; free(q->remote_event); } if (q->req.self_event_size > 0){ memcpy(e_dat, q->local_event, q->req.self_event_size); free(q->local_event); } free(q); rc->rtn = 1; } else{ q->rem -= psize; rc->rtn = 0; } return rc->rtn; }