seen_acl_bitmap, format_bitmap_hex, change_acl_bitmap);
/* *INDENT-OFF* */
- clib_bitmap_foreach(acln, change_acl_bitmap, ({
+ clib_bitmap_foreach (acln, change_acl_bitmap) {
if (clib_bitmap_get(old_seen_acl_bitmap, acln)) {
/* ACL is being removed. */
if (acln < vec_len((*pinout_sw_if_index_vec_by_acl))) {
vec_validate((*pinout_sw_if_index_vec_by_acl), acln);
vec_add1((*pinout_sw_if_index_vec_by_acl)[acln], sw_if_index);
}
- }));
+ }
/* *INDENT-ON* */
vec_free ((*pinout_acl_vec_by_sw_if_index)[sw_if_index]);
vec_reset_length (table->meta[af].prefix_lengths_in_search_order);
/* Note: bitmap reversed so this is in fact a longest prefix match */
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, table->meta[af].non_empty_dst_address_length_bitmap,
- ({
+ clib_bitmap_foreach (i, table->meta[af].non_empty_dst_address_length_bitmap)
+ {
int dst_address_length = 128 - i;
vec_add1 (table->meta[af].prefix_lengths_in_search_order, dst_address_length);
- }));
+ }
/* *INDENT-ON* */
}
valid_queue_count = 0;
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap, ({
+ clib_bitmap_foreach (i, bitmap) {
if (i >= dev_info.nb_rx_queues)
{
err = clib_error_return (0, "illegal queue number");
goto done;
}
reta[valid_queue_count++] = i;
- }));
+ }
/* *INDENT-ON* */
/* check valid_queue_count not zero, make coverity happy */
{
int i;
q = 0;
- clib_bitmap_foreach (i, devconf->workers, ({
+ clib_bitmap_foreach (i, devconf->workers) {
vnet_hw_interface_assign_rx_thread (dm->vnet_main, xd->hw_if_index, q++,
vdm->first_worker_thread_index + i);
- }));
+ }
}
else
for (q = 0; q < xd->rx_q_used; q++)
default_hugepage_sz = clib_mem_get_default_hugepage_size ();
/* *INDENT-OFF* */
- clib_bitmap_foreach (x, tm->cpu_socket_bitmap, (
+ clib_bitmap_foreach (x, tm->cpu_socket_bitmap)
{
clib_error_t *e;
uword n_pages;
if ((e = clib_sysfs_prealloc_hugepages(x, 0, n_pages)))
clib_error_report (e);
- }));
+ }
/* *INDENT-ON* */
}
/* Note: bitmap reversed so this is in fact a longest prefix match */
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, db->ip4_non_empty_dst_address_length_bitmap,
- ({
+ clib_bitmap_foreach (i, db->ip4_non_empty_dst_address_length_bitmap)
+ {
int dst_address_length = 32 - i;
vec_add1 (db->ip4_prefix_lengths_in_search_order, dst_address_length);
- }));
+ }
/* *INDENT-ON* */
}
/* Note: bitmap reversed so this is in fact a longest prefix match */
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, db->ip6_non_empty_dst_address_length_bitmap,
- ({
+ clib_bitmap_foreach (i, db->ip6_non_empty_dst_address_length_bitmap)
+ {
int dst_address_length = 128 - i;
vec_add1 (db->ip6_prefix_lengths_in_search_order, dst_address_length);
- }));
+ }
/* *INDENT-ON* */
}
ip6_address_t *addr = addr_v;
int i = 0, rv;
u32 value;
- clib_bitmap_foreach (i, lpm->prefix_lengths_bitmap,
- ({
+ clib_bitmap_foreach (i, lpm->prefix_lengths_bitmap)
+ {
rv = lpm_128_lookup_core(lpm, addr, i, &value);
if (rv == 0)
return value;
- }));
+ }
return ~0;
}
if (sm->num_workers > 1)
{
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap,
- ({
+ clib_bitmap_foreach (i, bitmap)
+ {
vec_add1(m->workers, i);
- }));
+ }
/* *INDENT-ON* */
}
}
if (sm->num_workers > 1)
{
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap, ({ vec_add1(m->workers, i); }));
+ clib_bitmap_foreach (i, bitmap) { vec_add1(m->workers, i); }
/* *INDENT-ON* */
}
vec_free (sm->workers);
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap,
- ({
+ clib_bitmap_foreach (i, bitmap)
+ {
vec_add1(sm->workers, i);
sm->per_thread_data[sm->first_worker_index + i].snat_thread_index = j;
sm->per_thread_data[sm->first_worker_index + i].thread_index = i;
j++;
- }));
+ }
/* *INDENT-ON* */
sm->port_per_thread = (0xffff - 1024) / _vec_len (sm->workers);
bitmap = clib_bitmap_set (bitmap, i, 1);
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap,
- ({
+ clib_bitmap_foreach (i, bitmap)
+ {
vec_add1(nm->workers, i);
- }));
+ }
/* *INDENT-ON* */
clib_bitmap_free (bitmap);
memset (original, 0, n_bytes);
/* *INDENT-OFF* */
- clib_bitmap_foreach (fd, *resultb, ({
+ clib_bitmap_foreach (fd, *resultb) {
if (fd > nfds)
break;
vlsh = ldp_fd_to_vlsh (fd);
clib_bitmap_set_no_check (*libcb, fd, 1);
else
*vclb = clib_bitmap_set (*vclb, vlsh_to_session_index (vlsh), 1);
- }));
+ }
/* *INDENT-ON* */
si_bits_set = clib_bitmap_last_set (*vclb) + 1;
return 0;
/* *INDENT-OFF* */
- clib_bitmap_foreach (si, vclb, ({
+ clib_bitmap_foreach (si, vclb) {
vlsh = vls_session_index_to_vlsh (si);
ASSERT (vlsh != VLS_INVALID_HANDLE);
fd = ldp_vlsh_to_fd (vlsh);
return -1;
}
FD_SET (fd, libcb);
- }));
+ }
/* *INDENT-ON* */
return 0;
return;
/* *INDENT-OFF* */
- clib_bitmap_foreach (fd, result, ({
+ clib_bitmap_foreach (fd, result)
FD_SET ((int)fd, libcb);
- }));
/* *INDENT-ON* */
}
wrk = vcl_worker_get_current ();
/* *INDENT-OFF* */
- clib_bitmap_foreach (si, read_map, ({
+ clib_bitmap_foreach (si, read_map) {
s = vcl_session_get (wrk, si);
if (s->session_state == VCL_STATE_LISTEN)
{
vls = vls_get (vls_session_index_to_vlsh (si));
vls_mp_checks (vls, 1 /* is_add */);
}
- }));
+ }
/* *INDENT-ON* */
}
goto check_rd;
/* *INDENT-OFF* */
- clib_bitmap_foreach (sid, wrk->wr_bitmap, ({
+ clib_bitmap_foreach (sid, wrk->wr_bitmap) {
if (!(session = vcl_session_get (wrk, sid)))
{
clib_bitmap_set_no_check ((uword*)write_map, sid, 1);
}
else
svm_fifo_add_want_deq_ntf (session->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
- }));
+ }
check_rd:
if (!read_map)
goto check_mq;
- clib_bitmap_foreach (sid, wrk->rd_bitmap, ({
+ clib_bitmap_foreach (sid, wrk->rd_bitmap) {
if (!(session = vcl_session_get (wrk, sid)))
{
clib_bitmap_set_no_check ((uword*)read_map, sid, 1);
clib_bitmap_set_no_check ((uword*)read_map, sid, 1);
bits_set++;
}
- }));
+ }
/* *INDENT-ON* */
check_mq:
VLIB_BUFFER_MAX_NUMA_NODES);
/* *INDENT-OFF* */
- clib_bitmap_foreach (numa_node, bmp,
+ clib_bitmap_foreach (numa_node, bmp)
{
u8 *index = bm->default_buffer_pool_index_for_numa + numa_node;
index[0] = ~0;
if (first_valid_buffer_pool_index == 0xff)
first_valid_buffer_pool_index = index[0];
- });
+ }
/* *INDENT-ON* */
if (first_valid_buffer_pool_index == (u8) ~ 0)
}
/* *INDENT-OFF* */
- clib_bitmap_foreach (numa_node, bmp,
+ clib_bitmap_foreach (numa_node, bmp)
{
if (bm->default_buffer_pool_index_for_numa[numa_node] == (u8) ~0)
bm->default_buffer_pool_index_for_numa[numa_node] =
first_valid_buffer_pool_index;
- });
+ }
/* *INDENT-ON* */
vec_foreach (bp, bm->buffer_pools)
* autocomplete the next level of subcommands */
help_next_level = (vec_len (str) == 0) || isspace (str[vec_len (str) - 1]);
/* *INDENT-OFF* */
- clib_bitmap_foreach(index, match_bitmap, {
+ clib_bitmap_foreach (index, match_bitmap) {
if (help_next_level && is_unique) {
c = get_sub_command (vcm, c, index);
vec_foreach (sc, c->sub_commands) {
}
sc = &c->sub_commands[index];
vec_add1(result, (u8*) sc->name);
- });
+ }
/* *INDENT-ON* */
done:
uword sib_node_index, sib_slot;
vlib_node_t *sib_node;
/* *INDENT-OFF* */
- clib_bitmap_foreach (sib_node_index, node->sibling_bitmap, ({
+ clib_bitmap_foreach (sib_node_index, node->sibling_bitmap) {
sib_node = vec_elt (nm->nodes, sib_node_index);
if (sib_node != node)
{
sib_slot = vlib_node_add_next_with_slot (vm, sib_node_index, next_node_index, slot);
ASSERT (sib_slot == slot);
}
- }));
+ }
/* *INDENT-ON* */
}
}
/* *INDENT-OFF* */
- clib_bitmap_foreach (si, sib->sibling_bitmap, ({
+ clib_bitmap_foreach (si, sib->sibling_bitmap) {
vlib_node_t * m = vec_elt (nm->nodes, si);
/* Connect all of sibling's siblings to us. */
/* Connect us to all of sibling's siblings. */
n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
- }));
+ }
/* *INDENT-ON* */
/* Connect sibling to us. */
{
int j = 0;
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, n->prev_node_bitmap, ({
+ clib_bitmap_foreach (i, n->prev_node_bitmap) {
vlib_node_t *pn = vlib_get_node (vm, i);
if (j++ % 3 == 0)
s = format (s, "\n ");
s2 = format (s2, "%v (%u)", pn->name, i);
s = format (s, "%-35v", s2);
vec_reset_length (s2);
- }));
+ }
/* *INDENT-ON* */
if (vec_len (s) == 0)
j = 0;
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, n->prev_node_bitmap, ({
+ clib_bitmap_foreach (i, n->prev_node_bitmap) {
vec_validate_init_empty (tmps, j, empty);
tmps[j].prev_node = i;
j++;
- }));
+ }
/* *INDENT-ON* */
for (i = 0; i < vec_len (tmps); i++)
{
uword c;
/* *INDENT-OFF* */
- clib_bitmap_foreach (c, tr->coremask, ({
+ clib_bitmap_foreach (c, tr->coremask) {
if (clib_bitmap_get(avail_cpu, c) == 0)
return clib_error_return (0, "cpu %u is not available to be used"
" for the '%s' thread",c, tr->name);
avail_cpu = clib_bitmap_set(avail_cpu, c, 0);
- }));
+ }
/* *INDENT-ON* */
}
else
/* *INDENT-OFF* */
clib_sysfs_read ("/sys/devices/system/node/online", "%U",
unformat_bitmap_list, &nbmp);
- clib_bitmap_foreach (node, nbmp, ({
+ clib_bitmap_foreach (node, nbmp) {
p = format (p, "%s%u/cpulist%c", sys_node_path, node, 0);
clib_sysfs_read ((char *) p, "%U", unformat_bitmap_list, &cbmp);
if (clib_bitmap_get (cbmp, cpu_id))
numa_id = node;
vec_reset_length (cbmp);
vec_reset_length (p);
- }));
+ }
/* *INDENT-ON* */
vec_free (nbmp);
vec_free (cbmp);
{
uword c;
/* *INDENT-OFF* */
- clib_bitmap_foreach (c, tr->coremask, ({
+ clib_bitmap_foreach (c, tr->coremask) {
w = vlib_worker_threads + worker_thread_index++;
err = vlib_launch_thread_int (vlib_worker_thread_bootstrap_fn,
w, c);
if (err)
clib_error_report (err);
- }));
+ }
/* *INDENT-ON* */
}
}
u32 index;
/* *INDENT-OFF* */
- clib_bitmap_foreach (index, cm->async_active_ids, ({
+ clib_bitmap_foreach (index, cm->async_active_ids) {
n_cache = crypto_dequeue_frame (vm, node, ct, cm->dequeue_handlers[index],
n_cache, &n_dispatched);
- }));
+ }
/* *INDENT-ON* */
if (n_cache)
vlib_buffer_enqueue_to_next (vm, node, ct->buffer_indice, ct->nexts,
old = table->prefix_lengths_in_search_order;
/* Note: bitmap reversed so this is in fact a longest prefix match */
- clib_bitmap_foreach (i, table->non_empty_dst_address_length_bitmap,
- ({
+ clib_bitmap_foreach (i, table->non_empty_dst_address_length_bitmap)
+ {
int dst_address_length = 128 - i;
vec_add1(prefix_lengths_in_search_order, dst_address_length);
- }));
+ }
table->prefix_lengths_in_search_order = prefix_lengths_in_search_order;
{
d->workers_bitmap = bitmap;
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap,
- ({
+ clib_bitmap_foreach (i, bitmap)
+ {
vec_add1(d->workers, i);
- }));
+ }
/* *INDENT-ON* */
}
/* *INDENT-OFF* */
foreach_vlib_main (({
- clib_bitmap_foreach (si, pn->sibling_bitmap,
- ({
+ clib_bitmap_foreach (si, pn->sibling_bitmap)
+ {
rt = vlib_node_get_runtime_data (this_vlib_main, si);
vec_foreach (dq, rt->devices_and_queues)
{
send_interface_rx_placement_details (am, reg, hw->sw_if_index, index,
dq->queue_id, dq->mode, mp->context);
}
- }));
+ }
index++;
}));
/* *INDENT-ON* */
hi, verbose);
/* *INDENT-OFF* */
- clib_bitmap_foreach (hw_idx, hi->bond_info,
- ({
+ clib_bitmap_foreach (hw_idx, hi->bond_info)
+ {
shi = vnet_get_hw_interface(vnm, hw_idx);
vlib_cli_output (vm, "%U\n",
format_vnet_hw_interface, vnm, shi, verbose);
- }));
+ }
/* *INDENT-ON* */
}
}
/* *INDENT-OFF* */
foreach_vlib_main (({
- clib_bitmap_foreach (si, pn->sibling_bitmap,
- ({
+ clib_bitmap_foreach (si, pn->sibling_bitmap)
+ {
rt = vlib_node_get_runtime_data (this_vlib_main, si);
if (vec_len (rt->devices_and_queues))
dq->queue_id,
format_vnet_hw_if_rx_mode, dq->mode);
}
- }));
+ }
if (vec_len (s) > 0)
{
vlib_cli_output(vm, "Thread %u (%s):\n%v", index,
if (bitmap)
{
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, bitmap, ({
+ clib_bitmap_foreach (i, bitmap) {
s = format (s, "%u ", i);
- }));
+ }
/* *INDENT-ON* */
}
{
int hw_idx;
s = format (s, "Slave-Idx:");
- clib_bitmap_foreach (hw_idx, hi->bond_info, s =
- format (s, " %d", hw_idx));
+ clib_bitmap_foreach (hw_idx, hi->bond_info)
+ s = format (s, " %d", hw_idx);
}
else if (dev_class->format_device_name)
s = format (s, "%U", dev_class->format_device_name, hi->dev_instance);
uword i;
/* *INDENT-OFF* */
- clib_bitmap_foreach(i, rw->configs_bitmap, {
+ clib_bitmap_foreach (i, rw->configs_bitmap) {
vlib_cli_output (vm, "sw_if_index:%d %U\n", i, format_l2_rw_config, &rw->configs[i]);
- });
+ }
/* *INDENT-ON* */
return 0;
}
int i;
vec_reset_length (table->prefix_lengths_in_search_order);
/* Note: bitmap reversed so this is in fact a longest prefix match */
- clib_bitmap_foreach (i, table->non_empty_dst_address_length_bitmap,
- ({
+ clib_bitmap_foreach (i, table->non_empty_dst_address_length_bitmap)
+ {
vec_add1(table->prefix_lengths_in_search_order, (256 - i));
- }));
+ }
}
void
worker_index = vlib_get_current_worker_index ();
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, pg->enabled_streams[worker_index], ({
+ clib_bitmap_foreach (i, pg->enabled_streams[worker_index]) {
pg_stream_t *s = vec_elt_at_index (pg->streams, i);
n_packets += pg_input_stream (node, pg, s);
- }));
+ }
/* *INDENT-ON* */
return n_packets;
return;
/* *INDENT-OFF* */
- clib_bitmap_foreach (i, sm0->mirror_ports, (
+ clib_bitmap_foreach (i, sm0->mirror_ports)
{
if (mirror_frames[i] == 0)
{
#endif
}
}
- }));
+ }
/* *INDENT-ON* */
}
}
s = format (s, "%U", format_vnet_sw_if_index_name, vnm,
si - sm->interfaces);
- clib_bitmap_foreach (i, b, (
+ clib_bitmap_foreach (i, b)
{
int device = (clib_bitmap_get (drxm->mirror_ports, i) +
clib_bitmap_get (dtxm->mirror_ports, i) * 2);
format_vnet_sw_if_index_name, vnm, i,
states[device], states[l2]);
vec_reset_length (s);
- }));
+ }
clib_bitmap_free (b);
clib_bitmap_free (l);
clib_bitmap_free (d);
clib_bitmap_t *b;
u32 i;
b = clib_bitmap_dup_or (rxm->mirror_ports, txm->mirror_ports);
- clib_bitmap_foreach (i, b, (
+ clib_bitmap_foreach (i, b)
{
rmp = vl_msg_api_alloc (sizeof (*rmp));
clib_memset (rmp, 0, sizeof (*rmp));
rmp->is_l2 = mp->is_l2;
vl_api_send_msg (reg, (u8 *) rmp);
- }));
+ }
clib_bitmap_free (b);
}
}
u64 significant_errors = 0;
/* *INDENT-OFF* */
- clib_bitmap_foreach (code, gm->sig_error_bitmap,
- ({
+ clib_bitmap_foreach (code, gm->sig_error_bitmap)
+ {
for (vm_index = 0; vm_index < vec_len (gm->my_vlib_mains); vm_index++)
{
this_vlib_main = gm->my_vlib_mains[vm_index];
((vec_len(em->counters_last_clear) > code) ?
em->counters_last_clear[code] : 0);
}
- }));
+ }
/* *INDENT-ON* */
return (significant_errors);
@param ai - the bitmap
@param body - the expression to evaluate for each set bit
*/
-#define clib_bitmap_foreach(i,ai,body) \
+#define clib_bitmap_foreach(i,ai) \
+ if (ai) \
+ for (i = clib_bitmap_first_set (ai); \
+ i != ~0; \
+ i = clib_bitmap_next_set (ai, i + 1))
+
+#define clib_bitmap_foreach_old(i,ai,body) \
do { \
uword __bitmap_i, __bitmap_ai, __bitmap_len, __bitmap_first_set; \
__bitmap_len = vec_len ((ai)); \
s_lo = s_hi = 0;
/* *INDENT-OFF* */
- clib_bitmap_foreach (si, g->section_index_bitmap, ({
+ clib_bitmap_foreach (si, g->section_index_bitmap) {
u64 lo, hi;
s = vec_elt_at_index (em->sections, si);
if (hi > s_hi)
s_hi = hi;
}
- }));
+ }
/* *INDENT-ON* */
if (n_sections == 0)
vec_foreach (l, w->levels)
{
/* *INDENT-OFF* */
- clib_bitmap_foreach (wi, l->occupancy_bitmap, ({
+ clib_bitmap_foreach (wi, l->occupancy_bitmap) {
l->elts[wi] = delete_user_data (l->elts[wi], user_data);
if (vec_len (l->elts[wi]) == 0)
l->occupancy_bitmap = clib_bitmap_andnoti (l->occupancy_bitmap, wi);
- }));
+ }
/* *INDENT-ON* */
}
{
uword wi;
/* *INDENT-OFF* */
- clib_bitmap_foreach (wi, l->occupancy_bitmap, ({
+ clib_bitmap_foreach (wi, l->occupancy_bitmap) {
vec_foreach (e, l->elts[wi])
{
/* This should always be true since otherwise we would have already expired
ASSERT (e->cpu_time_relative_to_base >= delta);
e->cpu_time_relative_to_base -= delta;
}
- }));
+ }
/* *INDENT-ON* */
}
level = vec_elt_at_index (w->levels, level_index);
/* *INDENT-OFF* */
- clib_bitmap_foreach (wi, level->occupancy_bitmap, ({
+ clib_bitmap_foreach (wi, level->occupancy_bitmap) {
expired_user_data = expire_bin (w, level_index, wi, advance_cpu_time,
expired_user_data);
- }));
+ }
/* *INDENT-ON* */
}