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