int mysql_pool_get(struct mysql_login_info *info, struct mysql_pool_entry **mysql) {
if (0 > make_ht_key(&misc, info))
return -1;
char *ht_key = vmbuf_data(&misc);
size_t key_len = vmbuf_wlocpos(&misc);
uint32_t ofs = hashtable_lookup(&ht_idle_connections, ht_key, key_len);
if (0 == ofs) {
struct list *l = (struct list *)calloc(1, sizeof(struct list));
list_init(l);
ofs = hashtable_insert(&ht_idle_connections,
ht_key, key_len,
&l, sizeof(struct list *));
if (0 == ofs) // unable to insert
return -1;
// add one element since we know there isn't any
if (0 > create_entry(l))
return -1;
// get first free element
if (0 > get_free_entry(info, l, mysql))
return -1;
}
struct list *l = *(struct list **)hashtable_get_val(&ht_idle_connections, ofs);
if (list_empty(l)) {
LOGGER_INFO("adding one more entry in the list");
if (0 > create_entry(l))
return -1;
}
if (0 > get_free_entry(info, l, mysql))
return -1;
return 0;
}
int gnttab_grant_foreign_transfer(domid_t domid, unsigned long pfn)
{
int ref;
if (unlikely((ref = get_free_entry()) < 0))
return -ENOSPC;
gnttab_grant_foreign_transfer_ref(ref, domid, pfn);
return ref;
}
grant_ref_t
gnttab_grant_transfer(domid_t domid, unsigned long pfn)
{
grant_ref_t ref;
ref = get_free_entry();
gnttab_table[ref].frame = pfn;
gnttab_table[ref].domid = domid;
wmb();
gnttab_table[ref].flags = GTF_accept_transfer;
return ref;
}
grant_ref_t
gnttab_grant_access(domid_t domid, unsigned long frame, int readonly)
{
grant_ref_t ref;
ref = get_free_entry();
gnttab_table[ref].frame = frame;
gnttab_table[ref].domid = domid;
wmb();
readonly *= GTF_readonly;
gnttab_table[ref].flags = GTF_permit_access | readonly;
return ref;
}
int gnttab_grant_foreign_access(domid_t domid, unsigned long frame,
int readonly)
{
int ref;
if (unlikely((ref = get_free_entry()) < 0))
return -ENOSPC;
shared[ref].frame = frame;
shared[ref].domid = domid;
wmb();
shared[ref].flags = GTF_permit_access | (readonly ? GTF_readonly : 0);
return ref;
}
int gnttab_grant_foreign_access(domid_t domid, unsigned long frame,
int flags)
{
int ref;
if (unlikely((ref = get_free_entry()) < 0))
return -ENOSPC;
shared[ref].frame = frame;
shared[ref].domid = domid;
wmb();
BUG_ON(flags & (GTF_accept_transfer | GTF_reading | GTF_writing));
shared[ref].flags = GTF_permit_access | flags;
return ref;
}
PoolAllocator::ID PoolAllocator::alloc(int p_size) {
ERR_FAIL_COND_V(p_size < 1, POOL_ALLOCATOR_INVALID_ID);
#ifdef DEBUG_ENABLED
if (p_size > free_mem) OS::get_singleton()->debug_break();
#endif
ERR_FAIL_COND_V(p_size > free_mem, POOL_ALLOCATOR_INVALID_ID);
mt_lock();
if (entry_count == entry_max) {
mt_unlock();
ERR_PRINT("entry_count==entry_max");
return POOL_ALLOCATOR_INVALID_ID;
}
int size_to_alloc = aligned(p_size);
EntryIndicesPos new_entry_indices_pos;
if (!find_hole(&new_entry_indices_pos, size_to_alloc)) {
/* No hole could be found, try compacting mem */
compact();
/* Then search again */
if (!find_hole(&new_entry_indices_pos, size_to_alloc)) {
mt_unlock();
ERR_PRINT("memory can't be compacted further");
return POOL_ALLOCATOR_INVALID_ID;
}
}
EntryArrayPos new_entry_array_pos;
bool found_free_entry = get_free_entry(&new_entry_array_pos);
if (!found_free_entry) {
mt_unlock();
ERR_FAIL_COND_V(!found_free_entry, POOL_ALLOCATOR_INVALID_ID);
}
/* move all entry indices up, make room for this one */
for (int i = entry_count; i > new_entry_indices_pos; i--) {
entry_indices[i] = entry_indices[i - 1];
}
entry_indices[new_entry_indices_pos] = new_entry_array_pos;
entry_count++;
Entry &entry = entry_array[entry_indices[new_entry_indices_pos]];
entry.len = p_size;
entry.pos = (new_entry_indices_pos == 0) ? 0 : entry_end(entry_array[entry_indices[new_entry_indices_pos - 1]]); //alloc either at begining or end of previous
entry.lock = 0;
entry.check = (check_count++) & CHECK_MASK;
free_mem -= size_to_alloc;
if (free_mem < free_mem_peak)
free_mem_peak = free_mem;
ID retval = (entry_indices[new_entry_indices_pos] << CHECK_BITS) | entry.check;
mt_unlock();
//ERR_FAIL_COND_V( (uintptr_t)get(retval)%align != 0, retval );
return retval;
}
