static void __init test_zero_clear(void)
{
DECLARE_BITMAP(bmap, 1024);
/* Known way to set all bits */
memset(bmap, 0xff, 128);
expect_eq_pbl("0-22", bmap, 23);
expect_eq_pbl("0-1023", bmap, 1024);
/* single-word bitmaps */
bitmap_clear(bmap, 0, 9);
expect_eq_pbl("9-1023", bmap, 1024);
bitmap_zero(bmap, 35);
expect_eq_pbl("64-1023", bmap, 1024);
/* cross boundaries operations */
bitmap_clear(bmap, 79, 19);
expect_eq_pbl("64-78,98-1023", bmap, 1024);
bitmap_zero(bmap, 115);
expect_eq_pbl("128-1023", bmap, 1024);
/* Zeroing entire area */
bitmap_zero(bmap, 1024);
expect_eq_pbl("", bmap, 1024);
}
void buddy_free(buddy_t *bd, uint64_t addr, unsigned sz)
{
uint64_t offs = addr - bd->start;
unsigned log_sz = log2_roundup(sz);
unsigned idx = offs >> log_sz;
while (log_sz >= MIN_BUDDY_SZ_LOG2) {
int order_idx = log_sz - MIN_BUDDY_SZ_LOG2;
// Mark node free
bitmap_set(&bd->orders[order_idx], idx);
// Can we coalese up another level?
if (log_sz == MAX_BUDDY_SZ_LOG2) {
break;
}
if (bitmap_isset(&bd->orders[order_idx], BUDDY(idx)) == 0) {
// guess not...
break;
}
// Mark both non-free
bitmap_clear(&bd->orders[order_idx], idx);
bitmap_clear(&bd->orders[order_idx], BUDDY(idx));
// Move up an order
idx = DEC_ORDER(idx);
log_sz++;
}
}
/** Freeing is actually easier, as we never have to worry about
splitting blocks.
Note that this function can only free addresses and sizes that are
correctly aligned, so it's only really safe to call this with addresses
returned from buddy_alloc().
We simply mark the incoming block as free, then while we are not
at the top level of the tree, see if the buddy is also free. If so,
we mark them both as unavailable and move up the tree one level. { */
void buddy_free(buddy_t *bd, uint64_t addr, unsigned sz) {
uint64_t offs = addr - bd->start;
unsigned log_sz = log2_roundup(sz);
unsigned idx = offs >> log_sz;
while (log_sz >= MIN_BUDDY_SZ_LOG2) {
int order_idx = log_sz - MIN_BUDDY_SZ_LOG2;
/* Mark this node free. */
bitmap_set(&bd->orders[order_idx], idx);
/* Can we coalesce up another level? */
if (log_sz == MAX_BUDDY_SZ_LOG2)
break;
/* Is this node's buddy also free? */
if (bitmap_isset(&bd->orders[order_idx], BUDDY(idx)) == 0)
/* no :( */
break;
/* FIXME: Ensure max(this, buddy) wouldn't go over the max extent
of the region. */
/* Mark them both non free. */
bitmap_clear(&bd->orders[order_idx], idx);
bitmap_clear(&bd->orders[order_idx], BUDDY(idx));
/* Move up an order. */
idx = DEC_ORDER(idx);
++log_sz;
}
}
bool pdb_set_init_flags(struct samu *sampass, enum pdb_elements element, enum pdb_value_state value_flag)
{
if (!sampass->set_flags) {
if ((sampass->set_flags =
bitmap_talloc(sampass,
PDB_COUNT))==NULL) {
DEBUG(0,("bitmap_talloc failed\n"));
return False;
}
}
if (!sampass->change_flags) {
if ((sampass->change_flags =
bitmap_talloc(sampass,
PDB_COUNT))==NULL) {
DEBUG(0,("bitmap_talloc failed\n"));
return False;
}
}
switch(value_flag) {
case PDB_CHANGED:
if (!bitmap_set(sampass->change_flags, element)) {
DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
return False;
}
if (!bitmap_set(sampass->set_flags, element)) {
DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
return False;
}
DEBUG(11, ("element %d -> now CHANGED\n", element));
break;
case PDB_SET:
if (!bitmap_clear(sampass->change_flags, element)) {
DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
return False;
}
if (!bitmap_set(sampass->set_flags, element)) {
DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
return False;
}
DEBUG(11, ("element %d -> now SET\n", element));
break;
case PDB_DEFAULT:
default:
if (!bitmap_clear(sampass->change_flags, element)) {
DEBUG(0,("Can't set flag: %d in change_flags.\n",element));
return False;
}
if (!bitmap_clear(sampass->set_flags, element)) {
DEBUG(0,("Can't set flag: %d in set_flags.\n",element));
return False;
}
DEBUG(11, ("element %d -> now DEFAULT\n", element));
break;
}
return True;
}
uint64_t buddy_alloc(buddy_t *bd, unsigned sz) {
/** Firstly we find the smallest power of 2 that will hold the allocation request, and take the log base 2 of it. { */
unsigned log_sz = log2_roundup(sz);
if (log_sz > MAX_BUDDY_SZ_LOG2)
panic("buddy_alloc had request that was too large to handle!");
unsigned orig_log_sz = log_sz;
/** Then we try and find a free block of this size. This involves searching in the right bitmap for an set bit. If there are no set bits, we increase the size of the block we're searching for. { */
/* Search for a free block - we may have to increase the size of the
block to find a free one. */
int64_t idx;
while (log_sz <= MAX_BUDDY_SZ_LOG2) {
idx = bitmap_first_set(&bd->orders[log_sz - MIN_BUDDY_SZ_LOG2]);
if (idx != -1)
/* Block found! */
break;
++log_sz;
}
if (idx == -1)
/* No free blocks :( */
return ~0ULL;
/** Now, if we couldn't get a block of the size we wanted, we'll have to
split it down to the right size. { */
/* We may have to split blocks to get back to a block of
the minimum size. */
for (; log_sz != orig_log_sz; --log_sz) {
int order_idx = log_sz - MIN_BUDDY_SZ_LOG2;
/* We're splitting a block, so deallocate it first... */
bitmap_clear(&bd->orders[order_idx], idx);
/* Then set both its children as free in the next order. */
idx = INC_ORDER(idx);
bitmap_set(&bd->orders[order_idx-1], idx);
bitmap_set(&bd->orders[order_idx-1], idx+1);
}
/** By this point we have a block that is free. We should now mark it as allocated then calculate the address that actually equates to. { */
/* Mark the block as not free. */
int order_idx = log_sz - MIN_BUDDY_SZ_LOG2;
bitmap_clear(&bd->orders[order_idx], idx);
uint64_t addr = bd->start + ((uint64_t)idx << log_sz);
return addr;
}
static int ccp_find_and_assign_lsb_to_q(struct ccp_device *ccp,
int lsb_cnt, int n_lsbs,
unsigned long *lsb_pub)
{
DECLARE_BITMAP(qlsb, MAX_LSB_CNT);
int bitno;
int qlsb_wgt;
int i;
/* For each queue:
* If the count of potential LSBs available to a queue matches the
* ordinal given to us in lsb_cnt:
* Copy the mask of possible LSBs for this queue into "qlsb";
* For each bit in qlsb, see if the corresponding bit in the
* aggregation mask is set; if so, we have a match.
* If we have a match, clear the bit in the aggregation to
* mark it as no longer available.
* If there is no match, clear the bit in qlsb and keep looking.
*/
for (i = 0; i < ccp->cmd_q_count; i++) {
struct ccp_cmd_queue *cmd_q = &ccp->cmd_q[i];
qlsb_wgt = bitmap_weight(cmd_q->lsbmask, MAX_LSB_CNT);
if (qlsb_wgt == lsb_cnt) {
bitmap_copy(qlsb, cmd_q->lsbmask, MAX_LSB_CNT);
bitno = find_first_bit(qlsb, MAX_LSB_CNT);
while (bitno < MAX_LSB_CNT) {
if (test_bit(bitno, lsb_pub)) {
/* We found an available LSB
* that this queue can access
*/
cmd_q->lsb = bitno;
bitmap_clear(lsb_pub, bitno, 1);
dev_info(ccp->dev,
"Queue %d gets LSB %d\n",
i, bitno);
break;
}
bitmap_clear(qlsb, bitno, 1);
bitno = find_first_bit(qlsb, MAX_LSB_CNT);
}
if (bitno >= MAX_LSB_CNT)
return -EINVAL;
n_lsbs--;
}
}
return n_lsbs;
}
/**
* Loads a bitmap from a Run Length Encoded ASCII file.
* @see http://conwaylife.com/wiki/index.php?title=Run_Length_Encoded
*/
void
bitmap_load_rle(struct bitmap * bitmap, char * filepath)
{
// TODO: open and validate file
bitmap_clear(bitmap);
}
/* Removes the tack 'tcb' from the RDYQUE 'rq'.
*/
void
ready_queue_delete(RDYQUE *rq,TCB *tcb)
{
INT i, priority;
/* Remove the task 'tcb' from the associated FIFO (for that priority).
However, it that task is the only element at that priority then
the 'bitmap' field must be adjusted.
*/
priority = tcb->priority;
queue_delete(&(tcb->tskque));
if ( !queue_empty_p(&(rq->tskque[priority])) )
return;
bitmap_clear(rq, priority);
if ( priority!=rq->top_priority )
return;
/* This section of the code deals with the case where the highest
priority task was removed and as a result, the 'top_priority'
field must be updated.
*/
for ( i=priority/BITMAPSZ;i<NUM_BITMAP;i++ )
{
if ( rq->bitmap[i] )
{
rq->top_priority = i * BITMAPSZ + _ffs(rq->bitmap[i]);
return;
}
}
rq->top_priority = NUM_PRI;
}
static void check_output(struct gpio_kp *kp, int out, int polarity)
{
struct gpio_keypad_info *kpinfo = kp->keypad_info;
int key_index;
int in;
int gpio;
int changed = 0;
key_index = out * kpinfo->ninputs;
for (in = 0; in < kpinfo->ninputs; in++, key_index++) {
gpio = kpinfo->input_gpios[in];
changed = 0;
if (gpio_get(gpio) ^ !polarity) {
if (kp->some_keys_pressed < 3)
kp->some_keys_pressed++;
changed = !bitmap_set(kp->keys_pressed, key_index);
} else {
changed = bitmap_clear(kp->keys_pressed, key_index);
}
if (changed) {
int state = bitmap_test(kp->keys_pressed, key_index);
keys_post_event(kpinfo->keymap[key_index], state);
}
}
/* sets up the right state for the next poll cycle */
gpio = kpinfo->output_gpios[out];
if (kpinfo->flags & GPIOKPF_DRIVE_INACTIVE)
gpio_set(gpio, !polarity);
else
gpio_config(gpio, GPIO_INPUT);
}
/* Free the block on disk and release control (bwrite) of the block */
void
bfree(blocknum_t blocknum)
{
blocknum_t bit = -1;
blocknum_t block_offset;
fs_lock(mainsb);
if (blocknum <= mainsb->block_bitmap_last || blocknum >=mainsb->disk_num_blocks) {
fs_unlock(mainsb);
return;
}
/* Set the block to free */
bit = blocknum;
block_offset = bit / BITS_PER_BLOCK;
if (bitmap_get(mainsb->block_bitmap, bit) == 1) {
bitmap_clear(mainsb->block_bitmap, bit);
bpush(block_offset + mainsb->block_bitmap_first,
(char*) mainsb->block_bitmap + block_offset * DISK_BLOCK_SIZE);
mainsb->free_blocks++;
}
fs_unlock(mainsb);
}
static void mirror_iteration_done(MirrorOp *op, int ret)
{
MirrorBlockJob *s = op->s;
struct iovec *iov;
int64_t chunk_num;
int i, nb_chunks, sectors_per_chunk;
trace_mirror_iteration_done(s, op->sector_num, op->nb_sectors, ret);
s->in_flight--;
iov = op->qiov.iov;
for (i = 0; i < op->qiov.niov; i++) {
MirrorBuffer *buf = (MirrorBuffer *) iov[i].iov_base;
QSIMPLEQ_INSERT_TAIL(&s->buf_free, buf, next);
s->buf_free_count++;
}
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
chunk_num = op->sector_num / sectors_per_chunk;
nb_chunks = op->nb_sectors / sectors_per_chunk;
bitmap_clear(s->in_flight_bitmap, chunk_num, nb_chunks);
if (s->cow_bitmap && ret >= 0) {
bitmap_set(s->cow_bitmap, chunk_num, nb_chunks);
}
g_slice_free(MirrorOp, op);
qemu_coroutine_enter(s->common.co, NULL);
}
/**
* @brief Frees a direct disk block.
*
* @details Frees a direct disk block by setting the block as free in the bitmap
* of blocks.
*
* @param sb Superblock in which the disk block should be freed.
* @param num Number of the direct disk block that shall be freed.
*
* @note The superblock must be locked.
*/
PRIVATE void block_free_direct(struct superblock *sb, block_t num)
{
unsigned idx; /* Bitmap index. */
unsigned off; /* Bitmap offset. */
/* Nothing to be done. */
if (num == BLOCK_NULL)
return;
/*
* Remember free disk block to
* speedup next block allocation.
*/
if (num < sb->zsearch)
sb->zsearch = num;
num -= sb->first_data_block;
/*
* Compute block index and offset
* in the bitmap.
*/
idx = num/(BLOCK_SIZE << 3);
off = num%(BLOCK_SIZE << 3);
/* Free disk block. */
bitmap_clear(buffer_data(sb->zmap[idx]), off);
buffer_dirty(sb->zmap[idx], 1);
sb->flags |= SUPERBLOCK_DIRTY;
}
/**
* dma_release_from_contiguous() - release allocated pages
* @dev: Pointer to device for which the pages were allocated.
* @pages: Allocated pages.
* @count: Number of allocated pages.
*
* This function releases memory allocated by dma_alloc_from_contiguous().
* It returns false when provided pages do not belong to contiguous area and
* true otherwise.
*/
bool dma_release_from_contiguous(struct device *dev, struct page *pages,
int count)
{
struct cma *cma = dev_get_cma_area(dev);
unsigned long pfn;
if (!cma || !pages){
pr_err("cma is null\n");
return false;
}
pfn = page_to_pfn(pages);
if (pfn < cma->base_pfn || pfn >= cma->base_pfn + cma->count){
pr_err("pfn:%lx cma->base_pfn:%lx cma->count:%lx\n",
pfn, cma->base_pfn, cma->count);
return false;
}
VM_BUG_ON(pfn + count > cma->base_pfn + cma->count);
mutex_lock(&cma_mutex);
bitmap_clear(cma->bitmap, pfn - cma->base_pfn, count);
free_contig_range(pfn, count);
mutex_unlock(&cma_mutex);
return true;
}
void conn_free(connection_struct *conn)
{
/* Free vfs_connection_struct */
if (conn->dl_handle != NULL) {
/* Close dlopen() handle */
sys_dlclose(conn->dl_handle);
}
DLIST_REMOVE(Connections, conn);
if (conn->ngroups && conn->groups) {
SAFE_FREE(conn->groups);
conn->groups = NULL;
conn->ngroups = 0;
}
delete_nt_token(&conn->nt_user_token);
free_namearray(conn->veto_list);
free_namearray(conn->hide_list);
free_namearray(conn->veto_oplock_list);
string_free(&conn->user);
string_free(&conn->dirpath);
string_free(&conn->connectpath);
string_free(&conn->origpath);
bitmap_clear(bmap, conn->cnum);
num_open--;
ZERO_STRUCTP(conn);
SAFE_FREE(conn);
}
static void
compute_farthest (struct edge_list *edge_list, int n_exprs,
sbitmap *st_avout, sbitmap *st_avin, sbitmap *st_antin,
sbitmap *kill, sbitmap *farthest)
{
int x, num_edges;
basic_block pred, succ;
num_edges = NUM_EDGES (edge_list);
auto_sbitmap difference (n_exprs), temp_bitmap (n_exprs);
for (x = 0; x < num_edges; x++)
{
pred = INDEX_EDGE_PRED_BB (edge_list, x);
succ = INDEX_EDGE_SUCC_BB (edge_list, x);
if (succ == EXIT_BLOCK_PTR_FOR_FN (cfun))
bitmap_copy (farthest[x], st_avout[pred->index]);
else
{
if (pred == ENTRY_BLOCK_PTR_FOR_FN (cfun))
bitmap_clear (farthest[x]);
else
{
bitmap_and_compl (difference, st_avout[pred->index],
st_antin[succ->index]);
bitmap_not (temp_bitmap, st_avin[succ->index]);
bitmap_and_or (farthest[x], difference,
kill[succ->index], temp_bitmap);
}
}
}
}
/**
* dma_release_from_contiguous() - release allocated pages
* @dev: Pointer to device for which the pages were allocated.
* @pages: Allocated pages.
* @count: Number of allocated pages.
*
* This function releases memory allocated by dma_alloc_from_contiguous().
* It returns false when provided pages do not belong to contiguous area and
* true otherwise.
*/
bool dma_release_from_contiguous(struct device *dev, struct page *pages,
int count)
{
struct cma *cma = dev_get_cma_area(dev);
unsigned long pfn;
if (!cma || !pages)
return false;
pr_debug("%s(page %p)\n", __func__, (void *)pages);
pfn = page_to_pfn(pages);
if (pfn < cma->base_pfn || pfn >= cma->base_pfn + cma->count)
return false;
VM_BUG_ON(pfn + count > cma->base_pfn + cma->count);
mutex_lock(&cma_mutex);
bitmap_clear(cma->bitmap, pfn - cma->base_pfn, count);
free_contig_range(pfn, count);
adjust_managed_cma_page_count(page_zone(pages), count);
mutex_unlock(&cma_mutex);
return true;
}
static inline void release_ptd_buffers(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
{
int last = ep->ptd_index + ep->num_ptds;
if (last > epq->buf_count)
pr_err("%s: ep %p req %d len %d %s PTD[%d] $%04x num_ptds %d buf_count %d buf_avail %d buf_map %08lx skip_map %08lx\n",
__func__, ep, ep->num_req, ep->length, epq->name, ep->ptd_index,
ep->ptd_offset, ep->num_ptds, epq->buf_count, epq->buf_avail,
epq->buf_map, epq->skip_map);
BUG_ON(last > epq->buf_count);
bitmap_clear(&epq->buf_map, ep->ptd_index, ep->num_ptds);
bitmap_set(&epq->skip_map, ep->ptd_index, ep->num_ptds);
epq->buf_avail += ep->num_ptds;
epq->ptd_count--;
BUG_ON(epq->buf_avail > epq->buf_count);
BUG_ON(epq->ptd_count > epq->buf_count);
DBG(1, "%s: Done %s PTDs $%04x released %d avail %d count %d\n",
__func__, epq->name,
ep->ptd_offset, ep->num_ptds, epq->buf_avail, epq->buf_count);
DBG(1, "%s: buf_map %08lx skip_map %08lx\n", __func__,
epq->buf_map, epq->skip_map);
ep->num_ptds = 0;
ep->ptd_offset = -EINVAL;
ep->ptd_index = -EINVAL;
}
static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
unsigned int npages)
{
unsigned long entry, free_entry;
entry = dma_addr >> IOMMU_PAGE_SHIFT;
free_entry = entry - tbl->it_offset;
if (((free_entry + npages) > tbl->it_size) ||
(entry < tbl->it_offset)) {
if (printk_ratelimit()) {
printk(KERN_INFO "iommu_free: invalid entry\n");
printk(KERN_INFO "\tentry = 0x%lx\n", entry);
printk(KERN_INFO "\tdma_addr = 0x%llx\n", (u64)dma_addr);
printk(KERN_INFO "\tTable = 0x%llx\n", (u64)tbl);
printk(KERN_INFO "\tbus# = 0x%llx\n", (u64)tbl->it_busno);
printk(KERN_INFO "\tsize = 0x%llx\n", (u64)tbl->it_size);
printk(KERN_INFO "\tstartOff = 0x%llx\n", (u64)tbl->it_offset);
printk(KERN_INFO "\tindex = 0x%llx\n", (u64)tbl->it_index);
WARN_ON(1);
}
return;
}
ppc_md.tce_free(tbl, entry, npages);
bitmap_clear(tbl->it_map, free_entry, npages);
}
static int alloc_descs(unsigned int start, unsigned int cnt, int node,
struct module *owner)
{
struct irq_desc *desc;
int i;
for (i = 0; i < cnt; i++) {
desc = alloc_desc(start + i, node, owner);
if (!desc)
goto err;
mutex_lock(&sparse_irq_lock);
irq_insert_desc(start + i, desc);
mutex_unlock(&sparse_irq_lock);
}
return start;
err:
for (i--; i >= 0; i--)
free_desc(start + i);
mutex_lock(&sparse_irq_lock);
bitmap_clear(allocated_irqs, start, cnt);
mutex_unlock(&sparse_irq_lock);
return -ENOMEM;
}
void usnic_transport_unrsrv_port(enum usnic_transport_type type, u16 port_num)
{
if (type == USNIC_TRANSPORT_ROCE_CUSTOM) {
spin_lock(&roce_bitmap_lock);
if (!port_num) {
usnic_err("Unreserved unvalid port num 0 for %s\n",
usnic_transport_to_str(type));
goto out_roce_custom;
}
if (!test_bit(port_num, roce_bitmap)) {
usnic_err("Unreserving invalid %hu for %s\n",
port_num,
usnic_transport_to_str(type));
goto out_roce_custom;
}
bitmap_clear(roce_bitmap, port_num, 1);
usnic_dbg("Freeing port %hu for %s\n", port_num,
usnic_transport_to_str(type));
out_roce_custom:
spin_unlock(&roce_bitmap_lock);
} else {
usnic_err("Freeing invalid port %hu for %d\n", port_num, type);
}
}
int
main(void)
{
bitmap_t *bm;
char s[101];
int i;
bm = bitmap_new(36, 0);
for (i = 0; i < 36; i++) {
if (i % 2)
bitmap_set(bm, i);
else
bitmap_clear(bm, i);
}
printf("%s\n", bitmap_string(bm, s, 48));
bm = bitmap_set_size(bm, 10);
printf("%s\n", bitmap_string(bm, s, 48));
bm = bitmap_set_size(bm, 100);
printf("%s\n", bitmap_string(bm, s, 101));
return 0;
}
static bool
reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
{
vec<edge> stack = vNULL;
edge e;
edge_iterator ei;
sbitmap visited;
bool ret;
if (va_arg_bb == va_start_bb)
return true;
if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
return false;
visited = sbitmap_alloc (last_basic_block_for_fn (cfun));
bitmap_clear (visited);
ret = true;
FOR_EACH_EDGE (e, ei, va_arg_bb->preds)
stack.safe_push (e);
while (! stack.is_empty ())
{
basic_block src;
e = stack.pop ();
src = e->src;
if (e->flags & EDGE_COMPLEX)
{
ret = false;
break;
}
if (src == va_start_bb)
continue;
/* va_arg_bb can be executed more times than va_start_bb. */
if (src == va_arg_bb)
{
ret = false;
break;
}
gcc_assert (src != ENTRY_BLOCK_PTR_FOR_FN (cfun));
if (! bitmap_bit_p (visited, src->index))
{
bitmap_set_bit (visited, src->index);
FOR_EACH_EDGE (e, ei, src->preds)
stack.safe_push (e);
}
}
stack.release ();
sbitmap_free (visited);
return ret;
}
oof ()
{
int live_head;
int * live = &live_head;
if (live)
bitmap_clear (live);
}
static void
all_bitmaps_space_clear()
{
unsigned int i;
for(i=0; i<THE_NUMBER_OF_FIXED_BLOCK; i++)
bitmap_clear(bitmap_info + i,i);
}
/** Free a previously allocated ID.
* @param alloc Allocator to free to.
* @param id ID to free. */
void id_allocator_free(id_allocator_t *alloc, int32_t id) {
mutex_lock(&alloc->lock);
assert(bitmap_test(alloc->bitmap, id));
bitmap_clear(alloc->bitmap, id);
mutex_unlock(&alloc->lock);
}
void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt)
{
obj &= bitmap->max + bitmap->reserved_top - 1;
spin_lock(&bitmap->lock);
bitmap_clear(bitmap->table, obj, cnt);
bitmap->avail += cnt;
spin_unlock(&bitmap->lock);
}
void conn_free(connection_struct *conn)
{
DLIST_REMOVE(Connections, conn);
bitmap_clear(bmap, conn->cnum);
num_open--;
conn_free_internal(conn);
}
void _mali_osk_bitmap_free_range(struct _mali_osk_bitmap *bitmap, u32 obj, int cnt)
{
MALI_DEBUG_ASSERT_POINTER(bitmap);
_mali_osk_spinlock_lock(bitmap->lock);
bitmap_clear(bitmap->table, obj, cnt);
bitmap->last = min(bitmap->last, obj);
bitmap->avail += cnt;
_mali_osk_spinlock_unlock(bitmap->lock);
}
/* Free a number of LSB slots from the bitmap, starting at
* the indicated starting slot number.
*/
static void ccp_lsb_free(struct ccp_cmd_queue *cmd_q, unsigned int start,
unsigned int count)
{
if (!start)
return;
if (cmd_q->lsb == start) {
/* An entry from the private LSB */
bitmap_clear(cmd_q->lsbmap, start, count);
} else {
/* From the shared LSBs */
struct ccp_device *ccp = cmd_q->ccp;
mutex_lock(&ccp->sb_mutex);
bitmap_clear(ccp->lsbmap, start, count);
ccp->sb_avail = 1;
mutex_unlock(&ccp->sb_mutex);
wake_up_interruptible_all(&ccp->sb_queue);
}
}
void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt)
{
obj &= bitmap->max + bitmap->reserved_top - 1;
spin_lock(&bitmap->lock);
bitmap_clear(bitmap->table, obj, cnt);
bitmap->last = min(bitmap->last, obj);
bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
& bitmap->mask;
spin_unlock(&bitmap->lock);
}
