int psivhmem_free_frame(ivshmem_pci_dev_t *dev, char * frame_ptr)
{
/*
 * first implementation: just clear corresponding bit in bitmap -> frame is available again
 *
 */
    unsigned long long n;
    unsigned long long index;

    if(!psivshmem_ptr_in_dev(dev, frame_ptr)) return -1;

    index = (frame_ptr - dev->ivshmem_base) / dev->frame_size;

    pthread_spin_lock(dev->spinlock);

	CLR_BIT(dev->bitmap,index);

    pthread_spin_unlock(dev->spinlock);

    return 0;
}

void* pull_buf(struct pipe* p, int id, const void** buf, int* seq)
{
	struct pipe_elem* elem = NULL;

	// lock
	pthread_spin_lock(&p->lock);

	if (id < 0 || id >= p->n_dst)
		goto unlock;

	if (!dequeue(&p->dst[id], (void**)&elem)) {
		*buf = elem->buf;
		*seq = elem->seq;
	}

	// unlock
unlock : 
	pthread_spin_unlock(&p->lock);

	return elem;
}

int
test_spin3(void)
#endif
{
  pthread_t t;

  wasHere = 0;
  assert(pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE) == 0);
  assert(pthread_spin_lock(&spin) == 0);
  assert(pthread_create(&t, NULL, unlocker, (void *) 0) == 0);
  assert(pthread_join(t, NULL) == 0);
  /*
   * Our spinlocks don't record the owner thread so any thread can unlock the spinlock,
   * but nor is it an error for any thread to unlock a spinlock that is not locked.
   */
  assert(pthread_spin_unlock(&spin) == 0);
  assert(pthread_spin_destroy(&spin) == 0);
  assert(wasHere == 2);

  return 0;
}

int pthread_create(pthread_t* thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void* arg) {
        event_t e;

        pthread_spin_lock(&lock);
       
        VERBOSE("[INTERCEPT] --> pthread_create\n");
       
        /* lock */
        e.owner = hashid.processes[id(pthread_self())];
        e.type = PTHREAD_CREATE;
        fire(&global_table, e);
       
        int ret = _BIANCApthread_create(thread, attr, start_routine, arg);
       
        e.son = id(*thread);
        post_fire(&global_table, e);
        hashid.processes[e.son] = find_process_id(&global_table, e.son);

        pthread_spin_unlock(&lock);
        return ret;
}

//global cron
//delete and close useless tcp fd
int
global_cron(struct server *s)
{
    int fd = -1;
    struct list_node *nds, *tmp;
    struct list *el = &s->eventlist;
    pthread_spin_lock(&el->lock);
    nds = el->head;
    el->head = NULL;
    pthread_spin_unlock(&el->lock);
    while (nds != NULL) {
        fd = *(int *) nds->data;
        if (fd > 0)
            close(fd);
        tmp = nds->next;
        free(nds->data);
        free(nds);
        nds = tmp;
    }
    return 0;
}

int
test_spin2(void)
#endif
{
  pthread_t t;

  assert(pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE) == 0);

  assert(pthread_spin_lock(&lock) == 0);

  assert(pthread_create(&t, NULL, func, NULL) == 0);
  assert(pthread_join(t, NULL) == 0);

  assert(pthread_spin_unlock(&lock) == 0);

  assert(pthread_spin_destroy(&lock) == 0);

  assert(washere == 1);

  return 0;
}

static int
usdf_pep_grow_backlog(struct usdf_pep *pep)
{
    struct usdf_connreq *crp;
    size_t extra;

    extra = sizeof(struct usdf_connreq_msg) + pep->pep_cr_max_data;

    while (pep->pep_cr_alloced < pep->pep_backlog) {
        crp = calloc(1, sizeof(*crp) + extra);
        if (crp == NULL) {
            return -FI_ENOMEM;
        }
        crp->handle.fclass = FI_CLASS_CONNREQ;
        pthread_spin_lock(&pep->pep_cr_lock);
        TAILQ_INSERT_TAIL(&pep->pep_cr_free, crp, cr_link);
        ++pep->pep_cr_alloced;
        pthread_spin_unlock(&pep->pep_cr_lock);
    }
    return 0;
}

int ddlog_ext_register_built_in_events(void){
    int spin_res = 0;
    int ret = DDLOG_RET_ERR;

    spin_res = pthread_spin_lock(&ddlog_ext_events.lock);
    if (spin_res == 0){
        ddlog_ext_events.events[ddlog_ext_events.index].event_type = DDLOG_EXT_EVENT_TYPE_BT;
        ddlog_ext_events.events[ddlog_ext_events.index].print_callback = ddlog_ext_display_bt;
        ddlog_ext_events.index++;

        ddlog_ext_events.events[ddlog_ext_events.index].event_type = DDLOG_EXT_EVENT_TYPE_HEXDUMP;
        ddlog_ext_events.events[ddlog_ext_events.index].print_callback = ddlog_ext_display_hex_dump;
        ddlog_ext_events.index++;

        spin_res = pthread_spin_unlock(&ddlog_ext_events.lock);
        if (spin_res == 0){
            ret = DDLOG_RET_OK;
        }
    }
    return ret;
}

/* Called by an I/O server upon receipt of an io_release_conch message;
   The user identified by USER is done with conch C; release it and 
   allow a waiting user to obtain the conch.  */
void
iohelp_handle_io_release_conch (struct conch *c, void *user)
{
  struct shared_io *user_sh = c->holder_shared_page;

  pthread_spin_lock (&user_sh->lock);
  if (c->holder_shared_page->conch_status != USER_HAS_NOT_CONCH)
    {
      c->holder_shared_page->conch_status = USER_HAS_NOT_CONCH;
      iohelp_fetch_shared_data (c->holder);
    }
  pthread_spin_unlock (&user_sh->lock);

  if (c->holder == user)
    {
      c->holder = 0;
      c->holder_shared_page = 0;
    }

  pthread_cond_broadcast (&c->wait);
}

inline int
sstack_sfsd_add(uint32_t weight, sstack_sfsd_pool_t *pools,
				sfsd_t *sfsd)
{
	sstack_sfsd_pool_t *temp = NULL;
	int i = 0;
	int index = -1;


	// Parameter validation
	if (weight < MAXIMUM_WEIGHT || weight > MINIMUM_WEIGHT ||
				NULL == pools || NULL == sfsd) {
		sfs_log(sfs_ctx, SFS_ERR, "%s: Invalid parametes specified \n",
						__FUNCTION__);

		errno = EINVAL;
		return -1;
	}

	// Get index of sfsd pool that covers the specified storeg weight
	for (i = 0; i < MAX_SFSD_POOLS; i++) {
		uint32_t low = *(uint32_t *) &weights[i][0];
		uint32_t high = *(uint32_t *) &weights[i][1];
		if (weight >= low && weight <= high)
			break;
	}
	index = i;
	temp = pools;

	for (i = 0; i < index; i++)
		temp ++;

	// Now temp points to the right pool
	pthread_spin_lock(&temp->lock);
	bds_list_add_tail((bds_list_head_t) &sfsd->list,
								(bds_list_head_t) &temp->list);
	pthread_spin_unlock(&temp->lock);

	return 0;
}

// funzione realtiva allo spinlock
void *do_something(long int who_i_am) {
    int i;
    int dummy;

    // imposta la cancellazione asincrona
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,&dummy);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&dummy);

    // aspetta che pure l'altro thread l'abbia fatto
    pthread_barrier_wait(&pbarrier);
    // sblocca il segnale SIGUSR1
    pthread_sigmask(SIG_UNBLOCK,&block_sig,NULL);

    while (1) {
        // selezione un intervallo casuale di tempo
        i=rand()%9+1;
        // avvisa
        printf("Thread %ld: going to sleep for %d sec...\n",who_i_am,i);
        // e dormi
        sleep(i);
        // prova ad acquisire lo spinlock
        if (pthread_spin_trylock(&spinlock)) {
            // in caso contrario avvisa
            printf("Thread %ld: wait for the spinlock...\n",who_i_am);
            // e attendi
            pthread_spin_lock(&spinlock);
        }
        // da qui ho acquisito lo spinlock
        // seleziona un intervallo casuale di tempo
        i=rand()%9+1;
        // avvisa
        printf("Thread %ld: spinlock obtained and now wait for %d sec...\n",who_i_am,i);
        // e dormi
        sleep(i);
        printf("Thread %ld: unlock spinlock...\n",who_i_am);
        // rilascia lo spinlock
        pthread_spin_unlock(&spinlock);
    }
    return NULL;
}

ssize_t
usdf_msg_recv(struct fid_ep *fep, void *buf, size_t len,
		void *desc, fi_addr_t src_addr, void *context)
{
	struct usdf_ep *ep;
	struct usdf_rx *rx;
	struct usdf_msg_qe *rqe;
	struct usdf_domain *udp;

	ep = ep_ftou(fep);
	rx = ep->ep_rx;
	udp = ep->ep_domain;

	if (TAILQ_EMPTY(&rx->r.msg.rx_free_rqe)) {
		return -FI_EAGAIN;
	}

	pthread_spin_lock(&udp->dom_progress_lock);

	rqe = TAILQ_FIRST(&rx->r.msg.rx_free_rqe);
	TAILQ_REMOVE(&rx->r.msg.rx_free_rqe, rqe, ms_link);
	--rx->r.msg.rx_num_free_rqe;

	rqe->ms_context = context;
	rqe->ms_iov[0].iov_base = buf;
	rqe->ms_iov[0].iov_len = len;
	rqe->ms_last_iov = 0;

	rqe->ms_cur_iov = 0;
	rqe->ms_cur_ptr = buf;
	rqe->ms_iov_resid = len;
	rqe->ms_length = 0;
	rqe->ms_resid = len;

	TAILQ_INSERT_TAIL(&rx->r.msg.rx_posted_rqe, rqe, ms_link);

	pthread_spin_unlock(&udp->dom_progress_lock);

	return 0;
}

/**
	@brief This function set value to thread_specific data by the key.
*/
int pthread_setspecific (pthread_key_t key, const void *value)
{
    hurd_ihash_t speci_tb = (hurd_ihash_t)get_current_pt_specific();

    /* key is valid ? */
    if (key > __pthread_key_nums ||
            __destructort_arry[key] == DESTRUCTORT_INVALID)
        return -EINVAL;

    /* has created? */
    if (!speci_tb)
    {
        int ret;

        /* if failt, it must out of memory */
        if (hurd_ihash_create(&speci_tb, HURD_IHASH_NO_LOCP) != 0)
            return -ENOMEM;

        /* add speci_tb to speci_tables */
        pthread_spin_lock(&__pthread_specific_lock);
        ret = find_elem_index_and_add_to_arry(speci_tb, &__pthread_specific_arry, (int *)&__pthread_specific_nums, NULL);
        pthread_spin_unlock(&__pthread_specific_lock);

        /* errno is always no mem */
        if (ret < 0)
        {
            hurd_ihash_destroy(speci_tb);
            return -ENOMEM;
        }

        /* set to pthread */
        set_current_pt_specific((void *)speci_tb);
    }

    /* add to ihash tables */
    if (hurd_ihash_add(speci_tb, (hurd_ihash_key_t)key, (hurd_ihash_value_t)value) != 0)
        return -ENOMEM;

    return 0;
}

void calqueue_put(double timestamp, void *payload) {

	calqueue_node *new_node;

	//printf("calqueue: inserendo %f, cwidth %f, bukettop %f, nbuckets %d, lastprio %f\n", timestamp, cwidth, buckettop, nbuckets, lastprio);

	// Fill the node entry
	new_node = malloc(sizeof(calqueue_node));
	new_node->timestamp = timestamp;
	new_node->payload = payload;
	new_node->next = NULL;

	if(new_node == NULL){
		printf("Out of memory in %s:%d\n", __FILE__, __LINE__);
		abort();
	}

	pthread_spin_lock(&cal_spinlock);
	calqueue_enq(new_node);
	pthread_spin_unlock(&cal_spinlock);

}

static void *                   /* Loop 'arg' times incrementing 'glob' */
threadFunc(void *arg)
{
    int loops = *((int *) arg);
    int loc, j, s;

    for (j = 0; j < loops; j++) {
        s = pthread_spin_lock(&splock);
        if (s != 0)
            errExitEN(s, "pthread_spin_lock");

        loc = glob;
        loc++;
        glob = loc;

        s = pthread_spin_unlock(&splock);
        if (s != 0)
            errExitEN(s, "pthread_spin_unlock");
    }

    return NULL;
}

MTC_STATIC  MTC_STATUS
script_terminate(void)
{
    MTC_U32 i;

    pthread_spin_lock(&lock);
    terminate = TRUE;
    for (i = 0 ; i < SCRIPT_SOCKET_NUM; i++) 
    {
        if (sc_listening_socket[i] > 0) 
        {
#if 0
            //  let exit system call handle this to give
            //  an accurate intication of daemon termination
            //  to calldaemon (command)

            close(sc_listening_socket[i]);
#endif
            sc_listening_socket[i] = -1;
        }
    }
    pthread_spin_unlock(&lock);

#if 0
    {
        int pthread_ret;
        // wait for thread termination;

        for (i = 0 ; i < SCRIPT_SOCKET_NUM; i++) 
        {
            if ((pthread_ret = pthread_join(sc_thread[i], NULL)) != 0) 
            {
                pthread_ret = pthread_kill(sc_thread[i], SIGKILL);
            }
        }
    }
#endif
    return MTC_SUCCESS;
}

static void
my_free_hook (void *ptr, const void *caller)
{
    pthread_spin_lock(&lock);
    /* Restore all old hooks */
    __malloc_hook = old_malloc_hook;
    __realloc_hook = old_realloc_hook;
    __free_hook = old_free_hook;
    /* Call recursively */
    free (ptr);
    /* Save underlying hooks */
    old_malloc_hook = __malloc_hook;
    old_realloc_hook = __realloc_hook;
    old_free_hook = __free_hook;
    /* printf might call free, so protect it too. */
    printf ("freed pointer %p\n", ptr);
    /* Restore our own hooks */
    __malloc_hook = my_malloc_hook;
    __realloc_hook = my_realloc_hook;
    __free_hook = my_free_hook;
    pthread_spin_unlock(&lock);
}

//for tcp
//add to list, sentinel will delete this in the main event loop
int
delete_close_event(int fd, struct fetcher *f)
{
    struct list *el = NULL;
    struct list_node *nd = NULL;
    el = f->el;
    if (el == NULL)
        return -1;
    if ((nd = malloc(sizeof(struct list_node))) == NULL)
        return -1;
    nd->data = malloc(sizeof(int));
    if (nd->data == NULL) {
        free(nd);
        return -1;
    }
    memcpy(nd->data, &fd, sizeof(int));
    pthread_spin_lock(&el->lock);
    nd->next = el->head;
    el->head = nd;
    pthread_spin_unlock(&el->lock);
    return 0;
}

static ssize_t
usdf_eq_write(struct fid_eq *feq, uint32_t event, const void *buf,
		size_t len, uint64_t flags)
{
	struct usdf_eq *eq;
	int ret;

	eq = eq_ftou(feq);

	pthread_spin_lock(&eq->eq_lock);

	/* EQ full? */
	if (atomic_get(&eq->eq_num_events) == eq->eq_ev_ring_size) {
		ret = -FI_EAGAIN;
		goto done;
	}

	ret = usdf_eq_write_event(eq, event, buf, len, flags);
done:
	pthread_spin_unlock(&eq->eq_lock);
	return ret;
}

void flush_buf(struct pipe* p, int id)
{
	struct pipe_elem* elem;

	// lock
	pthread_spin_lock(&p->lock);

	if (id < 0 || id >= p->n_dst)
		goto unlock;

	while (!dequeue(&p->dst[id], (void**)&elem)) {
		elem->ref_cnt--;
		if (elem->ref_cnt <= 0) {
			assert(elem->ref_cnt >= 0);
			assert(!enqueue(&p->src, elem));
		}
	}

unlock : 
	// unlock
	pthread_spin_unlock(&p->lock);
}