sizeof(srv6_localsid_sample_per_sid_memory_t), 0, 0, 1);
/* Set to zero the memory */
- memset (ls_mem, 0, sizeof(srv6_localsid_sample_per_sid_memory_t));
+ clib_memset (ls_mem, 0, sizeof(srv6_localsid_sample_per_sid_memory_t));
/* Our brand-new car is ready */
ls_mem->fib_table = table_id;
int i;
char *intfcs[] = { "eth1", "eth0", "ce" };
- memset (&config, 0, sizeof (config));
+ clib_memset (&config, 0, sizeof (config));
config.name = "test";
config.window_size = tm->window_size;
config.rx_buffer = test_rx_callback;
}
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id =
ntohs (VL_API_ABF_PLUGIN_GET_VERSION_REPLY + abf_base_msg_id);
rmp->context = mp->context;
msg_size = sizeof (*mp) + sizeof (mp->policy.paths[0]) * n_paths;
mp = vl_msg_api_alloc (msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_ABF_POLICY_DETAILS + abf_base_msg_id);
/* fill in the message */
return;
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id =
ntohs (VL_API_ACL_PLUGIN_GET_VERSION_REPLY + am->msg_id_base);
rmp->context = mp->context;
for (i = 0; i < count; i++)
{
r = vec_elt_at_index (acl_new_rules, i);
- memset (r, 0, sizeof (*r));
+ clib_memset (r, 0, sizeof (*r));
r->is_permit = rules[i].is_permit;
r->is_ipv6 = rules[i].is_ipv6;
if (r->is_ipv6)
{
/* Get ACL index */
pool_get_aligned (am->acls, a, CLIB_CACHE_LINE_BYTES);
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
/* Will return the newly allocated ACL index */
*acl_list_index = a - am->acls;
}
*/
for (tags = 2; tags >= 0; tags--)
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
/* source MAC address */
memcpy (&mask[6], mt->mac_mask, 6);
{
case 0:
default:
- memset (&mask[12], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */
l3_offset = 14;
last_tag_table = &mt->arp_table_index;
break;
case 1:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */
l3_offset = 18;
last_tag_table = &mt->arp_dot1q_table_index;
break;
case 2:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* VLAN tag2 */
- memset (&mask[20], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */
+ clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */
l3_offset = 22;
last_tag_table = &mt->arp_dot1ad_table_index;
break;
if (mt->has_egress)
{
/* egress ARP table */
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
switch (tags)
{
case 0:
default:
- memset (&mask[12], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */
l3_offset = 14;
out_last_tag_table = &mt->out_arp_table_index;
break;
case 1:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */
l3_offset = 18;
out_last_tag_table = &mt->out_arp_dot1q_table_index;
break;
case 2:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* VLAN tag2 */
- memset (&mask[20], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */
+ clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */
l3_offset = 22;
out_last_tag_table = &mt->out_arp_dot1ad_table_index;
break;
*/
for (tags = 2; tags >= 0; tags--)
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
memcpy (&mask[6], mt->mac_mask, 6);
l3_src_offs = tags * 4 + get_l3_src_offset (is6);
switch (tags)
{
case 0:
default:
- memset (&mask[12], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */
last_tag_table = &mt->table_index;
break;
case 1:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */
last_tag_table = &mt->dot1q_table_index;
break;
case 2:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* VLAN tag2 */
- memset (&mask[20], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */
+ clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */
last_tag_table = &mt->dot1ad_table_index;
break;
}
{
for (tags = 2; tags >= 0; tags--)
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
/* MAC destination */
memcpy (&mask[0], mt->mac_mask, 6);
l3_dst_offs = tags * 4 + get_l3_dst_offset (is6);
{
case 0:
default:
- memset (&mask[12], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */
out_last_tag_table = &mt->out_table_index;
break;
case 1:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */
out_last_tag_table = &mt->out_dot1q_table_index;
break;
case 2:
- memset (&mask[12], 0xff, 2); /* VLAN tag1 */
- memset (&mask[16], 0xff, 2); /* VLAN tag2 */
- memset (&mask[20], 0xff, 2); /* ethernet protocol */
+ clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */
+ clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */
+ clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */
out_last_tag_table = &mt->out_dot1ad_table_index;
break;
}
for (tags = 2; tags >= 0; tags--)
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
l3_src_offs = tags * 4 + get_l3_src_offset (is6);
memcpy (&mask[6], a->rules[i].src_mac, 6);
switch (tags)
vnet_classify_add_del_session (cm, tag_table,
mask, a->rules[i].is_permit ? ~0 : 0,
i, 0, action, metadata, 1);
- memset (&mask[12], 0, sizeof (mask) - 12);
+ clib_memset (&mask[12], 0, sizeof (mask) - 12);
}
/* add ARP table entry too */
if (!is6 && (mvec[match_type_index].arp_table_index != ~0))
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
memcpy (&mask[6], a->rules[i].src_mac, 6);
for (tags = 2; tags >= 0; tags--)
/* Add the egress entry with destination set */
for (tags = 2; tags >= 0; tags--)
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
l3_dst_offs = tags * 4 + get_l3_dst_offset (is6);
/* src mac in the other direction becomes dst */
memcpy (&mask[0], a->rules[i].src_mac, 6);
mask,
a->rules[i].is_permit ? ~0 : 0,
i, 0, action, metadata, 1);
- // memset (&mask[12], 0, sizeof (mask) - 12);
+ // clib_memset (&mask[12], 0, sizeof (mask) - 12);
}
/* add ARP table entry too */
{
for (tags = 2; tags >= 0; tags--)
{
- memset (mask, 0, sizeof (mask));
+ clib_memset (mask, 0, sizeof (mask));
switch (tags)
{
case 0:
{
/* Get ACL index */
pool_get_aligned (am->macip_acls, a, CLIB_CACHE_LINE_BYTES);
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
/* Will return the newly allocated ACL index */
*acl_list_index = a - am->macip_acls;
}
void *oldheap = acl_set_heap (am);
mp = vl_msg_api_alloc (msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_ACL_DETAILS + am->msg_id_base);
/* fill in the message */
msg_size += sizeof (mp->acls[0]) * count;
mp = vl_msg_api_alloc (msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id =
ntohs (VL_API_ACL_INTERFACE_LIST_DETAILS + am->msg_id_base);
int msg_size = sizeof (*mp) + (acl ? sizeof (mp->r[0]) * acl->count : 0);
mp = vl_msg_api_alloc (msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_DETAILS + am->msg_id_base);
/* fill in the message */
return;
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id =
ntohs (VL_API_MACIP_ACL_INTERFACE_GET_REPLY + am->msg_id_base);
rmp->context = mp->context;
int msg_size = sizeof (*rmp) + sizeof (rmp->acls[0]);
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id =
ntohs (VL_API_MACIP_ACL_INTERFACE_LIST_DETAILS + am->msg_id_base);
msg_size += sizeof (mp->whitelist[0]) * count;
mp = vl_msg_api_alloc (msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id =
ntohs (VL_API_ACL_INTERFACE_ETYPE_WHITELIST_DETAILS + am->msg_id_base);
{
acl_main_t *am = &acl_main;
clib_error_t *error = 0;
- memset (am, 0, sizeof (*am));
+ clib_memset (am, 0, sizeof (*am));
am->vlib_main = vm;
am->vnet_main = vnet_get_main ();
am->log_default = vlib_log_register_class ("acl_plugin", 0);
vam->result_ready = 0;
mp = vl_msg_api_alloc_as_if_client(msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_ACL_PLUGIN_GET_VERSION + sm->msg_id_base);
mp->client_index = vam->my_client_index;
vam->result_ready = 0;
mp = vl_msg_api_alloc_as_if_client(msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_INTERFACE_GET + sm->msg_id_base);
mp->client_index = vam->my_client_index;
msg_size += n_rules*sizeof(rules[0]);
mp = vl_msg_api_alloc_as_if_client(msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_ACL_ADD_REPLACE + sm->msg_id_base);
mp->client_index = vam->my_client_index;
if ((n_rules > 0) && rules)
msg_size += n_rules*sizeof(rules[0]);
mp = vl_msg_api_alloc_as_if_client(msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_ACL_ADD_REPLACE + sm->msg_id_base);
mp->client_index = vam->my_client_index;
if (n_rules > 0)
msg_size += n_rules*sizeof(rules[0]);
mp = vl_msg_api_alloc_as_if_client(msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_ADD + sm->msg_id_base);
mp->client_index = vam->my_client_index;
if ((n_rules > 0) && rules)
msg_size += n_rules*sizeof(rules[0]);
mp = vl_msg_api_alloc_as_if_client(msg_size);
- memset (mp, 0, msg_size);
+ clib_memset (mp, 0, msg_size);
mp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_ADD_REPLACE + sm->msg_id_base);
mp->client_index = vam->my_client_index;
if ((n_rules > 0) && rules)
DBG0("RELEAS MTE index %d new refcount %d", mask_type_index, mte->refcount);
if (mte->refcount == 0) {
/* we are not using this entry anymore */
- memset(mte, 0xae, sizeof(*mte));
+ clib_memset(mte, 0xae, sizeof(*mte));
pool_put(am->ace_mask_type_pool, mte);
}
}
{
int i, byte, bit, bitnum;
ASSERT (width <= 32);
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
for (i = 0; i < width; i++)
{
bitnum = (7 - (i & 7));
static void
make_mask_and_match_from_rule(fa_5tuple_t *mask, acl_rule_t *r, hash_ace_info_t *hi)
{
- memset(mask, 0, sizeof(*mask));
- memset(&hi->match, 0, sizeof(hi->match));
+ clib_memset(mask, 0, sizeof(*mask));
+ clib_memset(&hi->match, 0, sizeof(hi->match));
hi->action = r->is_permit;
/* we will need to be matching based on lc_index and mask_type_index when applied */
make_ip6_address_mask(&mask->ip6_addr[1], r->dst_prefixlen);
hi->match.ip6_addr[1] = r->dst.ip6;
} else {
- memset(hi->match.l3_zero_pad, 0, sizeof(hi->match.l3_zero_pad));
+ clib_memset(hi->match.l3_zero_pad, 0, sizeof(hi->match.l3_zero_pad));
make_ip4_address_mask(&mask->ip4_addr[0], r->src_prefixlen);
hi->match.ip4_addr[0] = r->src.ip4;
make_ip4_address_mask(&mask->ip4_addr[1], r->dst_prefixlen);
acl_list_t *a = &am->acls[acl_index];
vec_validate(am->hash_acl_infos, acl_index);
hash_acl_info_t *ha = vec_elt_at_index(am->hash_acl_infos, acl_index);
- memset(ha, 0, sizeof(*ha));
+ clib_memset(ha, 0, sizeof(*ha));
ha->hash_acl_exists = 1;
/* walk the newly added ACL entries and ensure that for each of them there
for(i=0; i < a->count; i++) {
hash_ace_info_t ace_info;
fa_5tuple_t mask;
- memset(&ace_info, 0, sizeof(ace_info));
+ clib_memset(&ace_info, 0, sizeof(ace_info));
ace_info.acl_index = acl_index;
ace_info.ace_index = i;
hash_acl_info_t *ha = vec_elt_at_index(am->hash_acl_infos, pae->acl_index);
hash_ace_info_t *ace_info;
u32 coll_mask_type_index = pae->mask_type_index;
- memset(&the_min_tuple, 0, sizeof(the_min_tuple));
- memset(&the_max_tuple, 0, sizeof(the_max_tuple));
+ clib_memset(&the_min_tuple, 0, sizeof(the_min_tuple));
+ clib_memset(&the_max_tuple, 0, sizeof(the_max_tuple));
int i=0;
u64 collisions = vec_len(pae->colliding_rules);
}
else
{
- memset(p5tuple_pkt->l3_zero_pad, 0, sizeof(p5tuple_pkt->l3_zero_pad));
+ clib_memset(p5tuple_pkt->l3_zero_pad, 0, sizeof(p5tuple_pkt->l3_zero_pad));
clib_memcpy (&p5tuple_pkt->ip4_addr,
get_ptr_to_offset (b0,
offsetof (ip4_header_t,
avf_create_if_args_t args;
int rv;
- memset (&args, 0, sizeof (avf_create_if_args_t));
+ clib_memset (&args, 0, sizeof (avf_create_if_args_t));
args.enable_elog = ntohl (mp->enable_elog);
args.addr.as_u32 = ntohl (mp->pci_addr);
int ret;
u32 x[4];
- memset (&args, 0, sizeof (avf_create_if_args_t));
+ clib_memset (&args, 0, sizeof (avf_create_if_args_t));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
avf_create_if_args_t args;
u32 tmp;
- memset (&args, 0, sizeof (avf_create_if_args_t));
+ clib_memset (&args, 0, sizeof (avf_create_if_args_t));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
rxq->descs = vlib_physmem_alloc_aligned (vm, am->physmem_region, &error,
rxq->size * sizeof (avf_rx_desc_t),
2 * CLIB_CACHE_LINE_BYTES);
- memset ((void *) rxq->descs, 0, rxq->size * sizeof (avf_rx_desc_t));
+ clib_memset ((void *) rxq->descs, 0, rxq->size * sizeof (avf_rx_desc_t));
vec_validate_aligned (rxq->bufs, rxq->size, CLIB_CACHE_LINE_BYTES);
rxq->qrx_tail = ad->bar0 + AVF_QRX_TAIL (qid);
avf_aq_desc_t *d;
u64 pa = ad->arq_bufs_pa + slot * AVF_MBOX_BUF_SZ;
d = &ad->arq[slot];
- memset (d, 0, sizeof (avf_aq_desc_t));
+ clib_memset (d, 0, sizeof (avf_aq_desc_t));
d->flags = AVF_AQ_F_BUF;
d->datalen = AVF_MBOX_BUF_SZ;
d->addr_hi = (u32) (pa >> 32);
int i;
/* VF MailBox Transmit */
- memset (ad->atq, 0, sizeof (avf_aq_desc_t) * AVF_MBOX_LEN);
+ clib_memset (ad->atq, 0, sizeof (avf_aq_desc_t) * AVF_MBOX_LEN);
ad->atq_bufs_pa = avf_dma_addr (vm, ad, ad->atq_bufs);
pa = avf_dma_addr (vm, ad, ad->atq);
avf_reg_write (ad, AVF_ATQBAH, (u32) (pa >> 32)); /* Base Address High */
/* VF MailBox Receive */
- memset (ad->arq, 0, sizeof (avf_aq_desc_t) * AVF_MBOX_LEN);
+ clib_memset (ad->arq, 0, sizeof (avf_aq_desc_t) * AVF_MBOX_LEN);
ad->arq_bufs_pa = avf_dma_addr (vm, ad, ad->arq_bufs);
for (i = 0; i < AVF_MBOX_LEN; i++)
u8 msg[msg_len];
virtchnl_rss_lut_t *rl;
- memset (msg, 0, msg_len);
+ clib_memset (msg, 0, msg_len);
rl = (virtchnl_rss_lut_t *) msg;
rl->vsi_id = ad->vsi_id;
rl->lut_entries = ad->rss_lut_size;
u8 msg[msg_len];
virtchnl_rss_key_t *rk;
- memset (msg, 0, msg_len);
+ clib_memset (msg, 0, msg_len);
rk = (virtchnl_rss_key_t *) msg;
rk->vsi_id = ad->vsi_id;
rk->key_len = ad->rss_key_size;
u8 msg[msg_len];
virtchnl_vsi_queue_config_info_t *ci;
- memset (msg, 0, msg_len);
+ clib_memset (msg, 0, msg_len);
ci = (virtchnl_vsi_queue_config_info_t *) msg;
ci->vsi_id = ad->vsi_id;
ci->num_queue_pairs = n_qp;
u8 msg[msg_len];
virtchnl_irq_map_info_t *imi;
- memset (msg, 0, msg_len);
+ clib_memset (msg, 0, msg_len);
imi = (virtchnl_irq_map_info_t *) msg;
imi->num_vectors = count;
virtchnl_ether_addr_list_t *al;
int i;
- memset (msg, 0, msg_len);
+ clib_memset (msg, 0, msg_len);
al = (virtchnl_ether_addr_list_t *) msg;
al->vsi_id = ad->vsi_id;
al->num_elements = count;
vec_free (ad->txqs);
clib_error_free (ad->error);
- memset (ad, 0, sizeof (*ad));
+ clib_memset (ad, 0, sizeof (*ad));
pool_put (am->devices, ad);
}
if (p == 0)
{
pool_get (cm->neighbors, n);
- memset (n, 0, sizeof (*n));
+ clib_memset (n, 0, sizeof (*n));
n->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
n->packet_template_index = (u8) ~ 0;
hash_set (cm->neighbor_by_sw_if_index, n->sw_if_index,
{
ethernet_llc_snap_and_cdp_header_t h;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
/* Send to 01:00:0c:cc:cc */
h.ethernet.dst_address[0] = 0x01;
- /* h.ethernet.dst_address[1] = 0x00; (memset) */
+ /* h.ethernet.dst_address[1] = 0x00; (clib_memset) */
h.ethernet.dst_address[2] = 0x0C;
h.ethernet.dst_address[3] = 0xCC;
h.ethernet.dst_address[4] = 0xCC;
h.llc.control = 0x03; /* UI (no extended control bytes) */
/* SNAP */
- /* h.snap.oui[0] = 0x00; (memset) */
- /* h.snap.oui[1] = 0x00; (memset) */
+ /* h.snap.oui[0] = 0x00; (clib_memset) */
+ /* h.snap.oui[1] = 0x00; (clib_memset) */
h.snap.oui[2] = 0x0C; /* Cisco = 0x00000C */
h.snap.protocol = htons (0x2000); /* CDP = 0x2000 */
{
hdlc_and_cdp_header_t h;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
h.hdlc.address = 0x0f;
- /* h.hdlc.control = 0; (memset) */
+ /* h.hdlc.control = 0; (clib_memset) */
h.hdlc.protocol = htons (0x2000); /* CDP = 0x2000 */
/* CDP */
{
srp_and_cdp_header_t h;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
/* Send to 01:00:0c:cc:cc */
h.ethernet.dst_address[0] = 0x01;
- /* h.ethernet.dst_address[1] = 0x00; (memset) */
+ /* h.ethernet.dst_address[1] = 0x00; (clib_memset) */
h.ethernet.dst_address[2] = 0x0C;
h.ethernet.dst_address[3] = 0xCC;
h.ethernet.dst_address[4] = 0xCC;
do { \
vam->result_ready = 0; \
mp = vl_msg_api_alloc(sizeof(*mp)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T + dm->msg_id_base); \
mp->client_index = vam->my_client_index; \
} while(0);
do { \
vam->result_ready = 0; \
mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T + dm->msg_id_base); \
mp->client_index = vam->my_client_index; \
} while(0);
vec_free (f->name);
vec_free (f->buffers);
/* Poison it. */
- memset (f, 0xab, sizeof (f[0]));
+ clib_memset (f, 0xab, sizeof (f[0]));
}
/* Add buffer free list. */
if (rte_mempool_get_bulk (rmp, (void *) d->mbuf_alloc_list, n_alloc) < 0)
return 0;
- memset (&bt, 0, sizeof (vlib_buffer_t));
+ clib_memset (&bt, 0, sizeof (vlib_buffer_t));
vlib_buffer_init_for_free_list (&bt, fl);
bt.buffer_pool_index = privp->buffer_pool_index;
vlib_packet_template_t *t = (vlib_packet_template_t *) vt;
vlib_worker_thread_barrier_sync (vm);
- memset (t, 0, sizeof (t[0]));
+ clib_memset (t, 0, sizeof (t[0]));
vec_add (t->packet_data, packet_data, n_packet_data_bytes);
rte_eth_allmulticast_disable (xd->port_id);
rte_eth_dev_stop (xd->port_id);
- memset (&xd->link, 0, sizeof (struct rte_eth_link));
+ clib_memset (&xd->link, 0, sizeof (struct rte_eth_link));
/* For bonded interface, stop slave links */
if (xd->pmd == VNET_DPDK_PMD_BOND)
.vni_reserved = clib_host_to_net_u32 (((u32) - 1) << 8)
};
- memset (raw, 0, sizeof raw);
+ clib_memset (raw, 0, sizeof raw);
raw[0].item.relative = 1;
raw[0].item.length = vxlan_hdr_sz;
{
/* make sure no action is taken for in-flight (marked) packets */
fle = pool_elt_at_index (xd->flow_lookup_entries, fe->mark);
- memset (fle, -1, sizeof (*fle));
+ clib_memset (fle, -1, sizeof (*fle));
vec_add1 (xd->parked_lookup_indexes, fe->mark);
xd->parked_loop_count = dm->vlib_main->main_loop_count;
}
- memset (fe, 0, sizeof (*fe));
+ clib_memset (fe, 0, sizeof (*fe));
pool_put (xd->flow_entries, fe);
goto disable_rx_offload;
fe->mark = fle - xd->flow_lookup_entries;
/* install entry in the lookup table */
- memset (fle, -1, sizeof (*fle));
+ clib_memset (fle, -1, sizeof (*fle));
if (flow->actions & VNET_FLOW_ACTION_MARK)
fle->flow_id = flow->mark_flow_id;
if (flow->actions & VNET_FLOW_ACTION_REDIRECT_TO_NODE)
done:
if (rv)
{
- memset (fe, 0, sizeof (*fe));
+ clib_memset (fe, 0, sizeof (*fe));
pool_put (xd->flow_entries, fe);
if (fle)
{
- memset (fle, -1, sizeof (*fle));
+ clib_memset (fle, -1, sizeof (*fle));
pool_put (xd->flow_lookup_entries, fle);
}
}
{
xd->lockp[q] = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
CLIB_CACHE_LINE_BYTES);
- memset ((void *) xd->lockp[q], 0, CLIB_CACHE_LINE_BYTES);
+ clib_memset ((void *) xd->lockp[q], 0, CLIB_CACHE_LINE_BYTES);
}
}
return;
xd->time_last_link_update = now ? now : xd->time_last_link_update;
- memset (&xd->link, 0, sizeof (xd->link));
+ clib_memset (&xd->link, 0, sizeof (xd->link));
rte_eth_link_get_nowait (xd->port_id, &xd->link);
if (LINK_STATE_ELOGS)
/* Allocate the per-thread device data array */
vec_validate_aligned (xd->hqos_wt, tm->n_vlib_mains - 1,
CLIB_CACHE_LINE_BYTES);
- memset (xd->hqos_wt, 0, tm->n_vlib_mains * sizeof (xd->hqos_wt[0]));
+ clib_memset (xd->hqos_wt, 0, tm->n_vlib_mains * sizeof (xd->hqos_wt[0]));
vec_validate_aligned (xd->hqos_ht, 0, CLIB_CACHE_LINE_BYTES);
- memset (xd->hqos_ht, 0, sizeof (xd->hqos_ht[0]));
+ clib_memset (xd->hqos_ht, 0, sizeof (xd->hqos_ht[0]));
/* Allocate space for one SWQ per worker thread in the I/O TX thread data structure */
vec_validate (xd->hqos_ht->swq, worker_thread_count);
{
struct rte_mempool *mp = rte_mempool_from_obj (obj);
- memset (obj, 0, mp->elt_size);
+ clib_memset (obj, 0, mp->elt_size);
rte_mempool_put (mp, obj);
}
{
vec_validate_init_empty_aligned (cwm->ops, VLIB_FRAME_SIZE - 1, 0,
CLIB_CACHE_LINE_BYTES);
- memset (cwm->cipher_resource_idx, ~0,
+ clib_memset (cwm->cipher_resource_idx, ~0,
IPSEC_CRYPTO_N_ALG * sizeof(*cwm->cipher_resource_idx));
- memset (cwm->auth_resource_idx, ~0,
+ clib_memset (cwm->auth_resource_idx, ~0,
IPSEC_INTEG_N_ALG * sizeof(*cwm->auth_resource_idx));
}
/* *INDENT-ON* */
fm->vlib_time_0 = vlib_time_now (vm);
fm->nanosecond_time_0 = unix_time_now_nsec ();
- memset (fm->template_reports, 0, sizeof (fm->template_reports));
- memset (fm->template_size, 0, sizeof (fm->template_size));
- memset (fm->template_per_flow, 0, sizeof (fm->template_per_flow));
+ clib_memset (fm->template_reports, 0, sizeof (fm->template_reports));
+ clib_memset (fm->template_size, 0, sizeof (fm->template_size));
+ clib_memset (fm->template_per_flow, 0, sizeof (fm->template_per_flow));
/* Decide how many worker threads we have */
num_threads = 1 /* main thread */ + tm->n_threads;
if (!mp)
return 1;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GBP_ENDPOINT_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
if (!mp)
return 1;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GBP_SUBNET_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
if (!mp)
return 1;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GBP_ENDPOINT_GROUP_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
if (!mp)
return 1;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GBP_RECIRC_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
if (!mp)
return 1;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GBP_CONTRACT_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
fib_protocol_t fproto;
pool_get (gbp_endpoint_group_pool, gepg);
- memset (gepg, 0, sizeof (*gepg));
+ clib_memset (gepg, 0, sizeof (*gepg));
gepg->gepg_id = epg_id;
gepg->gepg_bd = bd_id;
dpo_id_t parent = DPO_INVALID;
gpd = gbp_policy_dpo_alloc ();
- memset (gpd, 0, sizeof (*gpd));
+ clib_memset (gpd, 0, sizeof (*gpd));
gpd->gpd_proto = dproto;
gpd->gpd_sw_if_index = sw_if_index;
fib_protocol_t fproto;
pool_get (gbp_recirc_pool, gr);
- memset (gr, 0, sizeof (*gr));
+ clib_memset (gr, 0, sizeof (*gr));
gri = gr - gbp_recirc_pool;
gr->gr_epg = epg_id;
return VNET_API_ERROR_INVALID_DECAP_NEXT;
pool_get_aligned (gtm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
/* copy from arg structure */
#define _(x) t->x = a->x;
clib_error_t *error = NULL;
/* Cant "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&src, 0, sizeof src);
- memset (&dst, 0, sizeof dst);
+ clib_memset (&src, 0, sizeof src);
+ clib_memset (&dst, 0, sizeof dst);
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->is_ip6 = ipv6_set;
u8 is_ipv6 = !ip46_address_is_ip4 (&t->dst);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_GTPU_TUNNEL_DETAILS);
if (is_ipv6)
{
if (is_ip4)
last_key4.as_u64 = ~0;
else
- memset (&last_key6, 0xff, sizeof (last_key6));
+ clib_memset (&last_key6, 0xff, sizeof (last_key6));
from = vlib_frame_vector_args (from_frame);
n_left_from = from_frame->n_vectors;
int ret;
/* Can't "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&src, 0, sizeof src);
- memset (&dst, 0, sizeof dst);
+ clib_memset (&src, 0, sizeof src);
+ clib_memset (&dst, 0, sizeof dst);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
vec_validate_init_empty (im->igmp_config_by_sw_if_index,
sw_if_index, ~0);
pool_get (im->configs, config);
- memset (config, 0, sizeof (igmp_config_t));
+ clib_memset (config, 0, sizeof (igmp_config_t));
config->sw_if_index = sw_if_index;
config->igmp_group_by_key =
hash_create_mem (0, sizeof (igmp_key_t), sizeof (uword));
goto done;
}
- memset (&gaddr, 0, sizeof (gaddr));
+ clib_memset (&gaddr, 0, sizeof (gaddr));
clib_memcpy (&gaddr.ip4, &mp->group.gaddr, sizeof (ip4_address_t));
vec_validate (saddrs, mp->group.n_srcs - 1);
vl_api_igmp_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (IGMP_MSG_ID (VL_API_IGMP_DETAILS));
mp->context = context;
vl_api_igmp_group_prefix_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (IGMP_MSG_ID (VL_API_IGMP_DETAILS));
mp->context = ctx->context;
if (mp->enable)
{
pool_get (im->api_clients, api_client);
- memset (api_client, 0, sizeof (vpe_client_registration_t));
+ clib_memset (api_client, 0, sizeof (vpe_client_registration_t));
api_client->client_index = mp->client_index;
api_client->client_pid = mp->pid;
hash_set (im->igmp_api_client_by_client_index,
const ip46_address_t * saddr, const ip46_address_t * gaddr)
{
vl_api_igmp_event_t *mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs ((VL_API_IGMP_EVENT) + igmp_main.msg_id_base);
mp->context = context;
IGMP_DBG ("new-group: %U", format_igmp_key, gkey);
pool_get (im->groups, group);
- memset (group, 0, sizeof (igmp_group_t));
+ clib_memset (group, 0, sizeof (igmp_group_t));
group->key = clib_mem_alloc (sizeof (igmp_key_t));
clib_memcpy (group->key, gkey, sizeof (igmp_key_t));
group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE] =
return (NULL);
ip4 = vlib_buffer_get_current (b);
- memset (ip4, 0, sizeof (ip4_header_t));
+ clib_memset (ip4, 0, sizeof (ip4_header_t));
ip4->ip_version_and_header_length = 0x46;
ip4->ttl = 1;
ip4->protocol = IP_PROTOCOL_IGMP;
void
igmp_pkt_build_report_init (igmp_pkt_build_report_t * br, u32 sw_if_index)
{
- memset (br, 0, sizeof (*br));
+ clib_memset (br, 0, sizeof (*br));
br->base.sw_if_index = sw_if_index;
}
void
igmp_pkt_build_query_init (igmp_pkt_build_query_t * bq, u32 sw_if_index)
{
- memset (bq, 0, sizeof (*bq));
+ clib_memset (bq, 0, sizeof (*bq));
bq->base.sw_if_index = sw_if_index;
}
pool_get (im->proxy_devices, proxy_device);
im->igmp_proxy_device_by_vrf_id[vrf_id] =
proxy_device - im->proxy_devices;
- memset (proxy_device, 0, sizeof (igmp_proxy_device_t));
+ clib_memset (proxy_device, 0, sizeof (igmp_proxy_device_t));
proxy_device->vrf_id = vrf_id;
proxy_device->upstream_if = sw_if_index;
config->proxy_device_id = vrf_id;
IGMP_DBG ("new-src: (%U)", format_igmp_key, skey);
pool_get (im->srcs, src);
- memset (src, 0, sizeof (igmp_src_t));
+ clib_memset (src, 0, sizeof (igmp_src_t));
src->mode = mode;
src->key = clib_mem_alloc (sizeof (*skey));
src->group = group_index;
stream = &frm->streams[fr->stream_index];
- memset (&temp, 0, sizeof (ip6_address_t));
+ clib_memset (&temp, 0, sizeof (ip6_address_t));
aggregated_data = ioam_analyser_main.aggregated_data;
data_len = vec_len (aggregated_data);
flow_report_main_t *frm = &flow_report_main;
u16 template_id;
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
args.rewrite_callback = ioam_template_rewrite;
args.flow_data_callback = ioam_send_flows;
del ? (args.is_add = 0) : (args.is_add = 1);
hm->vlib_main = vm;
hm->vnet_main = vnet_get_main();
- memset(hm->counters, 0, sizeof(hm->counters));
+ clib_memset(hm->counters, 0, sizeof(hm->counters));
if (ip6_hbh_register_option(HBH_OPTION_TYPE_IOAM_PROOF_OF_TRANSIT, ip6_hbh_ioam_proof_of_transit_handler,
ip6_hbh_ioam_proof_of_transit_trace_handler) < 0)
hm->vlib_main = vm;
hm->vnet_main = vnet_get_main ();
- memset (hm->counters, 0, sizeof (hm->counters));
+ clib_memset (hm->counters, 0, sizeof (hm->counters));
if (ip6_hbh_register_option
{
eb = 0;
pool_get_aligned (em->buffer_pool, eb, CLIB_CACHE_LINE_BYTES);
- memset (eb, 0, sizeof (*eb));
+ clib_memset (eb, 0, sizeof (*eb));
em->buffer_per_thread[i] = eb - em->buffer_pool;
if (ioam_export_init_buffer (em, vm, eb) != 1)
{
}
em->lockp[i] = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
CLIB_CACHE_LINE_BYTES);
- memset ((void *) em->lockp[i], 0, CLIB_CACHE_LINE_BYTES);
+ clib_memset ((void *) em->lockp[i], 0, CLIB_CACHE_LINE_BYTES);
}
return (1);
}
{
pool_get_aligned (em->buffer_pool, new_eb,
CLIB_CACHE_LINE_BYTES);
- memset (new_eb, 0, sizeof (*new_eb));
+ clib_memset (new_eb, 0, sizeof (*new_eb));
if (ioam_export_init_buffer (em, vm, new_eb) == 1)
{
new_pool_index = new_eb - em->buffer_pool;
name = format (0, "ioam_cache_%08x%c", api_version, 0);
- memset (&ioam_cache_main, 0, sizeof (ioam_cache_main));
+ clib_memset (&ioam_cache_main, 0, sizeof (ioam_cache_main));
/* Ask for a correctly-sized block of API message decode slots */
em->msg_id_base = vl_msg_api_get_msg_ids
((char *) name, VL_MSG_FIRST_AVAILABLE);
if (entry)
{
vec_free (entry->ioam_rewrite_string);
- memset (entry, 0, sizeof (*entry));
+ clib_memset (entry, 0, sizeof (*entry));
pool_put (cm->ioam_rewrite_pool, entry);
}
}
ioam_e2e_id_option_t *e2e = 0;
pool_get_aligned (cm->ioam_rewrite_pool, entry, CLIB_CACHE_LINE_BYTES);
- memset (entry, 0, sizeof (*entry));
+ clib_memset (entry, 0, sizeof (*entry));
pool_index = entry - cm->ioam_rewrite_pool;
clib_memcpy (entry->dst_address.as_u64, ip0->dst_address.as_u64,
/* This nodes address and the original dest will be
* filled when the packet is processed */
vec_add2 (segments, this_seg, 1);
- memset (this_seg, 0xfe, sizeof (ip6_address_t));
+ clib_memset (this_seg, 0xfe, sizeof (ip6_address_t));
cm->sr_rewrite_template = ip6_sr_compute_rewrite_string_insert (segments);
vec_free (segments);
}
{
pool_alloc_aligned (cm->ioam_ts_pool[i],
MAX_CACHE_TS_ENTRIES, CLIB_CACHE_LINE_BYTES);
- memset (&cm->ts_stats[i], 0, sizeof (ioam_cache_ts_pool_stats_t));
+ clib_memset (&cm->ts_stats[i], 0, sizeof (ioam_cache_ts_pool_stats_t));
tw_timer_wheel_init_16t_2w_512sl (&cm->timer_wheels[i],
expired_cache_ts_timer_callback,
IOAM_CACHE_TS_TICK
}
pool_put (cm->ioam_ts_pool[thread_id], entry);
cm->ts_stats[thread_id].inuse--;
- memset (entry, 0, sizeof (*entry));
+ clib_memset (entry, 0, sizeof (*entry));
}
}
pool_get_aligned (cm->ioam_ts_pool[thread_id], entry,
CLIB_CACHE_LINE_BYTES);
- memset (entry, 0, sizeof (*entry));
+ clib_memset (entry, 0, sizeof (*entry));
*pool_index = entry - cm->ioam_ts_pool[thread_id];
clib_memcpy (entry->dst_address.as_u64, ip0->dst_address.as_u64,
else
{
seqno_rx->lost_packets += diff - 1;
- memset (bitmap->array, 0, bitmap->array_size * sizeof (u64));
+ clib_memset (bitmap->array, 0, bitmap->array_size * sizeof (u64));
}
BIT_SET (bitmap->array, seqno & bitmap->mask);
bitmap->highest = seqno;
{
if (seqno_check_wraparound (bitmap->highest, seqno))
{
- memset (bitmap->array, 0, bitmap->array_size * sizeof (u64));
+ clib_memset (bitmap->array, 0, bitmap->array_size * sizeof (u64));
BIT_SET (bitmap->array, seqno & bitmap->mask);
bitmap->highest = seqno;
return;
if (peer_dead_count > 25)
{
peer_dead_count = 0;
- memset (bitmap->array, 0, bitmap->array_size * sizeof (u64));
+ clib_memset (bitmap->array, 0,
+ bitmap->array_size * sizeof (u64));
BIT_SET (bitmap->array, seqno & bitmap->mask);
bitmap->highest = seqno;
}
{
if (new)
{
- memset(new, 0, sizeof(pot_profile));
+ clib_memset(new, 0, sizeof(pot_profile));
new->id = id;
}
}
{
u16 id = profile->id;
- memset(profile, 0, sizeof(pot_profile));
+ clib_memset(profile, 0, sizeof(pot_profile));
profile->id = id; /* Restore id alone */
}
trace_profile_cleanup (trace_profile * profile)
{
- memset (profile, 0, sizeof (trace_profile));
+ clib_memset (profile, 0, sizeof (trace_profile));
profile->trace_tsp = TSP_MICROSECONDS; /* Micro seconds */
ip6_trace_profile_cleanup (); /* lib-trace_TODO: Remove this once IOAM-IPv6 transport is a plugin */
return 0;
uword *t = NULL;
vxlan_gpe_ioam_main_t *hm = &vxlan_gpe_ioam_main;
fib_prefix_t key4;
- memset (&key4, 0, sizeof (key4));
+ clib_memset (&key4, 0, sizeof (key4));
key4.fp_proto = FIB_PROTOCOL_IP4;
key4.fp_addr.ip4.as_u32 = ip0->dst_address.as_u32;
t = hash_get_mem (hm->dst_by_ip4, &key4);
vxlan_gpe_ioam_main_t *sm = &vxlan_gpe_ioam_main;
ip46_address_t dst_addr;
- memset (&dst_addr.ip4, 0, sizeof (dst_addr.ip4));
+ clib_memset (&dst_addr.ip4, 0, sizeof (dst_addr.ip4));
if (!mp->is_ipv6)
{
clib_memcpy (&dst_addr.ip4, &mp->dst_addr, sizeof (dst_addr.ip4));
vxlan_gpe_ioam_main_t *sm = &vxlan_gpe_ioam_main;
ip46_address_t dst_addr;
- memset (&dst_addr.ip4, 0, sizeof (dst_addr.ip4));
+ clib_memset (&dst_addr.ip4, 0, sizeof (dst_addr.ip4));
if (!mp->is_ipv6)
{
clib_memcpy (&dst_addr.ip4, &mp->dst_addr, sizeof (dst_addr.ip4));
if (is_ipv4)
{
- memset (&fib_prefix, 0, sizeof (fib_prefix_t));
+ clib_memset (&fib_prefix, 0, sizeof (fib_prefix_t));
fib_prefix.fp_len = 32;
fib_prefix.fp_proto = FIB_PROTOCOL_IP4;
fib_prefix.fp_addr = dst_addr;
vxlan_gpe_ioam_dest_tunnels_t *t1;
fib_prefix_t key4, *key4_copy;
hash_pair_t *hp;
- memset (&key4, 0, sizeof (key4));
+ clib_memset (&key4, 0, sizeof (key4));
key4.fp_proto = FIB_PROTOCOL_IP4;
key4.fp_addr.ip4.as_u32 = fib_prefix.fp_addr.ip4.as_u32;
t = hash_get_mem (hm->dst_by_ip4, &key4);
return 0;
}
pool_get_aligned (hm->dst_tunnels, t1, CLIB_CACHE_LINE_BYTES);
- memset (t1, 0, sizeof (*t1));
+ clib_memset (t1, 0, sizeof (*t1));
t1->fp_proto = FIB_PROTOCOL_IP4;
t1->dst_addr.ip4.as_u32 = fib_prefix.fp_addr.ip4.as_u32;
key4_copy = clib_mem_alloc (sizeof (*key4_copy));
hm->vlib_main = vm;
hm->vnet_main = vnet_get_main ();
- memset (hm->counters, 0, sizeof (hm->counters));
+ clib_memset (hm->counters, 0, sizeof (hm->counters));
if (vxlan_gpe_ioam_register_option
(VXLAN_GPE_OPTION_TYPE_IOAM_TRACE,
flow_report_main_t *frm = &flow_report_main;
u16 template_id;
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
args.rewrite_callback = udp_ping_template_rewrite;
args.flow_data_callback = udp_ping_send_flows;
del ? (args.is_add = 0) : (args.is_add = 1);
do { \
vam->result_ready = 0; \
mp = vl_msg_api_alloc(sizeof(*mp)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T + sm->msg_id_base); \
mp->client_index = vam->my_client_index; \
} while(0);
if (error)
return error;
- memset (dq->descriptors, 0,
- dq->n_descriptors * sizeof (dq->descriptors[0]));
+ clib_memset (dq->descriptors, 0,
+ dq->n_descriptors * sizeof (dq->descriptors[0]));
vec_resize (dq->descriptor_buffer_indices, dq->n_descriptors);
if (rt == VLIB_RX)
vec_foreach (xd, xm->devices)
{
ixge_update_counters (xd);
- memset (xd->counters, 0, sizeof (xd->counters));
+ clib_memset (xd->counters, 0, sizeof (xd->counters));
}
timeout = 30.0;
clib_error_t *error;
xm->vlib_main = vm;
- memset (&xm->tx_descriptor_template, 0,
- sizeof (xm->tx_descriptor_template));
- memset (&xm->tx_descriptor_template_mask, 0,
- sizeof (xm->tx_descriptor_template_mask));
+ clib_memset (&xm->tx_descriptor_template, 0,
+ sizeof (xm->tx_descriptor_template));
+ clib_memset (&xm->tx_descriptor_template_mask, 0,
+ sizeof (xm->tx_descriptor_template_mask));
xm->tx_descriptor_template.status0 =
(IXGE_TX_DESCRIPTOR_STATUS0_ADVANCED |
IXGE_TX_DESCRIPTOR_STATUS0_IS_ADVANCED |
if (vec_len (l2_emulations) >= sw_if_index)
{
l2_emulation_t *l23e = &l2_emulations[sw_if_index];
- memset (l23e, 0, sizeof (*l23e));
+ clib_memset (l23e, 0, sizeof (*l23e));
l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_L2_EMULATION, 0);
ip4_sw_interface_enable_disable (sw_if_index, 0);
if ((sif->port_enabled == 0) || (sif->lacp_enabled == 0))
continue;
vec_add2(r_lacpifs, lacpif, 1);
- memset (lacpif, 0, sizeof (*lacpif));
+ clib_memset (lacpif, 0, sizeof (*lacpif));
lacpif->sw_if_index = sif->sw_if_index;
hi = vnet_get_hw_interface (vnm, sif->hw_if_index);
clib_memcpy(lacpif->interface_name, hi->name,
/* Create the ethernet lacp packet template */
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
memcpy (h.ethernet.dst_address, dst, sizeof (h.ethernet.dst_address));
/* Create the ethernet marker protocol packet template */
- memset (&m, 0, sizeof (m));
+ clib_memset (&m, 0, sizeof (m));
memcpy (m.ethernet.dst_address, dst, sizeof (m.ethernet.dst_address));
vl_api_sw_interface_lacp_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_LACP_DETAILS + lm->msg_id_base);
mp->sw_if_index = htonl (lacp_if->sw_if_index);
{
/* Add SNAT static mapping */
pool_get (lbm->snat_mappings, m);
- memset (m, 0, sizeof (*m));
+ clib_memset (m, 0, sizeof (*m));
if (lb_vip_is_nat4_port(vip)) {
lb_snat4_key_t m_key4;
clib_bihash_kv_8_8_t kv4;
am = &api_main;
shmem_hdr = am->shmem_hdr;
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MACTIME_ADD_DEL_RANGE + mm->msg_id_base);
name = format (0, "mac-%U", format_mac_address, mac_address);
feature_init (mm);
- memset (&kv, 0, sizeof (kv));
+ clib_memset (&kv, 0, sizeof (kv));
memcpy (&kv.key, mp->mac_address, sizeof (mp->mac_address));
/* See if we have a lookup table entry for this src mac address */
if (found == 0)
{
pool_get (mm->devices, dp);
- memset (dp, 0, sizeof (*dp));
+ clib_memset (dp, 0, sizeof (*dp));
vlib_validate_combined_counter (&mm->allow_counters,
dp - mm->devices);
vlib_zero_combined_counter (&mm->allow_counters, dp - mm->devices);
exit (EXIT_FAILURE);
}
- memset(&ifr, 0, sizeof(ifr));
+ clib_memset(&ifr, 0, sizeof(ifr));
snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", interface);
/* Bind socket to interface of this node. */
/* Get domain index */
pool_get_aligned (mm->domains, d, CLIB_CACHE_LINE_BYTES);
- memset (d, 0, sizeof (*d));
+ clib_memset (d, 0, sizeof (*d));
*map_domain_index = d - mm->domains;
/* Init domain struct */
d->rules = clib_mem_alloc_aligned (l, CLIB_CACHE_LINE_BYTES);
if (!d->rules)
return -1;
- memset (d->rules, 0, l);
+ clib_memset (d->rules, 0, l);
}
if (psid >= (0x1 << d->psid_length))
}
else
{
- memset (&d->rules[psid], 0, sizeof (ip6_address_t));
+ clib_memset (&d->rules[psid], 0, sizeof (ip6_address_t));
}
return 0;
}
clib_error_t *error = NULL;
int is_del = 0;
- memset (&ip4nh, 0, sizeof (ip4nh));
- memset (&ip6nh, 0, sizeof (ip6nh));
+ clib_memset (&ip4nh, 0, sizeof (ip4nh));
+ clib_memset (&ip6nh, 0, sizeof (ip6nh));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
ip6_address_t ip6_prefix;
if (d->rules)
- memset (&ip6_prefix, 0, sizeof (ip6_prefix));
+ clib_memset (&ip6_prefix, 0, sizeof (ip6_prefix));
else
ip6_prefix = d->ip6_prefix;
int which, i;
vlib_counter_t v;
- memset (total_pkts, 0, sizeof (total_pkts));
- memset (total_bytes, 0, sizeof (total_bytes));
+ clib_memset (total_pkts, 0, sizeof (total_pkts));
+ clib_memset (total_bytes, 0, sizeof (total_bytes));
map_domain_counter_lock (mm);
vec_foreach (cm, mm->domain_counters)
/* *INDENT-OFF* */
pool_foreach(d, mm->domains,
({
- /* Make sure every field is initiated (or don't skip the memset()) */
+ /* Make sure every field is initiated (or don't skip the clib_memset()) */
rmp = vl_msg_api_alloc (sizeof (*rmp));
rmp->_vl_msg_id = htons(VL_API_MAP_DOMAIN_DETAILS + mm->msg_id_base);
rmp->context = mp->context;
continue;
}
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_MAP_RULE_DETAILS + mm->msg_id_base);
rmp->psid = htons (i);
clib_memcpy (rmp->ip6_dst, &dst, sizeof (rmp->ip6_dst));
goto out;
}
- memset (total_pkts, 0, sizeof (total_pkts));
- memset (total_bytes, 0, sizeof (total_bytes));
+ clib_memset (total_pkts, 0, sizeof (total_pkts));
+ clib_memset (total_bytes, 0, sizeof (total_bytes));
map_domain_counter_lock (mm);
vec_foreach (cm, mm->domain_counters)
}
pool_get (ppm->interfaces, ppif);
- memset (ppif, 0, sizeof (*ppif));
+ clib_memset (ppif, 0, sizeof (*ppif));
ppif->dev_instance = ppif - ppm->interfaces;
ppif->hw_if_index = ~0;
vec_validate_aligned (ppif->inqs, n_inqs - 1, CLIB_CACHE_LINE_BYTES);
clib_error_t *err;
sock = clib_mem_alloc (sizeof (clib_socket_t));
- memset (sock, 0, sizeof (clib_socket_t));
+ clib_memset (sock, 0, sizeof (clib_socket_t));
while (1)
{
if (mif->flags & MEMIF_IF_FLAG_IS_SLAVE)
{
- memset (sock, 0, sizeof(clib_socket_t));
+ clib_memset (sock, 0, sizeof(clib_socket_t));
sock->config = (char *) msf->filename;
sock->flags = CLIB_SOCKET_F_IS_CLIENT| CLIB_SOCKET_F_SEQPACKET;
}
pool_get (mm->socket_files, msf);
- memset (msf, 0, sizeof (memif_socket_file_t));
+ clib_memset (msf, 0, sizeof (memif_socket_file_t));
msf->filename = socket_filename;
msf->socket_id = sock_id;
}
}
- memset (mif, 0, sizeof (*mif));
+ clib_memset (mif, 0, sizeof (*mif));
pool_put (mm->interfaces, mif);
if (pool_elts (mm->interfaces) == 0)
}
pool_get (mm->interfaces, mif);
- memset (mif, 0, sizeof (*mif));
+ clib_memset (mif, 0, sizeof (*mif));
mif->dev_instance = mif - mm->interfaces;
mif->socket_file_index = msf - mm->socket_files;
mif->id = args->id;
ASSERT (msf->sock == 0);
msf->sock = s;
- memset (s, 0, sizeof (clib_socket_t));
+ clib_memset (s, 0, sizeof (clib_socket_t));
s->config = (char *) msf->filename;
s->flags = CLIB_SOCKET_F_IS_SERVER |
CLIB_SOCKET_F_ALLOW_GROUP_WRITE |
{
memif_main_t *mm = &memif_main;
- memset (mm, 0, sizeof (memif_main_t));
+ clib_memset (mm, 0, sizeof (memif_main_t));
mm->log_class = vlib_log_register_class ("memif_plugin", 0);
memif_log_debug (0, "initialized");
hwif = vnet_get_sup_hw_interface (vnm, swif->sw_if_index);
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_MEMIF_DETAILS + mm->msg_id_base);
mp->context = context;
memif_main_t *mm = &memif_main;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_MEMIF_SOCKET_FILENAME_DETAILS
+ mm->msg_id_base);
goto done;
memif_desc_t *dt = &ptd->desc_template;
- memset (dt, 0, sizeof (memif_desc_t));
+ clib_memset (dt, 0, sizeof (memif_desc_t));
dt->length = buffer_length;
n_alloc = vlib_buffer_alloc_to_ring (vm, mq->buffers, head & mask,
}
// clear previous cache data if interface reconncected
- memset (mq, 0, sizeof (memif_queue_t));
+ clib_memset (mq, 0, sizeof (memif_queue_t));
mq->int_fd = fd;
mq->int_clib_file_index = ~0;
mq->log2_ring_size = ar->log2_ring_size;
clib_socket_t *client;
client = clib_mem_alloc (sizeof (clib_socket_t));
- memset (client, 0, sizeof (clib_socket_t));
+ clib_memset (client, 0, sizeof (clib_socket_t));
err = clib_socket_accept (msf->sock, client);
if (err)
goto error;
(&dm->per_thread_data[thread_index].b4_hash, &b4_kv, &b4_value))
{
pool_get (dm->per_thread_data[thread_index].b4s, b4);
- memset (b4, 0, sizeof (*b4));
+ clib_memset (b4, 0, sizeof (*b4));
b4->addr.as_u64[0] = in2out_key->softwire_id.as_u64[0];
b4->addr.as_u64[1] = in2out_key->softwire_id.as_u64[1];
return DSLITE_IN2OUT_NEXT_DROP;
}
pool_get (dm->per_thread_data[thread_index].sessions, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
b4->nsessions++;
pool_get (dm->per_thread_data[thread_index].list_pool, elt);
{
/* no, make a new one */
pool_get (tsm->users, u);
- memset (u, 0, sizeof (*u));
+ clib_memset (u, 0, sizeof (*u));
u->addr.as_u32 = addr->as_u32;
u->fib_index = fib_index;
else
{
pool_get (tsm->sessions, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
/* Create list elts */
pool_get (tsm->list_pool, per_user_translation_list_elt);
else
{
pool_get (tsm->sessions, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
/* Create list elts */
pool_get (tsm->list_pool, per_user_translation_list_elt);
}
pool_get (sm->static_mappings, m);
- memset (m, 0, sizeof (*m));
+ clib_memset (m, 0, sizeof (*m));
m->tag = vec_dup (tag);
m->local_addr = l_addr;
m->external_addr = e_addr;
}
pool_get (sm->static_mappings, m);
- memset (m, 0, sizeof (*m));
+ clib_memset (m, 0, sizeof (*m));
m->tag = vec_dup (tag);
m->external_addr = e_addr;
m->external_port = e_port;
if (unformat (line_input, "local %U:%u probability %u",
unformat_ip4_address, &l_addr, &l_port, &probability))
{
- memset (&local, 0, sizeof (local));
+ clib_memset (&local, 0, sizeof (local));
local.addr = l_addr;
local.port = (u16) l_port;
local.probability = (u8) probability;
unformat_ip4_address, &l_addr, &l_port, &vrf_id,
&probability))
{
- memset (&local, 0, sizeof (local));
+ clib_memset (&local, 0, sizeof (local));
local.addr = l_addr;
local.port = (u16) l_port;
local.probability = (u8) probability;
ip46_address_t daddr;
nat64_db_bib_entry_t *bibe;
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ip->dst_address.as_u32;
/* *INDENT-OFF* */
foreach_snat_protocol
#undef _
default:
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
addr.ip4.as_u32 = out_addr->as_u32;
if (nat64_db_bib_entry_find (db, &addr, 0, proto, fib_index, 0))
return VNET_API_ERROR_INVALID_VALUE;
db->bib.bib_entries_num++;
- memset (bibe, 0, sizeof (*bibe));
+ clib_memset (bibe, 0, sizeof (*bibe));
bibe->in_addr.as_u64[0] = in_addr->as_u64[0];
bibe->in_addr.as_u64[1] = in_addr->as_u64[1];
bibe->in_port = in_port;
kv.key[2] = bibe_key.as_u64[2];
clib_bihash_add_del_24_8 (&db->bib.in2out, &kv, 1);
- memset (&bibe_key.addr, 0, sizeof (bibe_key.addr));
+ clib_memset (&bibe_key.addr, 0, sizeof (bibe_key.addr));
bibe_key.addr.ip4.as_u32 = bibe->out_addr.as_u32;
bibe_key.fib_index = 0;
bibe_key.port = bibe->out_port;
kv.key[2] = bibe_key.as_u64[2];
clib_bihash_add_del_24_8 (&db->bib.in2out, &kv, 0);
- memset (&bibe_key.addr, 0, sizeof (bibe_key.addr));
+ clib_memset (&bibe_key.addr, 0, sizeof (bibe_key.addr));
bibe_key.addr.ip4.as_u32 = bibe->out_addr.as_u32;
bibe_key.fib_index = 0;
bibe_key.port = bibe->out_port;
db->st.st_entries_num++;
- memset (ste, 0, sizeof (*ste));
+ clib_memset (ste, 0, sizeof (*ste));
ste->in_r_addr.as_u64[0] = in_r_addr->as_u64[0];
ste->in_r_addr.as_u64[1] = in_r_addr->as_u64[1];
ste->out_r_addr.as_u32 = out_r_addr->as_u32;
bibe->ses_num++;
/* create hash lookup */
- memset (&ste_key, 0, sizeof (ste_key));
+ clib_memset (&ste_key, 0, sizeof (ste_key));
ste_key.l_addr.as_u64[0] = bibe->in_addr.as_u64[0];
ste_key.l_addr.as_u64[1] = bibe->in_addr.as_u64[1];
ste_key.r_addr.as_u64[0] = ste->in_r_addr.as_u64[0];
kv.key[5] = ste_key.as_u64[5];
clib_bihash_add_del_48_8 (&db->st.in2out, &kv, 1);
- memset (&ste_key, 0, sizeof (ste_key));
+ clib_memset (&ste_key, 0, sizeof (ste_key));
ste_key.l_addr.ip4.as_u32 = bibe->out_addr.as_u32;
ste_key.r_addr.ip4.as_u32 = ste->out_r_addr.as_u32;
ste_key.l_port = bibe->out_port;
db->st.st_entries_num--;
/* delete hash lookup */
- memset (&ste_key, 0, sizeof (ste_key));
+ clib_memset (&ste_key, 0, sizeof (ste_key));
ste_key.l_addr.as_u64[0] = bibe->in_addr.as_u64[0];
ste_key.l_addr.as_u64[1] = bibe->in_addr.as_u64[1];
ste_key.r_addr.as_u64[0] = ste->in_r_addr.as_u64[0];
kv.key[5] = ste_key.as_u64[5];
clib_bihash_add_del_48_8 (&db->st.in2out, &kv, 0);
- memset (&ste_key, 0, sizeof (ste_key));
+ clib_memset (&ste_key, 0, sizeof (ste_key));
ste_key.l_addr.ip4.as_u32 = bibe->out_addr.as_u32;
ste_key.r_addr.ip4.as_u32 = ste->out_r_addr.as_u32;
ste_key.l_port = bibe->out_port;
break;
}
- memset (&ste_key, 0, sizeof (ste_key));
+ clib_memset (&ste_key, 0, sizeof (ste_key));
ste_key.l_addr.as_u64[0] = l_addr->as_u64[0];
ste_key.l_addr.as_u64[1] = l_addr->as_u64[1];
ste_key.r_addr.as_u64[0] = r_addr->as_u64[0];
if (ip46_address_is_equal (&bibe->in_addr, &ctx->src_addr)
&& bibe->fib_index == ctx->fib_index)
{
- memset (&saddr, 0, sizeof (saddr));
+ clib_memset (&saddr, 0, sizeof (saddr));
saddr.ip4.as_u32 = bibe->out_addr.as_u32;
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
nat64_extract_ip4 (&ctx->dst_addr, &daddr.ip4, ctx->fib_index);
if (nat64_db_st_entry_find
nat64_db_st_walk (db, IP_PROTOCOL_UDP, unk_proto_st_walk, &ctx);
/* Verify if out address is not already in use for protocol */
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
addr.ip4.as_u32 = ctx.out_addr.as_u32;
if (nat64_db_bib_entry_find (db, &addr, 0, proto, 0, 0))
ctx.out_addr.as_u32 = 0;
sport = udp->src_port = bibe->out_port;
nat64_compose_ip6 (&ip6->src_address, &bibe->out_addr, fib_index);
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ste->out_r_addr.as_u32;
bibe = 0;
dport = udp->dst_port = bibe->out_port;
nat64_compose_ip6 (&inner_ip6->dst_address, &bibe->out_addr, fib_index);
- memset (&saddr, 0, sizeof (saddr));
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&saddr, 0, sizeof (saddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
saddr.ip4.as_u32 = ste->out_r_addr.as_u32;
daddr.ip4.as_u32 = bibe->out_addr.as_u32;
nat64_db_st_walk (db, IP_PROTOCOL_UDP, unk_proto_st_walk, &ctx);
/* Verify if out address is not already in use for protocol */
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
addr.ip4.as_u32 = ctx.out_addr.as_u32;
if (nat64_db_bib_entry_find (db, &addr, 0, proto, 0, 0))
ctx.out_addr.as_u32 = 0;
nat64_compose_ip6 (&ip6->src_address, &bibe->out_addr, fib_index);
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ste->out_r_addr.as_u32;
bibe = 0;
nat64_compose_ip6 (&ip6->src_address, &bibe->out_addr, bibe->fib_index);
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ste->out_r_addr.as_u32;
bibe = 0;
sw_if_index = vnet_buffer (ctx->b)->sw_if_index[VLIB_RX];
fib_index = ip4_fib_table_get_index_for_sw_if_index (sw_if_index);
- memset (&saddr, 0, sizeof (saddr));
+ clib_memset (&saddr, 0, sizeof (saddr));
saddr.ip4.as_u32 = ip4->src_address.as_u32;
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ip4->dst_address.as_u32;
ste =
sw_if_index = vnet_buffer (ctx->b)->sw_if_index[VLIB_RX];
fib_index = ip4_fib_table_get_index_for_sw_if_index (sw_if_index);
- memset (&saddr, 0, sizeof (saddr));
+ clib_memset (&saddr, 0, sizeof (saddr));
saddr.ip4.as_u32 = ip4->src_address.as_u32;
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ip4->dst_address.as_u32;
if (icmp->type == ICMP6_echo_request || icmp->type == ICMP6_echo_reply)
fib_index =
fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP6, sw_if_index);
- memset (&saddr, 0, sizeof (saddr));
+ clib_memset (&saddr, 0, sizeof (saddr));
saddr.ip4.as_u32 = ip4->src_address.as_u32;
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ip4->dst_address.as_u32;
if (proto == IP_PROTOCOL_ICMP6)
sw_if_index = vnet_buffer (ctx->b)->sw_if_index[VLIB_RX];
fib_index = ip4_fib_table_get_index_for_sw_if_index (sw_if_index);
- memset (&saddr, 0, sizeof (saddr));
+ clib_memset (&saddr, 0, sizeof (saddr));
saddr.ip4.as_u32 = ip4->src_address.as_u32;
- memset (&daddr, 0, sizeof (daddr));
+ clib_memset (&daddr, 0, sizeof (daddr));
daddr.ip4.as_u32 = ip4->dst_address.as_u32;
ste =
{
ctx0.first_frag = 1;
- memset (&saddr0, 0, sizeof (saddr0));
+ clib_memset (&saddr0, 0, sizeof (saddr0));
saddr0.ip4.as_u32 = ip40->src_address.as_u32;
- memset (&daddr0, 0, sizeof (daddr0));
+ clib_memset (&daddr0, 0, sizeof (daddr0));
daddr0.ip4.as_u32 = ip40->dst_address.as_u32;
ste0 =
fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, vrf_id,
FIB_SOURCE_PLUGIN_HI);
pool_get (nm->sm, sm);
- memset (sm, 0, sizeof (*sm));
+ clib_memset (sm, 0, sizeof (*sm));
sm->l_addr.as_u64[0] = l_addr->as_u64[0];
sm->l_addr.as_u64[1] = l_addr->as_u64[1];
sm->e_addr.as_u64[0] = e_addr->as_u64[0];
vlib_worker_threads + worker_index + sm->first_worker_index;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT_WORKER_DETAILS + sm->msg_id_base);
rmp->context = context;
rmp->worker_index = htonl (worker_index);
nat_api_walk_ctx_t *ctx = arg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT_REASS_DETAILS + sm->msg_id_base);
rmp->context = ctx->context;
clib_memcpy (rmp->src_addr, &(reass->key.src), 4);
nat_api_walk_ctx_t *ctx = arg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT_REASS_DETAILS + sm->msg_id_base);
rmp->context = ctx->context;
clib_memcpy (rmp->src_addr, &(reass->key.src), 16);
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT44_ADDRESS_DETAILS + sm->msg_id_base);
clib_memcpy (rmp->ip_address, &(a->addr), 4);
if (a->fib_index != ~0)
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT44_INTERFACE_DETAILS + sm->msg_id_base);
rmp->sw_if_index = ntohl (i->sw_if_index);
rmp->is_inside = (nat_interface_is_inside (i)
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_INTERFACE_OUTPUT_FEATURE_DETAILS + sm->msg_id_base);
rmp->sw_if_index = ntohl (i->sw_if_index);
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
rmp->addr_only = is_addr_only_static_mapping (m);
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_STATIC_MAPPING_DETAILS + sm->msg_id_base);
rmp->addr_only = m->addr_only;
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
rmp->addr_only = is_addr_only_static_mapping (m);
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_IDENTITY_MAPPING_DETAILS + sm->msg_id_base);
rmp->addr_only = m->addr_only;
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_INTERFACE_ADDR_DETAILS + sm->msg_id_base);
rmp->sw_if_index = ntohl (sw_if_index);
ip4_main_t *im = &ip4_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT44_USER_DETAILS + sm->msg_id_base);
if (!pool_is_free_index (im->fibs, u->fib_index))
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_USER_SESSION_DETAILS + sm->msg_id_base);
clib_memcpy (rmp->outside_ip_address, (&s->out2in.addr), 4);
for (i = 0; i < addr_port_pair_num; i++)
{
ap = &addr_port_pairs[i];
- memset (&lb_addr_port, 0, sizeof (lb_addr_port));
+ clib_memset (&lb_addr_port, 0, sizeof (lb_addr_port));
clib_memcpy (&lb_addr_port.addr, ap->addr, 4);
lb_addr_port.port = clib_net_to_host_u16 (ap->port);
lb_addr_port.probability = ap->probability;
rmp =
vl_msg_api_alloc (sizeof (*rmp) +
(vec_len (m->locals) * sizeof (nat44_lb_addr_port_t)));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_LB_STATIC_MAPPING_DETAILS + sm->msg_id_base);
return;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT44_FORWARDING_IS_ENABLED_REPLY + sm->msg_id_base);
rmp->context = mp->context;
REPLY_MACRO2 (VL_API_NAT_DET_REVERSE_REPLY,
({
rmp->is_nat44 = 1;
- memset (rmp->in_addr, 0, 16);
+ clib_memset (rmp->in_addr, 0, 16);
clib_memcpy (rmp->in_addr, &in_addr, 4);
}))
/* *INDENT-ON* */
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_MAP_DETAILS + sm->msg_id_base);
rmp->is_nat44 = 1;
clib_memcpy (rmp->in_addr, &m->in_addr, 4);
snat_main_t *sm = &snat_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT_DET_SESSION_DETAILS + sm->msg_id_base);
rmp->in_port = s->in_port;
clib_memcpy (rmp->ext_addr, &s->out.ext_host_addr, 4);
if (!mp->is_nat44)
return;
- memset (&empty_ses, 0, sizeof (empty_ses));
+ clib_memset (&empty_ses, 0, sizeof (empty_ses));
clib_memcpy (&user_addr, mp->user_addr, 4);
dm = snat_det_map_by_user (sm, &user_addr);
if (!dm)
nat64_api_walk_ctx_t *ctx = arg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT64_POOL_ADDR_DETAILS + sm->msg_id_base);
clib_memcpy (rmp->address, &(a->addr), 4);
if (a->fib_index != ~0)
nat64_api_walk_ctx_t *ctx = arg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT64_INTERFACE_DETAILS + sm->msg_id_base);
rmp->sw_if_index = ntohl (i->sw_if_index);
rmp->is_inside = (nat_interface_is_inside (i)
return -1;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT64_BIB_DETAILS + sm->msg_id_base);
rmp->context = ctx->context;
clib_memcpy (rmp->i_addr, &(bibe->in_addr), 16);
return -1;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT64_ST_DETAILS + sm->msg_id_base);
rmp->context = ctx->context;
clib_memcpy (rmp->il_addr, &(bibe->in_addr), 16);
nat64_api_walk_ctx_t *ctx = arg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT64_PREFIX_DETAILS + sm->msg_id_base);
clib_memcpy (rmp->prefix, &(p->prefix), 16);
rmp->prefix_len = p->plen;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_DSLITE_ADDRESS_DETAILS + sm->msg_id_base);
clib_memcpy (rmp->ip_address, &(ap->addr), 4);
nat66_api_walk_ctx_t *ctx = arg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_NAT66_INTERFACE_DETAILS + sm->msg_id_base);
rmp->sw_if_index = ntohl (i->sw_if_index);
rmp->is_inside = nat_interface_is_inside (i);
vlib_get_combined_counter (&nm->session_counters, m - nm->sm, &vc);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
ntohs (VL_API_NAT66_STATIC_MAPPING_DETAILS + sm->msg_id_base);
clib_memcpy (rmp->local_ip_address, &m->l_addr, 16);
if (is_add)
{
pool_get (sm->det_maps, det_map);
- memset (det_map, 0, sizeof (*det_map));
+ clib_memset (det_map, 0, sizeof (*det_map));
det_map->in_addr.as_u32 = in_cmp.as_u32;
det_map->in_plen = in_plen;
det_map->out_addr.as_u32 = out_cmp.as_u32;
silm->enabled = e;
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
a.is_add = enable;
a.domain_id = domain_id ? domain_id : 1;
a.src_port = src_port ? src_port : UDP_DST_PORT_ipfix;
/* Use a control ping for synchronization */
M(NAT_CONTROL_PING, mp_ping);
- memset(mp->ip_address, 0, 16);
+ clib_memset(mp->ip_address, 0, 16);
clib_memcpy(mp->ip_address, &addr, 4);
mp->vrf_id = htonl(vrf_id);
S(mp_ping);
uword *t = NULL;
nsh_md2_ioam_main_t *hm = &nsh_md2_ioam_main;
fib_prefix_t key4;
- memset (&key4, 0, sizeof (key4));
+ clib_memset (&key4, 0, sizeof (key4));
key4.fp_proto = FIB_PROTOCOL_IP4;
key4.fp_addr.ip4.as_u32 = ip0->dst_address.as_u32;
t = hash_get_mem (hm->dst_by_ip4, &key4);
if (is_ipv4)
{
- memset (&fib_prefix, 0, sizeof (fib_prefix_t));
+ clib_memset (&fib_prefix, 0, sizeof (fib_prefix_t));
fib_prefix.fp_len = 32;
fib_prefix.fp_proto = FIB_PROTOCOL_IP4;
#define TRANSIT_UNIT_TEST_HACK 1
#ifdef TRANSIT_UNIT_TEST_HACK
- memset(&dst_addr, 0, sizeof(dst_addr));
+ clib_memset(&dst_addr, 0, sizeof(dst_addr));
dst_addr.ip4.as_u32 = clib_net_to_host_u32(0x14020102);
#endif
fib_prefix.fp_addr = dst_addr;
nsh_md2_ioam_dest_tunnels_t *t1;
fib_prefix_t key4, *key4_copy;
hash_pair_t *hp;
- memset (&key4, 0, sizeof (key4));
+ clib_memset (&key4, 0, sizeof (key4));
key4.fp_proto = FIB_PROTOCOL_IP4;
key4.fp_addr.ip4.as_u32 = fib_prefix.fp_addr.ip4.as_u32;
t = hash_get_mem (hm->dst_by_ip4, &key4);
return 0;
}
pool_get_aligned (hm->dst_tunnels, t1, CLIB_CACHE_LINE_BYTES);
- memset (t1, 0, sizeof (*t1));
+ clib_memset (t1, 0, sizeof (*t1));
t1->fp_proto = FIB_PROTOCOL_IP4;
t1->dst_addr.ip4.as_u32 = fib_prefix.fp_addr.ip4.as_u32;
key4_copy = clib_mem_alloc (sizeof (*key4_copy));
- memset(key4_copy, 0, sizeof(*key4_copy));
+ clib_memset(key4_copy, 0, sizeof(*key4_copy));
clib_memcpy (key4_copy, &key4, sizeof (*key4_copy));
hash_set_mem (hm->dst_by_ip4, key4_copy, t1 - hm->dst_tunnels);
/*
gm->unix_time_0 = (u32) time (0); /* Store starting time */
gm->vlib_time_0 = vlib_time_now (vm);
- memset (hm->counters, 0, sizeof (hm->counters));
+ clib_memset (hm->counters, 0, sizeof (hm->counters));
if (nsh_md2_register_option
(clib_host_to_net_u16 (0x9),
pool_get_aligned (nm->nsh_option_mappings, nsh_option,
CLIB_CACHE_LINE_BYTES);
- memset (nsh_option, 0, sizeof (*nsh_option));
+ clib_memset (nsh_option, 0, sizeof (*nsh_option));
nsh_option->option_id = nsh_option - nm->nsh_option_mappings;
key_copy = clib_mem_alloc (sizeof (*key_copy));
return -1; //TODO API_ERROR_INVALID_VALUE;
pool_get_aligned (nm->nsh_mappings, map, CLIB_CACHE_LINE_BYTES);
- memset (map, 0, sizeof (*map));
+ clib_memset (map, 0, sizeof (*map));
/* copy from arg structure */
map->nsp_nsi = a->map.nsp_nsi;
hash_pair_t *hp;
u32 nsp = 0, nsi = 0;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
key.transport_type = a->map.next_node;
key.transport_index = a->map.sw_if_index;
return -1; //TODO API_ERROR_INVALID_VALUE;
pool_get_aligned (nm->nsh_proxy_sessions, proxy, CLIB_CACHE_LINE_BYTES);
- memset (proxy, 0, sizeof (*proxy));
+ clib_memset (proxy, 0, sizeof (*proxy));
/* Nsi needs to minus 1 within NSH-Proxy */
nsp = (a->map.nsp_nsi >> NSH_NSP_SHIFT) & NSH_NSP_MASK;
return clib_error_return (0,
"must specific action: [encap-gre-intf <nn> | encap-vxlan-gpe-intf <nn> | encap-lisp-gpe-intf <nn> | encap-none <tx_sw_if_index> <rx_sw_if_index>]");
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
/* set args structure */
a->is_add = is_add;
len = MAX_NSH_HEADER_LEN;
}
vec_validate_aligned (rw, len - 1, CLIB_CACHE_LINE_BYTES);
- memset (rw, 0, len);
+ clib_memset (rw, 0, len);
nsh_base = (nsh_base_header_t *) rw;
nsh_base->ver_o_c = nsh_entry->nsh_base.ver_o_c;
return -1; // TODO VNET_API_ERROR_INVALID_VALUE;
pool_get_aligned (nm->nsh_entries, nsh_entry, CLIB_CACHE_LINE_BYTES);
- memset (nsh_entry, 0, sizeof (*nsh_entry));
+ clib_memset (nsh_entry, 0, sizeof (*nsh_entry));
/* copy from arg structure */
#define _(x) nsh_entry->nsh_base.x = a->nsh_entry.nsh_base.x;
nsp_nsi = (nsp << 8) | nsi;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
if (md_type == 1)
nsh_main_t *nm = &nsh_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs ((VL_API_NSH_ENTRY_DETAILS) + nm->msg_id_base);
rmp->ver_o_c = t->nsh_base.ver_o_c;
nsh_main_t *nm = &nsh_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs ((VL_API_NSH_MAP_DETAILS) + nm->msg_id_base);
rmp->nsp_nsi = htonl (t->nsp_nsi);
}
else
{
- memset (&key0, 0, sizeof (key0));
+ clib_memset (&key0, 0, sizeof (key0));
key0.transport_type = NSH_NODE_NEXT_ENCAP_VXLAN4;
key0.transport_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
}
else
{
- memset (&key1, 0, sizeof (key1));
+ clib_memset (&key1, 0, sizeof (key1));
key1.transport_type = NSH_NODE_NEXT_ENCAP_VXLAN4;
key1.transport_index = vnet_buffer (b1)->sw_if_index[VLIB_RX];
}
else
{
- memset (&key0, 0, sizeof (key0));
+ clib_memset (&key0, 0, sizeof (key0));
key0.transport_type = NSH_NODE_NEXT_ENCAP_VXLAN4;
key0.transport_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
do { \
vam->result_ready = 0; \
mp = vl_msg_api_alloc(sizeof(*mp)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T + sm->msg_id_base); \
mp->client_index = vam->my_client_index; \
} while(0);
do { \
vam->result_ready = 0; \
mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T + sm->msg_id_base); \
mp->client_index = vam->my_client_index; \
} while(0);
cached_key.raw = ~0;
cached_result.raw = ~0; /* warning be gone */
- memset (&pfx, 0, sizeof (pfx));
+ clib_memset (&pfx, 0, sizeof (pfx));
if (!is_ip6)
{
return VNET_API_ERROR_INVALID_DECAP_NEXT;
pool_get_aligned (pem->sessions, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
clib_memcpy (t->local_mac, hi->hw_address, 6);
clib_error_t *error = NULL;
/* Cant "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&client_ip, 0, sizeof client_ip);
+ clib_memset (&client_ip, 0, sizeof client_ip);
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->is_ip6 = ipv6_set;
u8 is_ipv6 = !ip46_address_is_ip4 (&t->client_ip);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_PPPOE_SESSION_DETAILS);
if (is_ipv6)
{
int ret;
/* Can't "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&client_ip, 0, sizeof client_ip);
+ clib_memset (&client_ip, 0, sizeof client_ip);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
/* Allocate and initialize memory block for local SID parameters */
ls_mem = clib_mem_alloc_aligned_at_offset (sizeof *ls_mem, 0, 0, 1);
- memset (ls_mem, 0, sizeof *ls_mem);
+ clib_memset (ls_mem, 0, sizeof *ls_mem);
*plugin_mem_p = ls_mem;
/* Set local SID parameters */
ls_mem = clib_mem_alloc_aligned_at_offset (sizeof *ls_mem, 0, 0, 1);
/* Set to zero the memory */
- memset (ls_mem, 0, sizeof *ls_mem);
+ clib_memset (ls_mem, 0, sizeof *ls_mem);
/* Our brand-new car is ready */
clib_memcpy (&ls_mem->nh_addr.ip6, &nh_addr.ip6,
/* Allocate and initialize memory block for local SID parameters */
ls_mem = clib_mem_alloc_aligned_at_offset (sizeof *ls_mem, 0, 0, 1);
- memset (ls_mem, 0, sizeof *ls_mem);
+ clib_memset (ls_mem, 0, sizeof *ls_mem);
*plugin_mem_p = ls_mem;
/* Set local SID parameters */
vl_api_stn_rules_details_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id =
clib_host_to_net_u16 (VL_API_STN_RULES_DETAILS + stn_main.msg_id_base);
}
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id =
ntohs (VL_API_SVS_PLUGIN_GET_VERSION_REPLY + svs_base_msg_id);
rmp->context = mp->context;
{
void *ptr;
ptr = clib_mem_alloc (n * size);
- memset (ptr, 0, sizeof (*ptr));
+ clib_memset (ptr, 0, sizeof (*ptr));
return ptr;
}
if (!(*ctx))
*ctx = clib_mem_alloc (sizeof (mbedtls_ctx_t));
- memset (*ctx, 0, sizeof (mbedtls_ctx_t));
+ clib_memset (*ctx, 0, sizeof (mbedtls_ctx_t));
(*ctx)->ctx.c_thread_index = thread_index;
(*ctx)->ctx.tls_ctx_engine = TLS_ENGINE_MBEDTLS;
(*ctx)->mbedtls_ctx_index = ctx - tm->ctx_pool[thread_index];
if (!(*evt))
*evt = clib_mem_alloc (sizeof (openssl_evt_t));
- memset (*evt, 0, sizeof (openssl_evt_t));
+ clib_memset (*evt, 0, sizeof (openssl_evt_t));
(*evt)->event_index = evt - tm->evt_pool[thread_index];
return ((*evt)->event_index);
}
if (!(*ctx))
*ctx = clib_mem_alloc (sizeof (openssl_ctx_t));
- memset (*ctx, 0, sizeof (openssl_ctx_t));
+ clib_memset (*ctx, 0, sizeof (openssl_ctx_t));
(*ctx)->ctx.c_thread_index = thread_index;
(*ctx)->ctx.tls_ctx_engine = TLS_ENGINE_OPENSSL;
(*ctx)->ctx.app_session_handle = SESSION_INVALID_HANDLE;
pool_get (om->lctx_pool, lctx);
- memset (lctx, 0, sizeof (openssl_listen_ctx_t));
+ clib_memset (lctx, 0, sizeof (openssl_listen_ctx_t));
lctx->openssl_lctx_index = lctx - om->lctx_pool;
return lctx->openssl_lctx_index;
}
unittest.c
tcp_test.c
bihash_test.c
+ string_test.c
)
--- /dev/null
+/*
+ * Copyright (c) 2018 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <vlib/vlib.h>
+#include <vppinfra/string.h>
+
+static int
+test_clib_memset (vlib_main_t * vm, unformat_input_t * input)
+{
+ u8 dst[64];
+ int i;
+ errno_t err;
+
+ vlib_cli_output (vm, "Test memset_s...");
+
+ err = memset_s (dst, ARRAY_LEN (dst), 0xfe, ARRAY_LEN (dst));
+
+ if (err != EOK)
+ return -1;
+
+ for (i = 0; i < ARRAY_LEN (dst); i++)
+ if (dst[i] != 0xFE)
+ return -1;
+
+ err = memset_s (dst, ARRAY_LEN (dst), 0xfa, ARRAY_LEN (dst) + 1);
+
+ if (err == EOK)
+ return -1;
+
+ return 0;
+}
+
+static int
+test_memcpy (vlib_main_t * vm, unformat_input_t * input)
+{
+ char src[64], dst[64];
+ int i;
+ errno_t err;
+
+ vlib_cli_output (vm, "Test memcpy_s...");
+
+ for (i = 0; i < ARRAY_LEN (src); i++)
+ src[i] = i + 1;
+
+ /* Typical case */
+ err = memcpy_s (dst, sizeof (dst), src, sizeof (src));
+
+ if (err != EOK)
+ return -1;
+
+ /* This better not fail but check anyhow */
+ for (i = 0; i < ARRAY_LEN (dst); i++)
+ if (src[i] != dst[i])
+ return -1;
+
+ /* Size fail */
+ err = memcpy_s (dst + 1, sizeof (dst) - 1, src, sizeof (src));
+
+ if (err == EOK)
+ return -1;
+
+ /* overlap fail */
+ err = memcpy_s (dst, sizeof (dst), dst + 1, sizeof (dst) - 1);
+
+ if (err == EOK)
+ return -1;
+
+ /* Zero length copy */
+ err = memcpy_s (0, sizeof (dst), src, 0);
+
+ if (err != EOK)
+ return -1;
+
+ /* OK, seems to work */
+ return 0;
+}
+
+static clib_error_t *
+string_test_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd_arg)
+{
+ int res = 0;
+ u8 t_memcpy = 0;
+ u8 t_clib_memset = 0;
+ u8 specific_test;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "memcpy_s"))
+ t_memcpy = 1;
+ else if (unformat (input, "memset_s"))
+ t_clib_memset = 1;
+ break;
+ }
+
+ specific_test = t_memcpy + t_clib_memset;
+
+ if (specific_test == 0)
+ {
+ res = test_memcpy (vm, input);
+ res += test_clib_memset (vm, input);
+ goto done;
+ }
+
+ if (t_memcpy)
+ res = test_memcpy (vm, input);
+ else if (t_clib_memset)
+ res = test_clib_memset (vm, input);
+
+done:
+ if (res)
+ vlib_cli_output (vm, "String unit test(s) failed...");
+ else
+ vlib_cli_output (vm, "String unit test(s) OK...");
+ return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (string_test_command, static) =
+{
+ .path = "test string",
+ .short_help = "string library tests",
+ .function = string_test_command_fn,
+};
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
return tcp_test_scoreboard_replay (vm, input);
}
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->snd_una = 0;
tc->snd_una_max = 1000;
}
}
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
/*
* Add odd sack block pairs
f = svm_fifo_create (fifo_size);
/* Paint fifo data vector with -1's */
- memset (f->data, 0xFF, fifo_size);
+ clib_memset (f->data, 0xFF, fifo_size);
return f;
}
* Allocate fake session and connection 1
*/
pool_get (smm->sessions[0], s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
s->session_index = sidx = s - smm->sessions[0];
pool_get (tm->connections[0], tc);
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->connection.c_index = tc - tm->connections[0];
tc->connection.s_index = s->session_index;
s->connection_index = tc->connection.c_index;
* Allocate fake session and connection 2
*/
pool_get (session_manager_main.sessions[0], s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
s->session_index = s - smm->sessions[0];
pool_get (tm->connections[0], tc);
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->connection.c_index = tc - tm->connections[0];
tc->connection.s_index = s->session_index;
s->connection_index = tc->connection.c_index;
remote_port = clib_host_to_net_u16 (11234);
pool_get (tm->connections[0], tc0);
- memset (tc0, 0, sizeof (*tc0));
+ clib_memset (tc0, 0, sizeof (*tc0));
tc0->state = TCP_STATE_ESTABLISHED;
tc0->rcv_las = 1;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "%U", unformat_vlib_pci_addr, &args.addr))
if (error)
return error;
- memset (vd->dma, 0, sizeof (*vd->dma));
+ clib_memset (vd->dma, 0, sizeof (*vd->dma));
q = &vd->dma->queues;
q->tx.cfg.desc_address = vmxnet3_dma_addr (vm, vd, txq->tx_desc);
vec_validate_aligned (vd->rxqs, qid, CLIB_CACHE_LINE_BYTES);
rxq = vec_elt_at_index (vd->rxqs, qid);
- memset (rxq, 0, sizeof (*rxq));
+ clib_memset (rxq, 0, sizeof (*rxq));
rxq->size = qsz;
for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
{
512);
if (error)
return error;
- memset (rxq->rx_desc[rid], 0, qsz * sizeof (*rxq->rx_desc[rid]));
+ clib_memset (rxq->rx_desc[rid], 0, qsz * sizeof (*rxq->rx_desc[rid]));
}
rxq->rx_comp = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
qsz * sizeof (*rxq->rx_comp),
512);
if (error)
return error;
- memset (rxq->rx_comp, 0, qsz * sizeof (*rxq->rx_comp));
+ clib_memset (rxq->rx_comp, 0, qsz * sizeof (*rxq->rx_comp));
for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
{
vmxnet3_rx_ring *ring;
vec_validate_aligned (vd->txqs, qid, CLIB_CACHE_LINE_BYTES);
txq = vec_elt_at_index (vd->txqs, qid);
- memset (txq, 0, sizeof (*txq));
+ clib_memset (txq, 0, sizeof (*txq));
txq->size = qsz;
txq->tx_desc = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
qsz * sizeof (*txq->tx_desc),
512);
if (error)
return error;
- memset (txq->tx_desc, 0, qsz * sizeof (*txq->tx_desc));
+ clib_memset (txq->tx_desc, 0, qsz * sizeof (*txq->tx_desc));
txq->tx_comp = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
qsz * sizeof (*txq->tx_comp),
512);
if (error)
return error;
- memset (txq->tx_comp, 0, qsz * sizeof (*txq->tx_comp));
+ clib_memset (txq->tx_comp, 0, qsz * sizeof (*txq->tx_comp));
vec_validate_aligned (txq->tx_ring.bufs, txq->size, CLIB_CACHE_LINE_BYTES);
txq->tx_ring.gen = VMXNET3_TXF_GEN;
txq->tx_comp_ring.gen = VMXNET3_TXCF_GEN;
vlib_physmem_free (vm, vmxm->physmem_region, vd->dma);
clib_error_free (vd->error);
- memset (vd, 0, sizeof (*vd));
+ clib_memset (vd, 0, sizeof (*vd));
pool_put (vmxm->devices, vd);
}
vmxnet3_create_if_args_t args;
int rv;
- memset (&args, 0, sizeof (vmxnet3_create_if_args_t));
+ clib_memset (&args, 0, sizeof (vmxnet3_create_if_args_t));
args.enable_elog = ntohl (mp->enable_elog);
args.addr.as_u32 = ntohl (mp->pci_addr);
hwif = vnet_get_sup_hw_interface (vnm, swif->sw_if_index);
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_VMXNET3_DETAILS + vmxm->msg_id_base);
mp->context = context;
int ret;
u32 x[4];
- memset (&args, 0, sizeof (vmxnet3_create_if_args_t));
+ clib_memset (&args, 0, sizeof (vmxnet3_create_if_args_t));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
pthread_condattr_t cattr;
q = (svm_queue_t *) base;
- memset (q, 0, sizeof (*q));
+ clib_memset (q, 0, sizeof (*q));
q->elsize = elsize;
q->maxsize = nels;
q->producer_evtfd = -1;
q->consumer_evtfd = -1;
- memset (&attr, 0, sizeof (attr));
- memset (&cattr, 0, sizeof (cattr));
+ clib_memset (&attr, 0, sizeof (attr));
+ clib_memset (&cattr, 0, sizeof (cattr));
if (pthread_mutexattr_init (&attr))
clib_unix_warning ("mutexattr_init");
q = clib_mem_alloc_aligned (sizeof (svm_queue_t)
+ nels * elsize, CLIB_CACHE_LINE_BYTES);
- memset (q, 0, sizeof (*q));
+ clib_memset (q, 0, sizeof (*q));
q = svm_queue_init (q, nels, elsize);
q->consumer_pid = consumer_pid;
sh = clib_mem_alloc_aligned (sizeof (*sh), CLIB_CACHE_LINE_BYTES);
ssvm->sh = sh;
- memset (sh, 0, sizeof (*sh));
+ clib_memset (sh, 0, sizeof (*sh));
sh->heap = heap;
sh->type = SSVM_SEGMENT_PRIVATE;
ASSERT (rp);
int rv;
- memset (rp, 0, sizeof (*rp));
+ clib_memset (rp, 0, sizeof (*rp));
if (pthread_mutexattr_init (&attr))
clib_unix_warning ("mutexattr_init");
{
svm_map_region_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->root_path = 0;
a->name = SVM_GLOBAL_REGION_NAME;
a->baseva = svm_get_global_region_base_va ();
{
svm_map_region_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->root_path = root_path;
a->name = SVM_GLOBAL_REGION_NAME;
a->baseva = svm_get_global_region_base_va ();
{
svm_map_region_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->root_path = root_path;
a->name = SVM_GLOBAL_REGION_NAME;
a->baseva = svm_get_global_region_base_va ();
#endif
dummy_fifo = svm_fifo_create (f->nitems);
- memset (f->data, 0xFF, f->nitems);
+ clib_memset (f->data, 0xFF, f->nitems);
vec_validate (data, f->nitems);
for (i = 0; i < vec_len (data); i++)
if (f == 0)
return 0;
- memset (f, 0, sizeof (*f));
+ clib_memset (f, 0, sizeof (*f));
f->nitems = data_size_in_bytes;
f->ooos_list_head = OOO_SEGMENT_INVALID_INDEX;
f->ct_session_index = SVM_FIFO_INVALID_SESSION_INDEX;
first_copy_bytes = ((nitems - f->tail) < total_copy_bytes)
? (nitems - f->tail) : total_copy_bytes;
- clib_memcpy (&f->data[f->tail], copy_from_here, first_copy_bytes);
+ _clib_memcpy (&f->data[f->tail], copy_from_here, first_copy_bytes);
f->tail += first_copy_bytes;
f->tail = (f->tail == nitems) ? 0 : f->tail;
second_copy_bytes = total_copy_bytes - first_copy_bytes;
if (second_copy_bytes)
{
- clib_memcpy (&f->data[f->tail], copy_from_here + first_copy_bytes,
- second_copy_bytes);
+ _clib_memcpy (&f->data[f->tail], copy_from_here + first_copy_bytes,
+ second_copy_bytes);
f->tail += second_copy_bytes;
f->tail = (f->tail == nitems) ? 0 : f->tail;
}
first_copy_bytes = ((nitems - normalized_offset) < total_copy_bytes)
? (nitems - normalized_offset) : total_copy_bytes;
- clib_memcpy (&f->data[normalized_offset], copy_from_here, first_copy_bytes);
+ _clib_memcpy (&f->data[normalized_offset], copy_from_here,
+ first_copy_bytes);
/* Number of bytes in second copy segment, if any */
second_copy_bytes = total_copy_bytes - first_copy_bytes;
ASSERT (normalized_offset == 0);
- clib_memcpy (&f->data[normalized_offset],
- copy_from_here + first_copy_bytes, second_copy_bytes);
+ _clib_memcpy (&f->data[normalized_offset],
+ copy_from_here + first_copy_bytes, second_copy_bytes);
}
return (0);
first_chunk = f->nitems - f->head;
ASSERT (len <= f->nitems);
if (len <= first_chunk)
- clib_memcpy (&f->data[f->head], data, len);
+ _clib_memcpy (&f->data[f->head], data, len);
else
{
- clib_memcpy (&f->data[f->head], data, first_chunk);
- clib_memcpy (&f->data[0], data + first_chunk, len - first_chunk);
+ _clib_memcpy (&f->data[f->head], data, first_chunk);
+ _clib_memcpy (&f->data[0], data + first_chunk, len - first_chunk);
}
}
#endif
/* Number of bytes in first copy segment */
first_copy_bytes = ((nitems - f->head) < total_copy_bytes)
? (nitems - f->head) : total_copy_bytes;
- clib_memcpy (copy_here, &f->data[f->head], first_copy_bytes);
+ _clib_memcpy (copy_here, &f->data[f->head], first_copy_bytes);
f->head += first_copy_bytes;
f->head = (f->head == nitems) ? 0 : f->head;
second_copy_bytes = total_copy_bytes - first_copy_bytes;
if (second_copy_bytes)
{
- clib_memcpy (copy_here + first_copy_bytes,
- &f->data[f->head], second_copy_bytes);
+ _clib_memcpy (copy_here + first_copy_bytes,
+ &f->data[f->head], second_copy_bytes);
f->head += second_copy_bytes;
f->head = (f->head == nitems) ? 0 : f->head;
}
first_copy_bytes =
((nitems - real_head) < total_copy_bytes) ?
(nitems - real_head) : total_copy_bytes;
- clib_memcpy (copy_here, &f->data[real_head], first_copy_bytes);
+ _clib_memcpy (copy_here, &f->data[real_head], first_copy_bytes);
/* Number of bytes in second copy segment, if any */
second_copy_bytes = total_copy_bytes - first_copy_bytes;
if (second_copy_bytes)
{
- clib_memcpy (copy_here + first_copy_bytes, &f->data[0],
- second_copy_bytes);
+ _clib_memcpy (copy_here + first_copy_bytes, &f->data[0],
+ second_copy_bytes);
}
}
return total_copy_bytes;
oldheap = ssvm_push_heap (sh);
fsh = clib_mem_alloc (sizeof (*fsh));
- memset (fsh, 0, sizeof (*fsh));
+ clib_memset (fsh, 0, sizeof (*fsh));
s->h = sh->opaque[0] = fsh;
ssvm_pop_heap (oldheap);
/* Allocate a fresh segment */
pool_get (sm->segments, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
s->ssvm.ssvm_size = a->segment_size;
s->ssvm.i_am_master = 1;
u32 pagesize = clib_mem_get_page_size ();
pool_get (sm->segments, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
rnd_size = (a->segment_size + (pagesize - 1)) & ~pagesize;
sh = clib_mem_alloc_aligned (sizeof (*sh), CLIB_CACHE_LINE_BYTES);
s->ssvm.sh = sh;
- memset (sh, 0, sizeof (*sh));
+ clib_memset (sh, 0, sizeof (*sh));
sh->heap = heap;
svm_fifo_segment_init (s);
/* Allocate a fresh segment */
pool_get (sm->segments, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
s->ssvm.ssvm_size = a->segment_size;
s->ssvm.my_pid = getpid ();
svm_fifo_segment_main_t *sm = &svm_fifo_segment_main;
ssvm_delete (&s->ssvm);
- memset (s, 0xfe, sizeof (*s));
+ clib_memset (s, 0xfe, sizeof (*s));
pool_put (sm->segments, s);
}
{
fsh->free_fifos[freelist_index] = f->next;
/* (re)initialize the fifo, as in svm_fifo_create */
- memset (f, 0, sizeof (*f));
+ clib_memset (f, 0, sizeof (*f));
f->nitems = data_size_in_bytes;
f->ooos_list_head = OOO_SEGMENT_INVALID_INDEX;
f->ct_session_index = SVM_FIFO_INVALID_SESSION_INDEX;
{
svmdb_value_t *newvalue;
pool_get (shm->values, newvalue);
- memset (newvalue, 0, sizeof (*newvalue));
+ clib_memset (newvalue, 0, sizeof (*newvalue));
newvalue->elsize = elsize;
vec_alloc (newvalue->value, vec_len (val) * elsize);
clib_memcpy (newvalue->value, val, vec_len (val) * elsize);
h = shm->namespaces[SVMDB_NAMESPACE_VEC];
pool_get (shm->values, newvalue);
- memset (newvalue, 0, sizeof (*newvalue));
+ clib_memset (newvalue, 0, sizeof (*newvalue));
newvalue->elsize = 1;
vec_alloc (newvalue->value, nbytes);
_vec_len (newvalue->value) = nbytes;
svmdbtool_main_t *sm = &svmdbtool_main;
svmdb_map_args_t *ma = &sm->map_args;
- memset (ma, 0, sizeof (*ma));
+ clib_memset (ma, 0, sizeof (*ma));
ma->root_path = chroot_path;
ma->size = sm->size;
ma->uid = sm->uid;
ma = map_arg_setup (chroot_path);
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.sa_sigaction = sigaction_handler;
sa.sa_flags = SA_SIGINFO;
if (sigaction (SIGUSR2, &sa, 0) < 0)
return;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
c = svmdb_map (ma);
{
clib_warning ("rp->mutex LOCKED by pid %d, tag %d, cleared...",
rp->mutex_owner_pid, rp->mutex_owner_tag);
- memset (&rp->mutex, 0, sizeof (rp->mutex));
+ clib_memset (&rp->mutex, 0, sizeof (rp->mutex));
}
else
for (i = 0; i < vec_len (svm_names); i++)
{
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
a.root_path = chroot_path;
a.name = (char *) svm_names[i];
fformat (stdout, "Checking %s region...\n", a.name);
{
clib_warning ("root_rp->mutex LOCKED by pid %d, tag %d, cleared...",
root_rp->mutex_owner_pid, root_rp->mutex_owner_tag);
- memset (&root_rp->mutex, 0, sizeof (root_rp->mutex));
+ clib_memset (&root_rp->mutex, 0, sizeof (root_rp->mutex));
goto out;
}
else
u8 *retrieved_data = 0;
clib_error_t *error = 0;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = "fifo-test1";
a->segment_size = 256 << 10;
u8 *retrieved_data = 0;
int i;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = "fifo-test1";
a->segment_size = 256 << 10;
int rv;
int i;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = "fifo-test1";
a->segment_size = 256 << 10;
u32 *recovered_data = 0;
int i;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = "fifo-test1";
a->segment_size = 256 << 10;
u8 *retrieved_data = 0;
int i;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = "fifo-test1";
void *oldheap;
int i;
- memset (ssvm, 0, sizeof (*ssvm));
+ clib_memset (ssvm, 0, sizeof (*ssvm));
ssvm->ssvm_size = 1 << 20;
ssvm->i_am_master = 1;
int lp = 0x15, rp = 0x14;
b = clib_mem_alloc (buff_len);
- memset((u8 *)b, 0, buff_len);
+ clib_memset((u8 *)b, 0, buff_len);
b->current_length = buff_len;
b->current_data = sizeof(udp_header_t) + sizeof(ip4_header_t) +
sizeof(ecm_hdr_t) + 1;
ip4_header_t * ih = (ip4_header_t *) (lh + 1);
/* clear ip checksum */
- memset((u8 *)ih + 10, 0, 2);
+ clib_memset((u8 *)ih + 10, 0, 2);
u8 expected_ip4_hdr[] = {
0x45, /* version; IHL */
udp_header_t * uh = (udp_header_t *) (ih + 1);
/* clear udp checksum */
- memset((u8 *)uh + 6, 0, 2);
+ clib_memset((u8 *)uh + 6, 0, 2);
u8 expected_udp_hdr[] = {
0x00, 0x15, /* src port */
u32 buff_len = 500;
b = clib_mem_alloc (buff_len);
- memset((u8 *)b, 0, buff_len);
+ clib_memset((u8 *)b, 0, buff_len);
u8 map_reply_records[] = {
/* 1. record */
u8 rloc_probe_set = 0;
u64 nonce = 0;
map_request_hdr_t * h = 0;
- memset (deid, 0, sizeof (deid[0]));
- memset (seid, 0, sizeof (seid[0]));
+ clib_memset (deid, 0, sizeof (deid[0]));
+ clib_memset (seid, 0, sizeof (seid[0]));
gid_address_type (seid) = GID_ADDR_IP_PREFIX;
ip_address_t * ip_addr = &gid_address_ip (seid);
generate_rlocs (gid_address_t **rlocs, u32 * count)
{
gid_address_t gid_addr_data, * gid_addr = &gid_addr_data;
- memset (gid_addr, 0, sizeof (gid_addr[0]));
+ clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
ip_address_t * addr = &gid_address_ip (gid_addr);
gid_address_type (gid_addr) = GID_ADDR_IP_PREFIX;
u32 rloc_count_parse = 0;
u8 * data = clib_mem_alloc(500);
- memset(data, 0, 500);
+ clib_memset(data, 0, 500);
b = (vlib_buffer_t *) data;
generate_rlocs (&rlocs_decode, &rloc_count_parse);
vec_add1 (rlocs, g);
u8 * data = clib_mem_alloc (500);
- memset (data, 0, 500);
+ clib_memset (data, 0, 500);
h = build_map_request (lcm, (vlib_buffer_t *) data, rlocs);
/* clear Nonce to simplify comparison */
- memset ((u8 *)h + 4, 0, 8);
+ clib_memset ((u8 *)h + 4, 0, 8);
u8 expected_data[] =
{
u32 rloc_count = 0;
u8 * data = clib_mem_alloc(500);
- memset(data, 0, 500);
+ clib_memset(data, 0, 500);
generate_rlocs (&rlocs, &rloc_count);
h = build_map_request (lcm, (vlib_buffer_t *) data, rlocs);
/* clear Nonce to simplify comparison */
- memset((u8 *)h + 4, 0, 8);
+ clib_memset((u8 *)h + 4, 0, 8);
print_map_request(h);
mapping_t * records = build_test_map_records ();
u8 * data = clib_mem_alloc(500);
- memset(data, 0, 500);
+ clib_memset(data, 0, 500);
b = (vlib_buffer_t *) data;
lisp_msg_put_map_register (b, records, 1 /* want map notify */,
free_test_map_records (records);
/* clear Nonce to simplify comparison */
- memset((u8 *)b->data + 4, 0, 8);
+ clib_memset((u8 *)b->data + 4, 0, 8);
/* clear authentication data */
- memset ((u8 *)b->data + 16, 0, 20);
+ clib_memset ((u8 *)b->data + 16, 0, 20);
u8 expected_data[] = {
0x30, 0x00, 0x01, 0x01, /* type; rsvd; want notify; REC count */
vlib_buffer_t *b;
u8 *buf_data = clib_mem_alloc(500);
- memset (buf_data, 0, 500);
+ clib_memset (buf_data, 0, 500);
b = (vlib_buffer_t *)buf_data;
u8 * p = vlib_buffer_put_uninit (b, data_len);
u32 buff_len = 500;
b = clib_mem_alloc (buff_len);
- memset ((u8 *)b, 0, buff_len);
+ clib_memset ((u8 *)b, 0, buff_len);
u8 map_reply_records[] =
{
clib_error_t * error = 0;
u8 * b = clib_mem_alloc(500);
- memset(b, 0, 500);
+ clib_memset(b, 0, 500);
gid_address_t g =
{
gid_address_t _gid_addr, * gid_addr = &_gid_addr;
gid_address_t _gid_addr_copy, * copy = &_gid_addr_copy;
- memset (gid_addr, 0, sizeof (gid_addr[0]));
- memset (copy, 0, sizeof (copy[0]));
+ clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
+ clib_memset (copy, 0, sizeof (copy[0]));
u8 data[] =
{
gid_address_t _gid_addr, * gid_addr = &_gid_addr;
gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
- memset (gid_addr, 0, sizeof (gid_addr[0]));
- memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
+ clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
+ clib_memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
u8 data[] =
{
gid_address_t _gid_addr, * gid_addr = &_gid_addr;
gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
- memset (gid_addr, 0, sizeof (gid_addr[0]));
- memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
+ clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
+ clib_memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
u8 data[] =
{
clib_error_t * error = 0;
u8 * b = clib_mem_alloc(500);
- memset(b, 0, 500);
+ clib_memset(b, 0, 500);
gid_address_t g =
{
clib_error_t * error = 0;
u8 * b = clib_mem_alloc(500);
- memset(b, 0, 500);
+ clib_memset(b, 0, 500);
gid_address_t g =
{
{
clib_error_t * error = 0;
u8 * b = clib_mem_alloc (500);
- memset (b, 0, 500);
+ clib_memset (b, 0, 500);
fid_address_t src =
{
_assert (0 == memcmp (expected_data, b, sizeof (expected_data)));
gid_address_t p;
- memset (&p, 0, sizeof (p));
+ clib_memset (&p, 0, sizeof (p));
_assert (write_len == gid_address_parse (b, &p));
_assert (0 == gid_address_cmp (&g, &p));
done:
clib_error_t * error = 0;
u8 * b = clib_mem_alloc (500);
- memset (b, 0, 500);
+ clib_memset (b, 0, 500);
fid_address_t src =
{
_assert (0 == memcmp (expected_data, b, sizeof (expected_data)));
gid_address_t p;
- memset (&p, 0, sizeof (p));
+ clib_memset (&p, 0, sizeof (p));
_assert (write_len == gid_address_parse (b, &p));
_assert (0 == gid_address_cmp (&g, &p));
done:
ip_prefix_t ippref_data, * ippref = &ippref_data;
u8 * b = clib_mem_alloc(500);
- memset(b, 0, 500);
+ clib_memset(b, 0, 500);
ip_prefix_version (ippref) = IP4;
ip_prefix_len (ippref) = 9;
vl_api_application_tls_key_add_t *key_mp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
bmp->client_index = em->my_client_index;
vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
cert_mp = vl_msg_api_alloc (sizeof (*cert_mp) + test_srv_crt_rsa_len);
- memset (cert_mp, 0, sizeof (*cert_mp));
+ clib_memset (cert_mp, 0, sizeof (*cert_mp));
cert_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_CERT_ADD);
cert_mp->client_index = em->my_client_index;
cert_mp->context = ntohl (0xfeedface);
vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & cert_mp);
key_mp = vl_msg_api_alloc (sizeof (*key_mp) + test_srv_key_rsa_len);
- memset (key_mp, 0, sizeof (*key_mp) + test_srv_key_rsa_len);
+ clib_memset (key_mp, 0, sizeof (*key_mp) + test_srv_key_rsa_len);
key_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_KEY_ADD);
key_mp->client_index = em->my_client_index;
key_mp->context = ntohl (0xfeedface);
{
vl_api_application_detach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
bmp->client_index = em->my_client_index;
svm_fifo_segment_create_args_t _a, *a = &_a;
int rv;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = (char *) name;
a->segment_type = type;
svm_fifo_segment_create_args_t _a, *a = &_a;
int rv;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = (char *) mp->segment_name;
a->segment_size = mp->segment_size;
/* Attach to the segment vpp created */
{
vl_api_connect_uri_t *cmp;
cmp = vl_msg_api_alloc (sizeof (*cmp));
- memset (cmp, 0, sizeof (*cmp));
+ clib_memset (cmp, 0, sizeof (*cmp));
cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
cmp->client_index = em->my_client_index;
{
vl_api_disconnect_session_t *dmp;
dmp = vl_msg_api_alloc (sizeof (*dmp));
- memset (dmp, 0, sizeof (*dmp));
+ clib_memset (dmp, 0, sizeof (*dmp));
dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
dmp->client_index = em->my_client_index;
dmp->handle = s->vpp_session_handle;
{
client_send_disconnect (em, s);
pool_put (em->sessions, s);
- memset (s, 0xfe, sizeof (*s));
+ clib_memset (s, 0xfe, sizeof (*s));
return 0;
}
*/
pool_get (em->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - em->sessions;
rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
{
vl_api_bind_uri_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
bmp->client_index = em->my_client_index;
vl_api_unbind_uri_t *ump;
ump = vl_msg_api_alloc (sizeof (*ump));
- memset (ump, 0, sizeof (*ump));
+ clib_memset (ump, 0, sizeof (*ump));
ump->_vl_msg_id = ntohs (VL_API_UNBIND_URI);
ump->client_index = em->my_client_index;
for (i = 0; i < 200000; i++)
{
pool_get (em->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
}
for (i = 0; i < 200000; i++)
pool_put_index (em->sessions, i);
clib_mem_init_thread_safe (0, 256 << 20);
- memset (em, 0, sizeof (*em));
+ clib_memset (em, 0, sizeof (*em));
em->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
em->my_pid = getpid ();
em->configured_segment_size = 1 << 20;
{
vl_api_application_attach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
bmp->client_index = utm->my_client_index;
{
vl_api_application_detach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
bmp->client_index = utm->my_client_index;
tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - utm->sessions;
session->session_index = session_index;
tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - utm->sessions;
rx_fifo->client_session_index = session_index;
{
vl_api_connect_uri_t *cmp;
cmp = vl_msg_api_alloc (sizeof (*cmp));
- memset (cmp, 0, sizeof (*cmp));
+ clib_memset (cmp, 0, sizeof (*cmp));
cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
cmp->client_index = utm->my_client_index;
tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - utm->sessions;
rx_fifo->client_session_index = session_index;
u8 *seg_name;
int rv;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = (char *) mp->segment_name;
a->segment_size = mp->segment_size;
/* Attach to the segment vpp created */
vl_api_unbind_uri_t *ump;
ump = vl_msg_api_alloc (sizeof (*ump));
- memset (ump, 0, sizeof (*ump));
+ clib_memset (ump, 0, sizeof (*ump));
ump->_vl_msg_id = ntohs (VL_API_UNBIND_URI);
ump->client_index = utm->my_client_index;
vl_api_bind_uri_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
bmp->client_index = utm->my_client_index;
for (i = 0; i < 200000; i++)
{
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
}
for (i = 0; i < 200000; i++)
pool_put_index (utm->sessions, i);
return error;
/* Put in new null terminated string. */
- memset (s->contents, 0, vec_len (s->contents));
+ clib_memset (s->contents, 0, vec_len (s->contents));
clib_memcpy (s->contents, interp, strlen (interp));
return 0;
unformat_input_t i;
clib_error_t * error = 0;
- memset (tm, 0, sizeof (tm[0]));
+ clib_memset (tm, 0, sizeof (tm[0]));
unformat_init_command_line (&i, argv);
while (unformat_check_input (&i) != UNFORMAT_END_OF_INPUT)
if (s_color != NULL ) {
gdk_colormap_free_colors(gtk_widget_get_colormap(da),
s_color, g_npids);
- memset(s_color, 0, sizeof(GdkColor) * g_npids);
+ clib_memset(s_color, 0, sizeof(GdkColor) * g_npids);
} else {
/*
* First time through: allocate the array to hold the GCs.
if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
return(0);
- memset(&edsh, 0, sizeof(edsh));
+ clib_memset(&edsh, 0, sizeof(edsh));
strcpy(edsh.string_table_name, "FileStrtab");
edsh.number_of_event_definitions = ntohl(vec_len(the_event_definitions));
if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
return(0);
- memset(&eh, 0, sizeof(eh));
+ clib_memset(&eh, 0, sizeof(eh));
strcpy(eh.string_table_name, "FileStrtab");
eh.number_of_events = ntohl(number_of_events);
eh.clock_ticks_per_second = ntohl(clock_ticks_per_second);
if (fwrite(&sh, sizeof(sh), 1, ofp) != 1)
return(0);
- memset(&tdsh, 0, sizeof(tdsh));
+ clib_memset(&tdsh, 0, sizeof(tdsh));
strcpy(tdsh.string_table_name, "FileStrtab");
tdsh.number_of_track_definitions = ntohl(vec_len(the_tracks));
u32 user_instance = 0;
int ret;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
int ip6_address_set = 0;
int ret;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
u8 sw_if_index_set = 0;
int ret;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
int ret;
u32 rx_ring_sz = 0, tx_ring_sz = 0;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
u8 lb;
u8 mode_is_set = 0;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
lb = BOND_LB_L2;
/* Parse args required to build the message */
mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
- memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
- memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
+ clib_memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
+ clib_memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
}
else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
{
- memset (&v4_src_address, 0, sizeof (v4_src_address));
+ clib_memset (&v4_src_address, 0, sizeof (v4_src_address));
grp_address_length = 32;
address_set = 1;
is_ipv6 = 0;
}
else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
{
- memset (&v6_src_address, 0, sizeof (v6_src_address));
+ clib_memset (&v6_src_address, 0, sizeof (v6_src_address));
grp_address_length = 128;
address_set = 1;
is_ipv6 = 1;
ip6_address_t v6address;
int ret;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
}
else
{
- /* mp->is_ipv6 = 0; via memset in M macro above */
+ /* mp->is_ipv6 = 0; via clib_memset in M macro above */
clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
}
u32 fib_table = ~(u32) 0;
ip6_address_t nh_addr6;
ip4_address_t nh_addr4;
- memset (&nh_addr6, 0, sizeof (ip6_address_t));
- memset (&nh_addr4, 0, sizeof (ip4_address_t));
+ clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
+ clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
bool nexthop_set = 0;
tcp = (tcp_header_t *) mask;
-#define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
+#define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
foreach_tcp_proto_field;
#undef _
udp = (udp_header_t *) mask;
-#define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
+#define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
foreach_udp_proto_field;
#undef _
ip = (ip4_header_t *) mask;
-#define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
+#define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
foreach_ip4_proto_field;
#undef _
ip = (ip6_header_t *) mask;
-#define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
+#define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
foreach_ip6_proto_field;
#undef _
vec_validate (mask, len - 1);
if (dst)
- memset (mask, 0xff, 6);
+ clib_memset (mask, 0xff, 6);
if (src)
- memset (mask + 6, 0xff, 6);
+ clib_memset (mask + 6, 0xff, 6);
if (tag2 || dot1ad)
{
int ret;
/* Can't "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&src, 0, sizeof src);
- memset (&dst, 0, sizeof dst);
+ clib_memset (&src, 0, sizeof src);
+ clib_memset (&dst, 0, sizeof dst);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
int ret;
/* Can't "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&src, 0, sizeof src);
- memset (&dst, 0, sizeof dst);
+ clib_memset (&src, 0, sizeof src);
+ clib_memset (&dst, 0, sizeof dst);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
u32 instance = ~0;
int ret;
- memset (&src4, 0, sizeof src4);
- memset (&dst4, 0, sizeof dst4);
- memset (&src6, 0, sizeof src6);
- memset (&dst6, 0, sizeof dst6);
+ clib_memset (&src4, 0, sizeof src4);
+ clib_memset (&dst4, 0, sizeof dst4);
+ clib_memset (&src6, 0, sizeof src6);
+ clib_memset (&dst6, 0, sizeof dst6);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
int ret;
/* Shut up coverity */
- memset (hwaddr, 0, sizeof (hwaddr));
+ clib_memset (hwaddr, 0, sizeof (hwaddr));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
int ret;
/* Can't "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&local4, 0, sizeof local4);
- memset (&remote4, 0, sizeof remote4);
- memset (&local6, 0, sizeof local6);
- memset (&remote6, 0, sizeof remote6);
+ clib_memset (&local4, 0, sizeof local4);
+ clib_memset (&remote4, 0, sizeof remote4);
+ clib_memset (&local6, 0, sizeof local6);
+ clib_memset (&remote6, 0, sizeof remote6);
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
{
lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
{
vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
int ret;
- memset (&rloc, 0, sizeof (rloc));
+ clib_memset (&rloc, 0, sizeof (rloc));
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
ip_address_t ip;
int ret;
- memset (&ip, 0, sizeof (ip));
+ clib_memset (&ip, 0, sizeof (ip));
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
int ret;
- memset (&rloc, 0, sizeof (rloc));
+ clib_memset (&rloc, 0, sizeof (rloc));
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
}
else
{
- memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
+ clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
}
vec_free (locator_set_name);
struct in6_addr ip6;
u32 table_id = 0, nh_sw_if_index = ~0;
- memset (&ip4, 0, sizeof (ip4));
- memset (&ip6, 0, sizeof (ip6));
+ clib_memset (&ip4, 0, sizeof (ip4));
+ clib_memset (&ip6, 0, sizeof (ip6));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
u8 random_hw_addr = 1;
int ret;
- memset (hw_addr, 0, sizeof (hw_addr));
+ clib_memset (hw_addr, 0, sizeof (hw_addr));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
u8 is_master = 0;
int ret;
- memset (hw_addr, 0, sizeof (hw_addr));
+ clib_memset (hw_addr, 0, sizeof (hw_addr));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
int ret;
/* Shut up coverity */
- memset (dmac, 0, sizeof (dmac));
- memset (smac, 0, sizeof (smac));
+ clib_memset (dmac, 0, sizeof (dmac));
+ clib_memset (smac, 0, sizeof (smac));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
u8 mac_set = 0;
int ret;
- memset (remote_mac, 0, sizeof (remote_mac));
+ clib_memset (remote_mac, 0, sizeof (remote_mac));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
u8 mac_set = 0;
int ret;
- memset (remote_mac, 0, sizeof (remote_mac));
+ clib_memset (remote_mac, 0, sizeof (remote_mac));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
ip6_address_t ip6_addr;
int ret;
- memset (&ip4_addr, 0, sizeof (ip4_addr));
- memset (&ip6_addr, 0, sizeof (ip6_addr));
+ clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
+ clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
vat_json_print (FILE * ofp, vat_json_node_t * node)
{
vat_print_ctx_t ctx;
- memset (&ctx, 0, sizeof ctx);
+ clib_memset (&ctx, 0, sizeof ctx);
ctx.indent = 0;
ctx.ofp = ofp;
fformat (ofp, "\n");
for (i = 1; i < 32; i++)
{
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.sa_sigaction = (void *) signal_handler;
sa.sa_flags = SA_SIGINFO;
_vec_len (pm->plugin_info) = vec_len (pm->plugin_info) - 1;
continue;
}
- memset (pi, 0, sizeof (*pi));
+ clib_memset (pi, 0, sizeof (*pi));
hash_set_mem (pm->plugin_by_name_hash, plugin_name,
pi - pm->plugin_info);
}
/*
* Step 1: look up the current VPP pid in the shared-memory database
*/
- memset (ma, 0, sizeof (*ma));
+ clib_memset (ma, 0, sizeof (*ma));
ma->root_path = (char *) chroot_path;
svmdb_client = svmdb_map (ma);
pool_get_aligned (vm->buffer_free_list_pool, f, CLIB_CACHE_LINE_BYTES);
- memset (f, 0, sizeof (f[0]));
+ clib_memset (f, 0, sizeof (f[0]));
f->index = f - vm->buffer_free_list_pool;
f->n_data_bytes = vlib_buffer_round_size (n_data_bytes);
f->min_n_buffers_each_alloc = VLIB_FRAME_SIZE;
vec_free (f->buffers);
/* Poison it. */
- memset (f, 0xab, sizeof (f[0]));
+ clib_memset (f, 0xab, sizeof (f[0]));
}
/* Add buffer free list. */
if (CLIB_DEBUG > 0)
vlib_buffer_set_known_state (bi[0], VLIB_BUFFER_KNOWN_FREE);
- memset (b, 0, sizeof (vlib_buffer_t));
+ clib_memset (b, 0, sizeof (vlib_buffer_t));
vlib_buffer_init_for_free_list (b, fl);
if (fl->buffer_init_function)
vlib_worker_thread_barrier_sync (vm);
- memset (t, 0, sizeof (t[0]));
+ clib_memset (t, 0, sizeof (t[0]));
vec_add (t->packet_data, packet_data, n_packet_data_bytes);
t->min_n_buffers_each_alloc = min_n_buffers_each_alloc;
/* Initialize serialize main but save overflow buffer for re-use between calls. */
{
u8 *save = m->stream.overflow_buffer;
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
m->stream.overflow_buffer = save;
if (save)
_vec_len (save) = 0;
em->counters_last_clear + n->error_heap_index,
n_errors * sizeof (em->counters[0]));
else
- memset (em->counters + n->error_heap_index,
- 0, n_errors * sizeof (em->counters[0]));
+ clib_memset (em->counters + n->error_heap_index,
+ 0, n_errors * sizeof (em->counters[0]));
/* Register counter indices in the stat segment directory */
{
elog_event_type_t t;
uword i;
- memset (&t, 0, sizeof (t));
+ clib_memset (&t, 0, sizeof (t));
for (i = 0; i < n_errors; i++)
{
t.format = (char *) format (0, "%v %s: %%d",
int fd;
di = clib_mem_alloc (sizeof (vlib_pci_device_info_t));
- memset (di, 0, sizeof (vlib_pci_device_info_t));
+ clib_memset (di, 0, sizeof (vlib_pci_device_info_t));
di->addr.as_u32 = addr->as_u32;
u8 *dev_dir_name = format (0, "%s/%U", sysfs_pci_dev_path,
{
static pci_config_header_t all_ones;
if (all_ones.vendor_id == 0)
- memset (&all_ones, ~0, sizeof (all_ones));
+ clib_memset (&all_ones, ~0, sizeof (all_ones));
if (!memcmp (&di->config0.header, &all_ones, sizeof (all_ones)))
{
if (e->d_name[0] == '.') /* skip . and .. */
continue;
- memset (&ifr, 0, sizeof ifr);
- memset (&drvinfo, 0, sizeof drvinfo);
+ clib_memset (&ifr, 0, sizeof ifr);
+ clib_memset (&drvinfo, 0, sizeof drvinfo);
ifr.ifr_data = (char *) &drvinfo;
strncpy (ifr.ifr_name, e->d_name, sizeof (ifr.ifr_name));
ifr.ifr_name[ARRAY_LEN (ifr.ifr_name) - 1] = '\0';
if (strcmp ((char *) s, drvinfo.bus_info))
continue;
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
strncpy (ifr.ifr_name, e->d_name, sizeof (ifr.ifr_name));
ifr.ifr_name[ARRAY_LEN (ifr.ifr_name) - 1] = '\0';
if (ioctl (fd, SIOCGIFFLAGS, &ifr) < 0)
if (err)
{
pci_log_err (vm, p, "%U", format_clib_error, err);
- memset (p, 0, sizeof (linux_pci_device_t));
+ clib_memset (p, 0, sizeof (linux_pci_device_t));
pool_put (lpm->linux_pci_devices, p);
}
vec_free (p->regions);
close (p->fd);
- memset (p, 0, sizeof (linux_pci_device_t));
+ clib_memset (p, 0, sizeof (linux_pci_device_t));
pool_put (lpm->linux_pci_devices, p);
}
}
/* No driver, close the PCI config-space FD */
- memset (p, 0, sizeof (linux_pci_device_t));
+ clib_memset (p, 0, sizeof (linux_pci_device_t));
pool_put (lpm->linux_pci_devices, p);
}
goto done;
error:
- memset (pr, 0, sizeof (*pr));
+ clib_memset (pr, 0, sizeof (*pr));
pool_put (vpm->regions, pr);
done:
/* Poison frame when debugging. */
if (CLIB_DEBUG > 0)
- memset (f, 0xfe, n);
+ clib_memset (f, 0xfe, n);
/* Insert magic number. */
{
{
elog_event_type_t t;
- memset (&t, 0, sizeof (t));
+ clib_memset (&t, 0, sizeof (t));
/* 2 event types for this node: one when node function is called.
One when it returns. */
ASSERT (r->function != 0);
n = clib_mem_alloc_no_fail (sizeof (n[0]));
- memset (n, 0, sizeof (n[0]));
+ clib_memset (n, 0, sizeof (n[0]));
n->index = vec_len (nm->nodes);
n->node_fn_registrations = r->node_fn_registrations;
clib_panic ("failed to allocate process stack (%d bytes)",
1 << log2_n_stack_bytes);
- memset (p, 0, sizeof (p[0]));
+ clib_memset (p, 0, sizeof (p[0]));
p->log2_n_stack_bytes = log2_n_stack_bytes;
/* Process node's runtime index is really index into process
always_inline void
vlib_next_frame_init (vlib_next_frame_t * nf)
{
- memset (nf, 0, sizeof (nf[0]));
+ clib_memset (nf, 0, sizeof (nf[0]));
nf->frame_index = ~0;
nf->node_runtime_index = ~0;
}
{
vlib_process_signal_one_time_event (vm, p->node_index, p->one_time_event,
/* data */ ~0);
- memset (p, ~0, sizeof (p[0]));
+ clib_memset (p, ~0, sizeof (p[0]));
}
always_inline void
vlib_frame_queue_t *fq;
fq = clib_mem_alloc_aligned (sizeof (*fq), CLIB_CACHE_LINE_BYTES);
- memset (fq, 0, sizeof (*fq));
+ clib_memset (fq, 0, sizeof (*fq));
fq->nelts = nelts;
fq->vector_threshold = 128; // packets
vec_validate_aligned (fq->elts, nelts - 1, CLIB_CACHE_LINE_BYTES);
vm_clone->pending_rpc_requests = 0;
vec_validate (vm_clone->pending_rpc_requests, 0);
_vec_len (vm_clone->pending_rpc_requests) = 0;
- memset (&vm_clone->random_buffer, 0,
- sizeof (vm_clone->random_buffer));
+ clib_memset (&vm_clone->random_buffer, 0,
+ sizeof (vm_clone->random_buffer));
nm = &vlib_mains[0]->node_main;
nm_clone = &vm_clone->node_main;
clib_memcpy (n, nm->nodes[j], sizeof (*n));
/* none of the copied nodes have enqueue rights given out */
n->owner_node_index = VLIB_INVALID_NODE_INDEX;
- memset (&n->stats_total, 0, sizeof (n->stats_total));
- memset (&n->stats_last_clear, 0,
- sizeof (n->stats_last_clear));
+ clib_memset (&n->stats_total, 0, sizeof (n->stats_total));
+ clib_memset (&n->stats_last_clear, 0,
+ sizeof (n->stats_last_clear));
vec_add1 (nm_clone->nodes, n);
n++;
}
if (j >= vec_len (old_nodes_clone))
{
/* new node, set to zero */
- memset (&new_n_clone->stats_total, 0,
- sizeof (new_n_clone->stats_total));
- memset (&new_n_clone->stats_last_clear, 0,
- sizeof (new_n_clone->stats_last_clear));
+ clib_memset (&new_n_clone->stats_total, 0,
+ sizeof (new_n_clone->stats_total));
+ clib_memset (&new_n_clone->stats_last_clear, 0,
+ sizeof (new_n_clone->stats_last_clear));
}
else
{
fqt = &fqm->frame_queue_traces[fqix];
fqh = &fqm->frame_queue_histogram[fqix];
- memset (fqt->n_vectors, 0xff, sizeof (fqt->n_vectors));
+ clib_memset (fqt->n_vectors, 0xff, sizeof (fqt->n_vectors));
fqt->written = 0;
- memset (fqh, 0, sizeof (*fqh));
+ clib_memset (fqh, 0, sizeof (*fqh));
fqm->vlib_frame_queues[fqix]->trace = enable;
}
cjm->num_records = max_pow2 (cjm->num_records);
vec_validate (cjm->records, cjm->num_records - 1);
- memset (cjm->records, 0xff, cjm->num_records * sizeof (cj_record_t));
+ clib_memset (cjm->records, 0xff, cjm->num_records * sizeof (cj_record_t));
cjm->tail = ~0;
cjm->enable = enable;
}
pool_get (cm->cli_file_pool, cf);
- memset (cf, 0, sizeof (*cf));
+ clib_memset (cf, 0, sizeof (*cf));
template.read_function = unix_cli_read_ready;
template.write_function = unix_cli_write_ready;
if (isatty (STDIN_FILENO) && um->cli_line_mode == 0)
{
/* Capture terminal resize events */
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.sa_handler = unix_cli_resize_interrupt;
if (sigaction (SIGWINCH, &sa, 0) < 0)
clib_panic ("sigaction");
for (i = 1; i < 32; i++)
{
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.sa_sigaction = (void *) unix_signal_handler;
sa.sa_flags = SA_SIGINFO;
struct msghdr h;
word n_bytes, n_bytes_tx, n_retries;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
h.msg_name = tx_addr;
h.msg_namelen = sizeof (tx_addr[0]);
vlib_main_t *vm = msm->mc_main.vlib_main;
clib_error_t *error;
- memset (&tx_addr, 0, sizeof (tx_addr));
+ clib_memset (&tx_addr, 0, sizeof (tx_addr));
tx_addr.sin_family = AF_INET;
tx_addr.sin_addr.s_addr = mc_socket_peer_id_get_address (dest_peer_id);
tx_addr.sin_port = mc_socket_peer_id_get_port (dest_peer_id);
{
struct msghdr h;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
if (rx_addr)
{
h.msg_name = rx_addr;
clib_file_t template = { 0 };
pool_get (msm->catchups, c);
- memset (c, 0, sizeof (c[0]));
+ clib_memset (c, 0, sizeof (c[0]));
client_len = sizeof (client_addr);
{
struct sockaddr_in a;
- memset (&a, 0, sizeof (a)); /* Warnings be gone */
+ clib_memset (&a, 0, sizeof (a)); /* Warnings be gone */
a.sin_family = PF_INET;
a.sin_addr.s_addr = INADDR_ANY;
0)
return clib_error_return_unix (0, "%s setsockopt SO_REUSEADDR", type);
- memset (&ms->tx_addr, 0, sizeof (ms->tx_addr));
+ clib_memset (&ms->tx_addr, 0, sizeof (ms->tx_addr));
ms->tx_addr.sin_family = AF_INET;
ms->tx_addr.sin_addr.s_addr =
htonl (msm->multicast_tx_ip4_address_host_byte_order);
sizeof (ms->tx_addr)) < 0)
return clib_error_return_unix (0, "%s bind", type);
- memset (&mcast_req, 0, sizeof (mcast_req));
+ clib_memset (&mcast_req, 0, sizeof (mcast_req));
mcast_req.imr_multiaddr.s_addr =
htonl (msm->multicast_tx_ip4_address_host_byte_order);
mcast_req.imr_interface.s_addr = msm->if_ip4_address_net_byte_order;
int one = 1;
pool_get (msm->catchups, c);
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
c->socket = socket (AF_INET, SOCK_STREAM, 0);
if (c->socket < 0)
return 0;
}
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = mc_socket_peer_id_get_address (catchup_peer_id);
addr.sin_port = mc_socket_peer_id_get_port (catchup_peer_id);
if (!rmp) \
return; \
\
- memset (rmp, 0, sizeof (*rmp)); \
+ clib_memset (rmp, 0, sizeof (*rmp)); \
rv = VNET_API_ERROR_TABLE_TOO_BIG; \
is_error = 1; \
} \
vl_msg_api_trace_free (am, which);
}
- memset (tp, 0, sizeof (*tp));
+ clib_memset (tp, 0, sizeof (*tp));
if (clib_arch_is_big_endian)
{
vl_msg_api_msg_config_t cfg;
vl_msg_api_msg_config_t *c = &cfg;
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
c->id = id;
c->name = name;
vl_msg_api_msg_config_t cfg;
vl_msg_api_msg_config_t *c = &cfg;
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
c->id = msg_id;
vl_msg_api_config (c);
mp = vl_socket_client_msg_alloc (sizeof(*mp)); \
else \
mp = vl_msg_api_alloc_as_if_client(sizeof(*mp)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T+__plugin_msg_base); \
mp->client_index = vam->my_client_index; \
} while(0);
mp = vl_socket_client_msg_alloc (sizeof(*mp)); \
else \
mp = vl_msg_api_alloc_as_if_client(sizeof(*mp)); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T+__plugin_msg_base); \
mp->client_index = vam->my_client_index; \
if (scm) \
mp = vl_socket_client_msg_alloc (sizeof(*mp)); \
else \
mp = vl_msg_api_alloc_as_if_client(sizeof(*mp) + n); \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T+__plugin_msg_base); \
mp->client_index = vam->my_client_index; \
} while(0);
*regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
regp = *regpp;
- memset (regp, 0, sizeof (*regp));
+ clib_memset (regp, 0, sizeof (*regp));
regp->registration_type = REGISTRATION_TYPE_SHMEM;
regp->vl_api_registration_pool_index = regpp - am->vl_clients;
regp->vlib_rp = svm;
*regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
regp = *regpp;
- memset (regp, 0, sizeof (*regp));
+ clib_memset (regp, 0, sizeof (*regp));
regp->registration_type = REGISTRATION_TYPE_SHMEM;
regp->vl_api_registration_pool_index = regpp - am->vl_clients;
regp->vlib_rp = svm;
oldheap = svm_push_data_heap (svm);
vec_free (regp->name);
/* Poison the old registration */
- memset (regp, 0xF1, sizeof (*regp));
+ clib_memset (regp, 0xF1, sizeof (*regp));
clib_mem_free (regp);
pthread_mutex_unlock (&svm->mutex);
svm_pop_heap (oldheap);
shmem_hdr = am->shmem_hdr;
rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
rmp->context = mp->context;
vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp);
vl_shmem_hdr_t *shm;
vlib_main_t *vm = vlib_get_main ();
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
return rv;
am->shmem_hdr = regp->shmem_hdr;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MEMCLNT_KEEPALIVE);
mp->context = mp->client_index =
vl_msg_api_handle_from_index_and_epoch
else
{
/* Poison the old registration */
- memset (*regpp, 0xF3, sizeof (**regpp));
+ clib_memset (*regpp, 0xF3, sizeof (**regpp));
clib_mem_free (*regpp);
}
/* no dangling references, please */
svm_map_region_args_t _a, *a = &_a;
clib_error_t *error;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->root_path = am->root_path;
a->name = SVM_GLOBAL_REGION_NAME;
a->baseva = (am->global_baseva != 0) ?
am->vl_input_queue = vl_input_queue;
mp = vl_msg_api_alloc (sizeof (vl_api_memclnt_create_t));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE);
mp->ctx_quota = ctx_quota;
mp->input_queue = (uword) vl_input_queue;
vl_input_queue = am->vl_input_queue;
mp = vl_msg_api_alloc (sizeof (vl_api_memclnt_delete_t));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE);
mp->index = am->my_client_index;
mp->handle = (uword) am->my_registration;
shmem_hdr = am->shmem_hdr;
rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
rmp->context = mp->context;
vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp);
if (do_unmap)
vl_client_api_unmap ();
}
- memset (mm, 0, sizeof (*mm));
+ clib_memset (mm, 0, sizeof (*mm));
}
void
if (strlen (plugin_name) + 1 > sizeof (mp->name))
return (rv);
- memset (&clib_time, 0, sizeof (clib_time));
+ clib_memset (&clib_time, 0, sizeof (clib_time));
clib_time_init (&clib_time);
/* Push this plugin's first_msg_id_reply handler */
if (!am->my_registration)
{
mp = vl_socket_client_msg_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
mp->client_index = am->my_client_index;
strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1);
else
{
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
mp->client_index = am->my_client_index;
strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1);
struct timespec ts, tsrem;
char *vpe_api_region_suffix = "-vpe-api";
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
if (strstr (region_name, vpe_api_region_suffix))
{
ts = tsrem;
}
/* Mutex buggered, "fix" it */
- memset (&q->mutex, 0, sizeof (q->mutex));
+ clib_memset (&q->mutex, 0, sizeof (q->mutex));
clib_warning ("forcibly release main input queue mutex");
mutex_ok:
clib_file_t template = { 0 };
pool_get (socket_main.registration_pool, rp);
- memset (rp, 0, sizeof (*rp));
+ clib_memset (rp, 0, sizeof (*rp));
template.read_function = vl_socket_read_ready;
template.write_function = vl_socket_write_ready;
mh.msg_iov = iov;
mh.msg_iovlen = 1;
- memset (&ctl, 0, sizeof (ctl));
+ clib_memset (&ctl, 0, sizeof (ctl));
mh.msg_control = ctl;
mh.msg_controllen = sizeof (ctl);
cmsg = CMSG_FIRSTHDR (&mh);
* Set up a memfd segment of the requested size wherein the
* shmem data structures will be initialized
*/
- memset (memfd, 0, sizeof (*memfd));
+ clib_memset (memfd, 0, sizeof (*memfd));
memfd->ssvm_size = mp->requested_size;
memfd->requested_va = 0ULL;
memfd->i_am_master = 1;
/*
* Create a plausible svm_region in the memfd backed segment
*/
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE;
a->size = memfd->ssvm_size - MMAP_PAGESIZE;
/* $$$$ might want a different config parameter */
return error;
pool_get (sm->registration_pool, rp);
- memset (rp, 0, sizeof (*rp));
+ clib_memset (rp, 0, sizeof (*rp));
rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN;
mh.msg_control = ctl;
mh.msg_controllen = sizeof (ctl);
- memset (ctl, 0, sizeof (ctl));
+ clib_memset (ctl, 0, sizeof (ctl));
if (wait != ~0)
{
return;
}
- memset (memfd, 0, sizeof (*memfd));
+ clib_memset (memfd, 0, sizeof (*memfd));
memfd->fd = my_fd;
/* Note: this closes memfd.fd */
mp = vl_socket_client_msg_alloc (sizeof (*mp) +
vec_len (config) * sizeof (u64));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_SOCK_INIT_SHM);
mp->client_index = clib_host_to_net_u32 (scm->client_index);
mp->requested_size = 64 << 20;
return;
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id = ntohs (VL_API_API_VERSIONS_REPLY);
/* fill in the message */
vl_msg_api_msg_config_t cfg;
vl_msg_api_msg_config_t *c = &cfg;
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
#define _(N,n) do { \
c->id = VL_API_##N; \
svm_queue_t *q;
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_TRACE_PLUGIN_MSG_IDS);
strncpy ((char *) mp->plugin_name, (char *) name,
/* Otherwise, actually do an RPC */
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + data_length);
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
clib_memcpy (mp->data, data, data_length);
mp->_vl_msg_id = ntohs (VL_API_RPC_CALL);
mp->function = pointer_to_uword (fp);
/* Copy the buffer (from the read-only mmap'ed file) */
vec_validate (tmpbuf, size - 1 + sizeof (uword));
clib_memcpy (tmpbuf + sizeof (uword), msg, size);
- memset (tmpbuf, 0xf, sizeof (uword));
+ clib_memset (tmpbuf, 0xf, sizeof (uword));
/*
* Endian swap if needed. All msg data is supposed to be
{
if (CLIB_DEBUG > 0)
{
- memset (adj, 0xfe, sizeof (adj[0]));
+ clib_memset (adj, 0xfe, sizeof (adj[0]));
}
}
adj->ia_delegates = NULL;
/* lest it become a midchain in the future */
- memset(&adj->sub_type.midchain.next_dpo, 0,
+ clib_memset(&adj->sub_type.midchain.next_dpo, 0,
sizeof(adj->sub_type.midchain.next_dpo));
return (adj);
adj_nbr_tables[nh_proto][sw_if_index] =
clib_mem_alloc_aligned(sizeof(BVT(clib_bihash)),
CLIB_CACHE_LINE_BYTES);
- memset(adj_nbr_tables[nh_proto][sw_if_index],
+ clib_memset(adj_nbr_tables[nh_proto][sw_if_index],
0,
sizeof(BVT(clib_bihash)));
always_inline void
vnet_rewrite_clear_data_internal (vnet_rewrite_header_t * rw, int max_size)
{
- /* Sanity check values carefully for this memset operation */
+ /* Sanity check values carefully for this clib_memset operation */
ASSERT ((max_size > 0) && (max_size < VLIB_BUFFER_PRE_DATA_SIZE));
rw->data_bytes = 0;
- memset (rw->data, 0xfe, max_size);
+ clib_memset (rw->data, 0xfe, max_size);
}
always_inline void
vnet_rewrite_set_data_internal (vnet_rewrite_header_t * rw,
int max_size, void *data, int data_bytes)
{
- /* Sanity check values carefully for this memset operation */
+ /* Sanity check values carefully for this clib_memset operation */
ASSERT ((max_size > 0) && (max_size < VLIB_BUFFER_PRE_DATA_SIZE));
ASSERT ((data_bytes >= 0) && (data_bytes < max_size));
rw->data_bytes = data_bytes;
clib_memcpy (rw->data + max_size - data_bytes, data, data_bytes);
- memset (rw->data, 0xfe, max_size - data_bytes);
+ clib_memset (rw->data, 0xfe, max_size - data_bytes);
}
#define vnet_rewrite_set_data(rw,data,data_bytes) \
#define BFD_UDP_API_PARAM_COMMON_CODE \
ip46_address_t local_addr; \
- memset (&local_addr, 0, sizeof (local_addr)); \
+ clib_memset (&local_addr, 0, sizeof (local_addr)); \
ip46_address_t peer_addr; \
- memset (&peer_addr, 0, sizeof (peer_addr)); \
+ clib_memset (&peer_addr, 0, sizeof (peer_addr)); \
if (mp->is_ipv6) \
{ \
clib_memcpy (&local_addr.ip6, mp->local_addr, sizeof (local_addr.ip6)); \
}
vl_api_bfd_udp_session_details_t *mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_BFD_UDP_SESSION_DETAILS);
mp->context = context;
mp->state = bs->local_state;
/* *INDENT-OFF* */
pool_foreach (key, bfd_main.auth_keys, ({
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_BFD_AUTH_KEYS_DETAILS);
rmp->context = mp->context;
rmp->conf_key_id = clib_host_to_net_u32 (key->conf_key_id);
b->current_length += sizeof (*auth);
pkt->pkt.head.length += sizeof (*auth);
bfd_pkt_set_auth_present (&pkt->pkt);
- memset (auth, 0, sizeof (*auth));
+ clib_memset (auth, 0, sizeof (*auth));
auth->type_len.type = bs->auth.curr_key->auth_type;
/*
* only meticulous authentication types require incrementing seq number
bfd_pkt_t *pkt = vlib_buffer_get_current (b);
u32 bfd_length = 0;
bfd_length = sizeof (bfd_pkt_t);
- memset (pkt, 0, sizeof (*pkt));
+ clib_memset (pkt, 0, sizeof (*pkt));
bfd_pkt_set_version (pkt, 1);
bfd_pkt_set_diag_code (pkt, bs->local_diag);
bfd_pkt_set_state (pkt, bs->local_state);
}
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
ASSERT (b->current_data == 0);
- memset (vnet_buffer (b), 0, sizeof (*vnet_buffer (b)));
+ clib_memset (vnet_buffer (b), 0, sizeof (*vnet_buffer (b)));
VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
bfd_echo_pkt_t *pkt = vlib_buffer_get_current (b);
- memset (pkt, 0, sizeof (*pkt));
+ clib_memset (pkt, 0, sizeof (*pkt));
pkt->discriminator = bs->local_discr;
pkt->expire_time_clocks =
now + bs->echo_transmit_interval_clocks * bs->local_detect_mult;
}
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
ASSERT (b->current_data == 0);
- memset (vnet_buffer (b), 0, sizeof (*vnet_buffer (b)));
+ clib_memset (vnet_buffer (b), 0, sizeof (*vnet_buffer (b)));
VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
bfd_init_control_frame (bm, bs, b);
switch (bs->poll_state)
bm->random_seed = random_default_seed ();
bm->vlib_main = vm;
bm->vnet_main = vnet_get_main ();
- memset (&bm->wheel, 0, sizeof (bm->wheel));
+ clib_memset (&bm->wheel, 0, sizeof (bm->wheel));
bm->cpu_cps = vm->clib_time.clocks_per_second;
BFD_DBG ("cps is %.2f", bm->cpu_cps);
bm->default_desired_min_tx_clocks =
bfd_lock (bm);
pool_get (bm->sessions, result);
- memset (result, 0, sizeof (*result));
+ clib_memset (result, 0, sizeof (*result));
result->bs_idx = result - bm->sessions;
result->transport = t;
const unsigned limit = 1000;
auth_key - bm->auth_keys);
}
auth_key->auth_type = auth_type;
- memset (auth_key->key, 0, sizeof (auth_key->key));
+ clib_memset (auth_key->key, 0, sizeof (auth_key->key));
clib_memcpy (auth_key->key, key_data, key_len);
return 0;
#else
return VNET_API_ERROR_BFD_EINUSE;
}
hash_unset (bm->auth_key_by_conf_key_id, conf_key_id);
- memset (auth_key, 0, sizeof (*auth_key));
+ clib_memset (auth_key, 0, sizeof (*auth_key));
pool_put (bm->auth_keys, auth_key);
}
else
ip4_udp_headers *headers = NULL;
vlib_buffer_advance (b, -sizeof (*headers));
headers = vlib_buffer_get_current (b);
- memset (headers, 0, sizeof (*headers));
+ clib_memset (headers, 0, sizeof (*headers));
headers->ip4.ip_version_and_header_length = 0x45;
headers->ip4.ttl = 255;
headers->ip4.protocol = IP_PROTOCOL_UDP;
ip6_udp_headers *headers = NULL;
vlib_buffer_advance (b, -sizeof (*headers));
headers = vlib_buffer_get_current (b);
- memset (headers, 0, sizeof (*headers));
+ clib_memset (headers, 0, sizeof (*headers));
headers->ip6.ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (0x6 << 28);
headers->ip6.hop_limit = 255;
const ip46_address_t * local_addr,
const ip46_address_t * peer_addr)
{
- memset (key, 0, sizeof (*key));
+ clib_memset (key, 0, sizeof (*key));
key->sw_if_index = sw_if_index;
key->local_addr.as_u64[0] = local_addr->as_u64[0];
key->local_addr.as_u64[1] = local_addr->as_u64[1];
return VNET_API_ERROR_BFD_EAGAIN;
}
bfd_udp_session_t *bus = &bs->udp;
- memset (bus, 0, sizeof (*bus));
+ clib_memset (bus, 0, sizeof (*bus));
bfd_udp_key_t *key = &bus->key;
bfd_udp_key_init (key, sw_if_index, local_addr, peer_addr);
const bfd_session_t *tmp = bfd_lookup_session (bum, key);
else
{
bfd_udp_key_t key;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
key.local_addr.ip4.as_u32 = ip4->dst_address.as_u32;
key.peer_addr.ip4.as_u32 = ip4->src_address.as_u32;
else
{
bfd_udp_key_t key;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
key.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
key.local_addr.ip6.as_u64[0] = ip6->dst_address.as_u64[0];
key.local_addr.ip6.as_u64[1] = ip6->dst_address.as_u64[1];
{
b0->current_data = 0;
b0->current_length = 0;
- memset (vnet_buffer (b0), 0, sizeof (*vnet_buffer (b0)));
+ clib_memset (vnet_buffer (b0), 0, sizeof (*vnet_buffer (b0)));
bfd_init_final_control_frame (vm, b0, bfd_udp_main.bfd_main, bs,
0);
if (is_ipv6)
mp = vl_msg_api_alloc(sizeof(*mp));
if (!mp)
return;
- memset(mp, 0, sizeof(*mp));
+ clib_memset(mp, 0, sizeof(*mp));
mp->_vl_msg_id = ntohs(VL_API_BIER_TABLE_DETAILS);
mp->context = context;
if (!mp)
return;
- memset(mp, 0, m_size);
+ clib_memset(mp, 0, m_size);
mp->_vl_msg_id = ntohs(VL_API_BIER_ROUTE_DETAILS);
mp->context = ctx->context;
mp = vl_msg_api_alloc(sizeof(*mp) + n_bytes);
if (!mp)
return;
- memset(mp, 0, sizeof(*mp)+n_bytes);
+ clib_memset(mp, 0, sizeof(*mp)+n_bytes);
mp->_vl_msg_id = ntohs(VL_API_BIER_IMP_DETAILS);
mp->context = context;
mp = vl_msg_api_alloc(sizeof(*mp));
if (!mp)
return;
- memset(mp, 0, sizeof(*mp));
+ clib_memset(mp, 0, sizeof(*mp));
mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_TABLE_DETAILS);
mp->context = context;
if (!mp)
return;
- memset(mp, 0, m_size);
+ clib_memset(mp, 0, m_size);
mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_ENTRY_DETAILS);
mp->context = ctx->context;
*/
bier_bift_table = clib_mem_alloc_aligned(sizeof(*bier_bift_table),
CLIB_CACHE_LINE_BYTES);
- memset(bier_bift_table, 0, sizeof(*bier_bift_table));
+ clib_memset(bier_bift_table, 0, sizeof(*bier_bift_table));
for (ii = 0; ii < BIER_BIFT_N_ENTRIES; ii++)
{
/**
* Set the result for each entry in the DB to be invalid
*/
- memset(bdt->bdt_db, 0xff, sizeof(bdt->bdt_db));
+ clib_memset(bdt->bdt_db, 0xff, sizeof(bdt->bdt_db));
}
else
{
{
bits->bfmb_refs = clib_mem_alloc(sizeof(bits->bfmb_refs[0]) *
bier_hdr_len_id_to_num_bits(hlid));
- memset(bits->bfmb_refs,
+ clib_memset(bits->bfmb_refs,
0,
(sizeof(bits->bfmb_refs[0]) *
bier_hdr_len_id_to_num_bits(hlid)));
sizeof(bits->bfmb_input_reset_string.bbs_buckets[0]) *
bier_hdr_len_id_to_num_buckets(hlid),
CLIB_CACHE_LINE_BYTES);
- memset(bits->bfmb_input_reset_string.bbs_buckets,
+ clib_memset(bits->bfmb_input_reset_string.bbs_buckets,
0,
sizeof(bits->bfmb_input_reset_string.bbs_buckets[0]) *
bier_hdr_len_id_to_num_buckets(hlid));
fib_route_path_t *rpaths;
mpls_label_t olabel;
- memset(bfm, 0, sizeof(*bfm));
+ clib_memset(bfm, 0, sizeof(*bfm));
bfm->bfm_id = clib_mem_alloc(sizeof(*bfm->bfm_id));
bfm = bier_fmask_get(bfmi);
*btid = *bier_table_get_id(bfm->bfm_id->bfmi_bti);
- memset(rpath, 0, sizeof(*rpath));
+ clib_memset(rpath, 0, sizeof(*rpath));
rpath->rpath.frp_sw_if_index = ~0;
* Depending on what the ID is there may be padding.
* This key will be memcmp'd in the mhash, so make sure it's all 0
*/
- memset(key, 0, sizeof(*key));
+ clib_memset(key, 0, sizeof(*key));
/*
* Pick the attributes from the path that make the FMask unique
static inline void
bier_hdr_clear (bier_hdr_t *bier_hdr)
{
- memset(&bier_hdr->bh_bit_string, 0,
+ clib_memset(&bier_hdr->bh_bit_string, 0,
bier_hdr_len_id_to_num_buckets(
bier_hdr_get_len_id(bier_hdr)));
}
*/
bier_bit_string_t bbs_256;
u8 buckets[BIER_HDR_BUCKETS_256];
- memset(buckets, 0x5, BIER_HDR_BUCKETS_256);
+ clib_memset(buckets, 0x5, BIER_HDR_BUCKETS_256);
res = 0;
bier_bit_string_init(&bbs_256, BIER_HDR_LEN_256, buckets);
vl_api_sw_interface_event_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
mp->sw_if_index = ntohl (sw_if_index);
unix_shared_memory_queue_t *q;
bond_create_if_args_t _a, *ap = &_a;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
if (mp->use_custom_mac)
{
unix_shared_memory_queue_t *q;
bond_enslave_args_t _a, *ap = &_a;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->group = ntohl (mp->bond_sw_if_index);
ap->slave = ntohl (mp->sw_if_index);
unix_shared_memory_queue_t *q;
bond_detach_slave_args_t _a, *ap = &_a;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->slave = ntohl (mp->sw_if_index);
bond_detach_slave (vm, ap);
vl_api_sw_interface_bond_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_BOND_DETAILS);
mp->sw_if_index = htonl (bond_if->sw_if_index);
clib_memcpy (mp->interface_name, bond_if->interface_name,
vl_api_sw_interface_slave_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_SLAVE_DETAILS);
mp->sw_if_index = htonl (slave_if->sw_if_index);
clib_memcpy (mp->interface_name, slave_if->interface_name,
/* *INDENT-OFF* */
pool_foreach (bif, bm->interfaces,
vec_add2(r_bondifs, bondif, 1);
- memset (bondif, 0, sizeof (*bondif));
+ clib_memset (bondif, 0, sizeof (*bondif));
bondif->sw_if_index = bif->sw_if_index;
hi = vnet_get_hw_interface (vnm, bif->hw_if_index);
clib_memcpy(bondif->interface_name, hi->name,
vec_foreach (sw_if_index, bif->slaves)
{
vec_add2 (r_slaveifs, slaveif, 1);
- memset (slaveif, 0, sizeof (*slaveif));
+ clib_memset (slaveif, 0, sizeof (*slaveif));
sif = bond_get_slave_by_sw_if_index (*sw_if_index);
if (sif)
{
clib_bitmap_free (bif->port_number_bitmap);
hash_unset (bm->bond_by_sw_if_index, bif->sw_if_index);
- memset (bif, 0, sizeof (*bif));
+ clib_memset (bif, 0, sizeof (*bif));
pool_put (bm->interfaces, bif);
return 0;
return;
}
pool_get (bm->interfaces, bif);
- memset (bif, 0, sizeof (*bif));
+ clib_memset (bif, 0, sizeof (*bif));
bif->dev_instance = bif - bm->interfaces;
bif->lb = args->lb;
bif->mode = args->mode;
return;
}
pool_get (bm->neighbors, sif);
- memset (sif, 0, sizeof (*sif));
+ clib_memset (sif, 0, sizeof (*sif));
sw = pool_elt_at_index (im->sw_interfaces, args->slave);
sif->port_enabled = sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP;
sif->sw_if_index = sw->sw_if_index;
vl_api_policer_classify_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_POLICER_CLASSIFY_DETAILS);
mp->context = context;
mp->sw_if_index = htonl (sw_if_index);
vl_api_classify_session_details_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_CLASSIFY_SESSION_DETAILS);
rmp->context = context;
rmp->table_id = ntohl (table_id);
vl_api_flow_classify_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_FLOW_CLASSIFY_DETAILS);
mp->context = context;
mp->sw_if_index = htonl (sw_if_index);
nbuckets = 1 << (max_log2 (nbuckets));
pool_get_aligned (cm->tables, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
vec_validate_aligned (t->mask, match_n_vectors - 1, sizeof (u32x4));
clib_memcpy (t->mask, mask, match_n_vectors * sizeof (u32x4));
initialize:
ASSERT (rv);
- memset (rv, 0xff, required_length);
+ clib_memset (rv, 0xff, required_length);
return rv;
}
(v->key, add_v->key, t->match_n_vectors * sizeof (u32x4)))
{
vnet_classify_entry_release_resource (v);
- memset (v, 0xff, sizeof (vnet_classify_entry_t) +
- t->match_n_vectors * sizeof (u32x4));
+ clib_memset (v, 0xff, sizeof (vnet_classify_entry_t) +
+ t->match_n_vectors * sizeof (u32x4));
v->flags |= VNET_CLASSIFY_ENTRY_FREE;
CLIB_MEMORY_BARRIER ();
tcp = (tcp_header_t *) mask;
-#define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
+#define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
foreach_tcp_proto_field;
#undef _
udp = (udp_header_t *) mask;
-#define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
+#define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
foreach_udp_proto_field;
#undef _
ip = (ip4_header_t *) mask;
-#define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
+#define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
foreach_ip4_proto_field;
#undef _
ip = (ip6_header_t *) mask;
-#define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
+#define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
foreach_ip6_proto_field;
#undef _
vec_validate (mask, len - 1);
if (dst)
- memset (mask, 0xff, 6);
+ clib_memset (mask, 0xff, 6);
if (src)
- memset (mask + 6, 0xff, 6);
+ clib_memset (mask + 6, 0xff, 6);
if (tag2 || dot1ad)
{
data = (classify_data_or_mask_t *) dp;
/* Mask on src address */
- memset (&mask->ip.src_address, 0xff, 4);
+ clib_memset (&mask->ip.src_address, 0xff, 4);
tmp = clib_host_to_net_u32 (tm->src.as_u32);
vlib_node_t *n;
u32 i;
- memset (cm, 0, sizeof (cm[0]));
+ clib_memset (cm, 0, sizeof (cm[0]));
cm->config_string_hash =
hash_create_vec (0,
int address_family;
u32 ci, default_next;
- memset (data, 0, sizeof(*data));
+ clib_memset (data, 0, sizeof(*data));
/*
* Ignore local interface, pg interfaces. $$$ need a #define for the
}
/* bind before rx ring is cfged so we don't receive packets from other interfaces */
- memset (&sll, 0, sizeof (sll));
+ clib_memset (&sll, 0, sizeof (sll));
sll.sll_family = PF_PACKET;
sll.sll_protocol = htons (ETH_P_ALL);
sll.sll_ifindex = host_if_index;
if (error)
{
- memset (apif, 0, sizeof (*apif));
+ clib_memset (apif, 0, sizeof (*apif));
pool_put (apm->interfaces, apif);
vlib_log_err (apm->log_class, "Unable to register interface: %U",
format_clib_error, error);
af_packet_main_t *apm = &af_packet_main;
vlib_thread_main_t *tm = vlib_get_thread_main ();
- memset (apm, 0, sizeof (af_packet_main_t));
+ clib_memset (apm, 0, sizeof (af_packet_main_t));
mhash_init_vec_string (&apm->if_index_by_host_if_name, sizeof (uword));
{
vl_api_af_packet_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_AF_PACKET_DETAILS);
mp->sw_if_index = htonl (af_packet_if->sw_if_index);
clib_memcpy (mp->host_if_name, af_packet_if->host_if_name,
{
struct nlmsghdr *nh;
u8 *p;
- memset (m, 0, sizeof (vnet_netlink_msg_t));
+ clib_memset (m, 0, sizeof (vnet_netlink_msg_t));
vec_add2 (m->data, p, NLMSG_SPACE (msg_len));
ASSERT (m->data == p);
vec_free (nif->host_if_name);
vec_free (nif->req);
- memset (nif, 0, sizeof (*nif));
+ clib_memset (nif, 0, sizeof (*nif));
pool_put (nm->interfaces, nif);
}
vlib_thread_registration_t *tr;
uword *p;
- memset (nm, 0, sizeof (netmap_main_t));
+ clib_memset (nm, 0, sizeof (netmap_main_t));
nm->input_cpu_first_index = 0;
nm->input_cpu_count = 1;
{
vnet_sw_interface_t template;
- memset (&template, 0, sizeof (template));
+ clib_memset (&template, 0, sizeof (template));
template.type = VNET_SW_INTERFACE_TYPE_PIPE;
template.flood_class = VNET_FLOOD_CLASS_NORMAL;
template.sup_sw_if_index = hi->sw_if_index;
ASSERT (parent_sw_if_index);
- memset (address, 0, sizeof (address));
+ clib_memset (address, 0, sizeof (address));
/*
* Allocate a pipe instance. Either select one dynamically
return;
}
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
pool_get (vim->interfaces, vif);
vif->dev_instance = vif - vim->interfaces;
vif->tap_fd = -1;
/* Set vhost memory table */
i = sizeof (struct vhost_memory) + sizeof (struct vhost_memory_region);
vhost_mem = clib_mem_alloc (i);
- memset (vhost_mem, 0, i);
+ clib_memset (vhost_mem, 0, i);
vhost_mem->nregions = 1;
vhost_mem->regions[0].memory_size = (1ULL << 47) - 4096;
_IOCTL (vif->fd, VHOST_SET_MEM_TABLE, vhost_mem);
close (vif->fd);
vec_foreach_index (i, vif->vrings) virtio_vring_free (vm, vif, i);
vec_free (vif->vrings);
- memset (vif, 0, sizeof (virtio_if_t));
+ clib_memset (vif, 0, sizeof (virtio_if_t));
pool_put (vim->interfaces, vif);
done:
tm->tap_ids = clib_bitmap_set (tm->tap_ids, vif->id, 0);
clib_spinlock_free (&vif->lockp);
- memset (vif, 0, sizeof (*vif));
+ clib_memset (vif, 0, sizeof (*vif));
pool_put (mm->interfaces, vif);
return 0;
/* *INDENT-OFF* */
pool_foreach (vif, mm->interfaces,
vec_add2(r_tapids, tapid, 1);
- memset (tapid, 0, sizeof (*tapid));
+ clib_memset (tapid, 0, sizeof (*tapid));
tapid->id = vif->id;
tapid->sw_if_index = vif->sw_if_index;
hi = vnet_get_hw_interface (vnm, vif->hw_if_index);
vl_api_registration_t *reg;
tap_create_if_args_t _a, *ap = &_a;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->id = ntohl (mp->id);
if (!mp->use_random_mac)
vl_api_sw_interface_event_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
mp->sw_if_index = ntohl (sw_if_index);
{
vl_api_sw_interface_tap_v2_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_TAP_V2_DETAILS);
mp->id = htonl (tap_if->id);
mp->sw_if_index = htonl (tap_if->sw_if_index);
vlib_buffer_t *b = vlib_get_buffer (vm, bi);
struct virtio_net_hdr_v1 *hdr = vlib_buffer_get_current (b) - hdr_sz;
- memset (hdr, 0, hdr_sz);
+ clib_memset (hdr, 0, hdr_sz);
if (PREDICT_TRUE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0))
{
vhost_user_vring_init (vhost_user_intf_t * vui, u32 qid)
{
vhost_user_vring_t *vring = &vui->vrings[qid];
- memset (vring, 0, sizeof (*vring));
+ clib_memset (vring, 0, sizeof (*vring));
vring->kickfd_idx = ~0;
vring->callfd_idx = ~0;
vring->errfd = -1;
char control[CMSG_SPACE (VHOST_MEMORY_MAX_NREGIONS * sizeof (int))];
- memset (&mh, 0, sizeof (mh));
- memset (control, 0, sizeof (control));
+ clib_memset (&mh, 0, sizeof (mh));
+ clib_memset (control, 0, sizeof (control));
for (i = 0; i < VHOST_MEMORY_MAX_NREGIONS; i++)
fds[i] = -1;
{
vui->vring_locks[q] = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
CLIB_CACHE_LINE_BYTES);
- memset ((void *) vui->vring_locks[q], 0, CLIB_CACHE_LINE_BYTES);
+ clib_memset ((void *) vui->vring_locks[q], 0, CLIB_CACHE_LINE_BYTES);
}
vec_validate (vui->per_cpu_tx_qid,
vl_api_sw_interface_event_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
mp->sw_if_index = ntohl (sw_if_index);
vl_api_sw_interface_vhost_user_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_VHOST_USER_DETAILS);
mp->sw_if_index = ntohl (vui->sw_if_index);
mp->virtio_net_hdr_sz = ntohl (vui->virtio_net_hdr_sz);
virtio_net_hdr_mrg_rxbuf_t *hdr;
u32 hint = 0;
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
t->device_index = vui - vum->vhost_user_interfaces;
t->qid = qid;
vring_desc_t *hdr_desc = 0;
u32 hint = 0;
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
t->device_index = vui - vum->vhost_user_interfaces;
t->qid = qid;
i = sizeof (struct vring_desc) * sz;
i = round_pow2 (i, CLIB_CACHE_LINE_BYTES);
vring->desc = clib_mem_alloc_aligned (i, CLIB_CACHE_LINE_BYTES);
- memset (vring->desc, 0, i);
+ clib_memset (vring->desc, 0, i);
i = sizeof (struct vring_avail) + sz * sizeof (vring->avail->ring[0]);
i = round_pow2 (i, CLIB_CACHE_LINE_BYTES);
vring->avail = clib_mem_alloc_aligned (i, CLIB_CACHE_LINE_BYTES);
- memset (vring->avail, 0, i);
+ clib_memset (vring->avail, 0, i);
// tell kernel that we don't need interrupt
vring->avail->flags = VIRTIO_RING_FLAG_MASK_INT;
i = sizeof (struct vring_used) + sz * sizeof (struct vring_used_elem);
i = round_pow2 (i, CLIB_CACHE_LINE_BYTES);
vring->used = clib_mem_alloc_aligned (i, CLIB_CACHE_LINE_BYTES);
- memset (vring->used, 0, i);
+ clib_memset (vring->used, 0, i);
ASSERT (vring->buffers == 0);
vec_validate_aligned (vring->buffers, sz, CLIB_CACHE_LINE_BYTES);
dhcp = (dhcp_header_t *) (udp + 1);
/* $$$ optimize, maybe */
- memset (ip, 0, sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp));
+ clib_memset (ip, 0, sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp));
ip->ip_version_and_header_length = 0x45;
ip->ttl = 128;
if (a->is_add)
{
pool_get (dcm->clients, c);
- memset (c, 0, sizeof (*c));
+ clib_memset (c, 0, sizeof (*c));
c->state = DHCP_DISCOVER;
c->sw_if_index = a->sw_if_index;
c->client_index = a->client_index;
dhcp_client_add_del_args_t _a, *a = &_a;
int rv;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->sw_if_index = sw_if_index;
a->client_index = client_index;
if (sw_if_index_set == 0)
return clib_error_return (0, "interface not specified");
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->sw_if_index = sw_if_index;
a->hostname = hostname;
hi0 = vnet_get_sup_hw_interface (vnm, original_sw_if_index);
ei0 = pool_elt_at_index (em->interfaces, hi0->hw_instance);
clib_memcpy (mac0->src_address, ei0->address, sizeof (ei0->address));
- memset (mac0->dst_address, 0xff, sizeof (mac0->dst_address));
+ clib_memset (mac0->dst_address, 0xff, sizeof (mac0->dst_address));
mac0->type = (si0->type == VNET_SW_INTERFACE_TYPE_SUB) ?
clib_net_to_host_u16 (0x8100) : clib_net_to_host_u16 (0x0800);
int is_del = 0;
int set_src = 0, set_server = 0;
- memset (&server_addr, 0, sizeof (server_addr));
- memset (&src_addr, 0, sizeof (src_addr));
+ clib_memset (&server_addr, 0, sizeof (server_addr));
+ clib_memset (&src_addr, 0, sizeof (src_addr));
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
ntohs (ip0->payload_length) - dhcpv6_ip6_palyoad_offset -
sizeof (*dhcpv60);
- memset (&report, 0, sizeof (report));
+ clib_memset (&report, 0, sizeof (report));
sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
if (sw_if_index >= vec_len (icm->client_state_by_sw_if_index))
vec_len (events[i].addresses) *
sizeof (vl_api_dhcp6_address_info_t);
vl_api_dhcp6_reply_event_t *event = clib_mem_alloc (event_size);
- memset (event, 0, event_size);
+ clib_memset (event, 0, event_size);
event->sw_if_index = htonl (events[i].body.sw_if_index);
event->server_index = htonl (events[i].body.server_index);
vec_free (prefix_list);
- memset (client_state, 0, sizeof (*client_state));
+ clib_memset (client_state, 0, sizeof (*client_state));
}
return 0;
sizeof (vl_api_dhcp6_pd_prefix_info_t);
vl_api_dhcp6_pd_reply_event_t *event =
clib_mem_alloc (event_size);
- memset (event, 0, event_size);
+ clib_memset (event, 0, event_size);
event->sw_if_index = htonl (events[i].body.sw_if_index);
event->server_index = htonl (events[i].body.server_index);
sizeof (*r1) + sizeof (*fwd_opt) +
sizeof (*u1) + sizeof (*id1) + u1->length);
- memset (ip1, 0, sizeof (*ip1));
+ clib_memset (ip1, 0, sizeof (*ip1));
ip1->ip_version_traffic_class_and_flow_label = 0x60;
ip1->payload_length = u1->length;
ip1->protocol = PROTO_UDP;
}
len = clib_net_to_host_u16 (r0->length);
- memset (ip1, 0, sizeof (*ip1));
+ clib_memset (ip1, 0, sizeof (*ip1));
copy_ip6_address (&ip1->dst_address, &client_address);
u1->checksum = 0;
u1->src_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_server);
hi0 = vnet_get_sup_hw_interface (vnm, original_sw_if_index);
ei0 = pool_elt_at_index (em->interfaces, hi0->hw_instance);
clib_memcpy (mac0->src_address, ei0->address, sizeof (ei0->address));
- memset (&mac0->dst_address, 0xff, sizeof (mac0->dst_address));
+ clib_memset (&mac0->dst_address, 0xff, sizeof (mac0->dst_address));
mac0->type = (si0->type == VNET_SW_INTERFACE_TYPE_SUB) ?
clib_net_to_host_u16 (0x8100) : clib_net_to_host_u16 (0x86dd);
mp = vl_msg_api_alloc (n);
if (!mp)
return;
- memset (mp, 0, n);
+ clib_memset (mp, 0, n);
mp->_vl_msg_id = ntohs (VL_API_DHCP_PROXY_DETAILS);
mp->context = context;
mp->count = count;
ctx = arg;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_DHCP_CLIENT_DETAILS);
mp->context = ctx->context;
rx_fib_index, ~0);
pool_get (dpm->dhcp_servers[proto], proxy);
- memset (proxy, 0, sizeof (*proxy));
+ clib_memset (proxy, 0, sizeof (*proxy));
new = 1;
dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] =
vnet_buffer (b)->sw_if_index[VLIB_TX] = 0; /* default VRF for now */
ip = vlib_buffer_get_current (b);
- memset (ip, 0, sizeof (*ip));
+ clib_memset (ip, 0, sizeof (*ip));
udp = (udp_header_t *) (ip + 1);
- memset (udp, 0, sizeof (*udp));
+ clib_memset (udp, 0, sizeof (*udp));
dns_request = (u8 *) (udp + 1);
VLIB_BUFFER_TOTAL_LENGTH_VALID | VNET_BUFFER_F_LOCALLY_ORIGINATED;
ip = vlib_buffer_get_current (b);
- memset (ip, 0, sizeof (*ip));
+ clib_memset (ip, 0, sizeof (*ip));
udp = (udp_header_t *) (ip + 1);
- memset (udp, 0, sizeof (*udp));
+ clib_memset (udp, 0, sizeof (*udp));
dns_request = (u8 *) (udp + 1);
}
pool_get (dm->entries, ep);
- memset (ep, 0, sizeof (*ep));
+ clib_memset (ep, 0, sizeof (*ep));
/* Note: consumes the name vector */
ep->name = name;
/* add new hash table entry */
pool_get (dm->entries, ep);
- memset (ep, 0, sizeof (*ep));
+ clib_memset (ep, 0, sizeof (*ep));
ep->name = format (0, "%s%c", name, 0);
_vec_len (ep->name) = vec_len (ep->name) - 1;
/* Need to recompute ep post pool-get */
ep = pool_elt_at_index (dm->entries, ep_index);
- memset (next_ep, 0, sizeof (*next_ep));
+ clib_memset (next_ep, 0, sizeof (*next_ep));
next_ep->name = vec_dup (cname);
vec_add1 (next_ep->name, 0);
_vec_len (next_ep->name) -= 1;
vlib_cli_output (vm, "%U", format_dns_reply, dns_reply_data, verbose);
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rv = vnet_dns_response_to_reply (dns_reply_data, rmp, 0 /* ttl-ptr */ );
if (pr->request_type == DNS_PEER_PENDING_NAME_TO_IP)
{
/* Quick and dirty way to dig up the A-record address. $$ FIXME */
- memset (rnr, 0, sizeof (*rnr));
+ clib_memset (rnr, 0, sizeof (*rnr));
if (vnet_dns_response_to_reply (ep->dns_response, rnr, &ttl))
{
/* clib_warning ("response_to_reply failed..."); */
}
else if (pr->request_type == DNS_PEER_PENDING_IP_TO_NAME)
{
- memset (rir, 0, sizeof (*rir));
+ clib_memset (rir, 0, sizeof (*rir));
if (vnet_dns_response_to_name (ep->dns_response, rir, &ttl))
{
/* clib_warning ("response_to_name failed..."); */
ip = vlib_buffer_get_current (b0);
udp = (udp_header_t *) (ip + 1);
dns_response = (u8 *) (udp + 1);
- memset (ip, 0, sizeof (*ip) + sizeof (*udp));
+ clib_memset (ip, 0, sizeof (*ip) + sizeof (*udp));
/*
* Start with the variadic portion of the exercise.
classify_dpo_t *cd;
pool_get_aligned(classify_dpo_pool, cd, CLIB_CACHE_LINE_BYTES);
- memset(cd, 0, sizeof(*cd));
+ clib_memset(cd, 0, sizeof(*cd));
return (cd);
}
l3_proxy_dpo_t *l3p;
pool_get_aligned(l3_proxy_dpo_pool, l3p, CLIB_CACHE_LINE_BYTES);
- memset(l3p, 0, sizeof(*l3p));
+ clib_memset(l3p, 0, sizeof(*l3p));
return (l3p);
}
load_balance_t *lb;
pool_get_aligned(load_balance_pool, lb, CLIB_CACHE_LINE_BYTES);
- memset(lb, 0, sizeof(*lb));
+ clib_memset(lb, 0, sizeof(*lb));
lb->lb_map = INDEX_INVALID;
lb->lb_urpf = INDEX_INVALID;
u32 ii;
pool_get_aligned(load_balance_map_pool, lbm, CLIB_CACHE_LINE_BYTES);
- memset(lbm, 0, sizeof(*lbm));
+ clib_memset(lbm, 0, sizeof(*lbm));
vec_validate(lbm->lbm_paths, vec_len(paths)-1);
mpls_disp_dpo_t *mdd;
pool_get_aligned(mpls_disp_dpo_pool, mdd, CLIB_CACHE_LINE_BYTES);
- memset(mdd, 0, sizeof(*mdd));
+ clib_memset(mdd, 0, sizeof(*mdd));
dpo_reset(&mdd->mdd_dpo);
mpls_label_dpo_t *mld;
pool_get_aligned(mpls_label_dpo_pool, mld, CLIB_CACHE_LINE_BYTES);
- memset(mld, 0, sizeof(*mld));
+ clib_memset(mld, 0, sizeof(*mld));
dpo_reset(&mld->mld_dpo);
receive_dpo_t *rd;
pool_get_aligned(receive_dpo_pool, rd, CLIB_CACHE_LINE_BYTES);
- memset(rd, 0, sizeof(*rd));
+ clib_memset(rd, 0, sizeof(*rd));
return (rd);
}
replicate_t *rep;
pool_get_aligned(replicate_pool, rep, CLIB_CACHE_LINE_BYTES);
- memset(rep, 0, sizeof(*rep));
+ clib_memset(rep, 0, sizeof(*rep));
vlib_validate_combined_counter(&(replicate_main.repm_counters),
replicate_get_index(rep));
if (dst_address)
clib_memcpy (h->dst_address, dst_address, sizeof (h->dst_address));
else
- memset (h->dst_address, ~0, sizeof (h->dst_address)); /* broadcast */
+ clib_memset (h->dst_address, ~0, sizeof (h->dst_address)); /* broadcast */
}
if (PREDICT_FALSE (!is_p2p) && sub_sw->sub.eth.flags.one_tag)
*sw_if_indexp = (u32) ~ 0;
- memset (address, 0, sizeof (address));
+ clib_memset (address, 0, sizeof (address));
/*
* Allocate a loopback instance. Either select on dynamically
u8 is_specified = 0;
u32 user_instance = 0;
- memset (mac_address, 0, sizeof (mac_address));
+ clib_memset (mac_address, 0, sizeof (mac_address));
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
path_flags = FIB_ROUTE_PATH_FLAG_NONE;
next_hop_via_label = ntohl (in->via_label);
- memset(out, 0, sizeof(*out));
+ clib_memset(out, 0, sizeof(*out));
out->frp_sw_if_index = ~0;
out->frp_proto = in->afi;
fib_api_path_encode (const fib_route_path_encode_t * api_rpath,
vl_api_fib_path_t *out)
{
- memset (out, 0, sizeof (*out));
+ clib_memset (out, 0, sizeof (*out));
switch (api_rpath->dpo.dpoi_type)
{
case DPO_RECEIVE:
fed = fib_entry_delegate_find_or_add(entry,
FIB_ENTRY_DELEGATE_ATTACHED_EXPORT);
pool_get(fib_ae_export_pool, export);
- memset(export, 0, sizeof(*export));
+ clib_memset(export, 0, sizeof(*export));
fed->fd_index = (export - fib_ae_export_pool);
export->faee_ei = connected;
fib_prefix_t *fep;
pool_get(fib_entry_pool, fib_entry);
- memset(fib_entry, 0, sizeof(*fib_entry));
+ clib_memset(fib_entry, 0, sizeof(*fib_entry));
fib_node_init(&fib_entry->fe_node,
FIB_NODE_TYPE_ENTRY);
fib_path_t *path;
pool_get(fib_path_pool, path);
- memset(path, 0, sizeof(*path));
+ clib_memset(path, 0, sizeof(*path));
fib_node_init(&path->fp_node,
FIB_NODE_TYPE_PATH);
fib_path_t *path;
pool_get(fib_path_pool, path);
- memset(path, 0, sizeof(*path));
+ clib_memset(path, 0, sizeof(*path));
fib_node_init(&path->fp_node,
FIB_NODE_TYPE_PATH);
path->fp_oper_flags = FIB_PATH_OPER_FLAG_NONE;
path->fp_pl_index = path_list_index;
path->fp_via_fib = FIB_NODE_INDEX_INVALID;
- memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
+ clib_memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
dpo_reset(&path->fp_dpo);
return (fib_path_get_index(path));
fib_path_list_t *path_list;
pool_get(fib_path_list_pool, path_list);
- memset(path_list, 0, sizeof(*path_list));
+ clib_memset(path_list, 0, sizeof(*path_list));
fib_node_init(&path_list->fpl_node,
FIB_NODE_TYPE_PATH_LIST);
vnet_main_t *vnm;
vnm = vnet_get_main ();
- memset(rpath, 0, sizeof(*rpath));
+ clib_memset(rpath, 0, sizeof(*rpath));
rpath->frp_weight = 1;
rpath->frp_sw_if_index = ~0;
fib_urpf_list_t *urpf;
pool_get(fib_urpf_list_pool, urpf);
- memset(urpf, 0, sizeof(*urpf));
+ clib_memset(urpf, 0, sizeof(*urpf));
urpf->furpf_locks++;
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
- memset(fib_walk_hist_vists_per_walk, 0, sizeof(fib_walk_hist_vists_per_walk));
- memset(fib_walk_history, 0, sizeof(fib_walk_history));
- memset(fib_walk_work_time_taken, 0, sizeof(fib_walk_work_time_taken));
- memset(fib_walk_work_nodes_visited, 0, sizeof(fib_walk_work_nodes_visited));
- memset(fib_walk_sleep_lengths, 0, sizeof(fib_walk_sleep_lengths));
+ clib_memset(fib_walk_hist_vists_per_walk, 0, sizeof(fib_walk_hist_vists_per_walk));
+ clib_memset(fib_walk_history, 0, sizeof(fib_walk_history));
+ clib_memset(fib_walk_work_time_taken, 0, sizeof(fib_walk_work_time_taken));
+ clib_memset(fib_walk_work_nodes_visited, 0, sizeof(fib_walk_work_nodes_visited));
+ clib_memset(fib_walk_sleep_lengths, 0, sizeof(fib_walk_sleep_lengths));
return (NULL);
}
void *old_heap;
pool_get(ip4_main.fibs, fib_table);
- memset(fib_table, 0, sizeof(*fib_table));
+ clib_memset(fib_table, 0, sizeof(*fib_table));
old_heap = clib_mem_set_heap (ip4_main.mtrie_mheap);
pool_get_aligned(ip4_main.v4_fibs, v4_fib, CLIB_CACHE_LINE_BYTES);
pool_get(ip6_main.fibs, fib_table);
pool_get_aligned(ip6_main.v6_fibs, v6_fib, CLIB_CACHE_LINE_BYTES);
- memset(fib_table, 0, sizeof(*fib_table));
- memset(v6_fib, 0, sizeof(*v6_fib));
+ clib_memset(fib_table, 0, sizeof(*fib_table));
+ clib_memset(v6_fib, 0, sizeof(*v6_fib));
ASSERT((fib_table - ip6_main.fibs) ==
(v6_fib - ip6_main.v6_fibs));
vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
- memset (ca, 0, sizeof(*ca));
+ clib_memset (ca, 0, sizeof(*ca));
ca->fib_index = fib->index;
BV(clib_bihash_foreach_key_value_pair)
ASSERT((fib_table - mpls_main.fibs) ==
(mf - mpls_main.mpls_fibs));
- memset(fib_table, 0, sizeof(*fib_table));
+ clib_memset(fib_table, 0, sizeof(*fib_table));
fib_table->ft_proto = FIB_PROTOCOL_MPLS;
fib_table->ft_index = (fib_table - mpls_main.fibs);
/* *INDENT-ON* */
hash_free (f->private_data);
- memset (f, 0, sizeof (*f));
+ clib_memset (f, 0, sizeof (*f));
pool_put (fm->global_flow_pool, f);
return 0;
}
int rv;
u8 prot;
- memset (&flow, 0, sizeof (vnet_flow_t));
+ clib_memset (&flow, 0, sizeof (vnet_flow_t));
flow.index = ~0;
flow.actions = 0;
flow.ip4_n_tuple.protocol = ~0;
if (is_ip4)
last_key4.as_u64 = ~0;
else
- memset (&last_key6, 0xff, sizeof (last_key6));
+ clib_memset (&last_key6, 0xff, sizeof (last_key6));
from = vlib_frame_vector_args (from_frame);
n_left_from = from_frame->n_vectors;
return VNET_API_ERROR_INVALID_DECAP_NEXT;
pool_get_aligned (vxm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
/* copy from arg structure */
#define _(x) t->x = a->x;
clib_error_t *error = NULL;
/* Cant "universally zero init" (={0}) due to GCC bug 53119 */
- memset (&local, 0, sizeof local);
- memset (&remote, 0, sizeof remote);
+ clib_memset (&local, 0, sizeof local);
+ clib_memset (&remote, 0, sizeof remote);
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->is_ip6 = ipv6_set;
u8 is_ipv6 = !ip46_address_is_ip4 (&t->remote);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_GENEVE_TUNNEL_DETAILS);
if (is_ipv6)
{
ip_main_t *im = &ip_main;
ip_protocol_info_t *pi;
- memset (gm, 0, sizeof (gm[0]));
+ clib_memset (gm, 0, sizeof (gm[0]));
gm->vlib_main = vm;
gm->vnet_main = vnet_get_main ();
rv = VNET_API_ERROR_SAME_SRC_DST;
goto out;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = mp->is_add;
a->tunnel_type = mp->tunnel_type;
fib_table_t *ft;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = htons (VL_API_GRE_TUNNEL_DETAILS);
if (!is_ipv6)
{
return VNET_API_ERROR_IF_ALREADY_EXISTS;
pool_get_aligned (gm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
/* Reconcile the real dev_instance and a possible requested instance */
u32 t_idx = t - gm->tunnels; /* tunnel index (or instance) */
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->outer_fib_id = outer_fib_id;
a->tunnel_type = t_type;
vnet_interface_main_t *im = &gm->vnet_main->interface_main;
if (!is_ipv6)
- memset (&cached_tunnel_key.gtk_v4, 0xff,
- sizeof (cached_tunnel_key.gtk_v4));
+ clib_memset (&cached_tunnel_key.gtk_v4, 0xff,
+ sizeof (cached_tunnel_key.gtk_v4));
else
- memset (&cached_tunnel_key.gtk_v6, 0xff,
- sizeof (cached_tunnel_key.gtk_v6));
+ clib_memset (&cached_tunnel_key.gtk_v6, 0xff,
+ sizeof (cached_tunnel_key.gtk_v6));
from = vlib_frame_vector_args (from_frame);
n_left_from = from_frame->n_vectors;
{
hdlc_main_t *pm = &hdlc_main;
- memset (pm, 0, sizeof (pm[0]));
+ clib_memset (pm, 0, sizeof (pm[0]));
pm->vlib_main = vm;
pm->protocol_info_by_name = hash_create_string (0, sizeof (uword));
char *tx_node_name = NULL, *output_node_name = NULL;
pool_get (im->hw_interfaces, hw);
- memset (hw, 0, sizeof (*hw));
+ clib_memset (hw, 0, sizeof (*hw));
hw_index = hw - im->hw_interfaces;
hw->hw_if_index = hw_index;
.is_deleted = 0,
};
- memset (&r, 0, sizeof (r));
+ clib_memset (&r, 0, sizeof (r));
r.type = VLIB_NODE_TYPE_INTERNAL;
r.runtime_data = &rt;
r.runtime_data_bytes = sizeof (rt);
vnet_get_sup_hw_interface (am->vnet_main, swif->sw_if_index);
vl_api_sw_interface_details_t *mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_DETAILS);
mp->sw_if_index = ntohl (swif->sw_if_index);
mp->sup_sw_if_index = ntohl (swif->sup_sw_if_index);
u16 outer_tag = 0;
u16 b_vlanid = 0;
u32 i_sid = 0;
- memset (ð_hdr, 0, sizeof (eth_hdr));
+ clib_memset (ð_hdr, 0, sizeof (eth_hdr));
if (!l2pbb_get (am->vlib_main, am->vnet_main, swif->sw_if_index,
&vtr_op, &outer_tag, ð_hdr, &b_vlanid, &i_sid))
vl_api_sw_interface_get_table_reply_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_GET_TABLE_REPLY);
mp->context = context;
mp->retval = htonl (retval);
vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm,
swif->sw_if_index);
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
mp->sw_if_index = ntohl (swif->sw_if_index);
mp->client_index = reg->client_index;
{
vl_api_sw_interface_rx_placement_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_RX_PLACEMENT_DETAILS);
mp->sw_if_index = htonl (sw_if_index);
goto out;
}
- memset (&template, 0, sizeof (template));
+ clib_memset (&template, 0, sizeof (template));
template.type = VNET_SW_INTERFACE_TYPE_SUB;
template.sup_sw_if_index = hi->sw_if_index;
template.sub.id = id;
goto out;
}
- memset (&template, 0, sizeof (template));
+ clib_memset (&template, 0, sizeof (template));
template.type = VNET_SW_INTERFACE_TYPE_SUB;
template.sup_sw_if_index = sw_if_index;
template.sub.id = sub_id;
goto done;
}
- memset (&template, 0, sizeof (template));
+ clib_memset (&template, 0, sizeof (template));
template.sub.eth.raw_flags = 0;
if (unformat (input, "%d default", &id_min))
if (im->pcap_filename == 0)
im->pcap_filename = format (0, "/tmp/drop.pcap%c", 0);
- memset (&im->pcap_main, 0, sizeof (im->pcap_main));
+ clib_memset (&im->pcap_main, 0, sizeof (im->pcap_main));
im->pcap_main.file_name = (char *) im->pcap_filename;
im->pcap_main.n_packets_to_capture = 100;
if (im->pcap_pkts_to_capture)
foreach_icmp4_code;
#undef _
- memset (cm->ip4_input_next_index_by_type,
- ICMP_INPUT_NEXT_ERROR, sizeof (cm->ip4_input_next_index_by_type));
+ clib_memset (cm->ip4_input_next_index_by_type,
+ ICMP_INPUT_NEXT_ERROR,
+ sizeof (cm->ip4_input_next_index_by_type));
ip4_icmp_register_type (vm, ICMP4_echo_request,
ip4_icmp_echo_request_node.index);
foreach_icmp6_code;
#undef _
- memset (cm->input_next_index_by_type,
- ICMP_INPUT_NEXT_DROP, sizeof (cm->input_next_index_by_type));
- memset (cm->max_valid_code_by_type, 0, sizeof (cm->max_valid_code_by_type));
+ clib_memset (cm->input_next_index_by_type,
+ ICMP_INPUT_NEXT_DROP, sizeof (cm->input_next_index_by_type));
+ clib_memset (cm->max_valid_code_by_type, 0,
+ sizeof (cm->max_valid_code_by_type));
#define _(a,n,t) cm->max_valid_code_by_type[ICMP6_##a] = clib_max (cm->max_valid_code_by_type[ICMP6_##a], n);
foreach_icmp6_code;
#undef _
- memset (cm->min_valid_hop_limit_by_type, 0,
- sizeof (cm->min_valid_hop_limit_by_type));
+ clib_memset (cm->min_valid_hop_limit_by_type, 0,
+ sizeof (cm->min_valid_hop_limit_by_type));
cm->min_valid_hop_limit_by_type[ICMP6_router_solicitation] = 255;
cm->min_valid_hop_limit_by_type[ICMP6_router_advertisement] = 255;
cm->min_valid_hop_limit_by_type[ICMP6_neighbor_solicitation] = 255;
cm->min_valid_hop_limit_by_type[ICMP6_neighbor_advertisement] = 255;
cm->min_valid_hop_limit_by_type[ICMP6_redirect] = 255;
- memset (cm->min_valid_length_by_type, sizeof (icmp46_header_t),
- sizeof (cm->min_valid_length_by_type));
+ clib_memset (cm->min_valid_length_by_type, sizeof (icmp46_header_t),
+ sizeof (cm->min_valid_length_by_type));
cm->min_valid_length_by_type[ICMP6_router_solicitation] =
sizeof (icmp6_neighbor_discovery_header_t);
cm->min_valid_length_by_type[ICMP6_router_advertisement] =
ip = p;
}
- memset (ip, 0, sizeof (ip[0]));
+ clib_memset (ip, 0, sizeof (ip[0]));
ip->ip_version_and_header_length = IP4_VERSION_AND_HEADER_LENGTH_NO_OPTIONS;
if (!unformat (input, "%U: %U -> %U",
{
ethernet_arp_header_t h;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
/* Set target ethernet address to all zeros. */
- memset (h.ip4_over_ethernet[1].ethernet, 0,
- sizeof (h.ip4_over_ethernet[1].ethernet));
+ clib_memset (h.ip4_over_ethernet[1].ethernet, 0,
+ sizeof (h.ip4_over_ethernet[1].ethernet));
#define _16(f,v) h.f = clib_host_to_net_u16 (v);
#define _8(f,v) h.f = v;
*/ \
p->n_non_empty_leafs = (prefix_len > ply_base_len ? \
ARRAY_LEN (p->leaves) : 0); \
- memset (p->dst_address_bits_of_leaves, prefix_len, \
+ clib_memset (p->dst_address_bits_of_leaves, prefix_len, \
sizeof (p->dst_address_bits_of_leaves)); \
p->dst_address_bits_base = ply_base_len; \
\
ply_16_init (ip4_fib_mtrie_16_ply_t * p,
ip4_fib_mtrie_leaf_t init, uword prefix_len)
{
- memset (p->dst_address_bits_of_leaves, prefix_len,
- sizeof (p->dst_address_bits_of_leaves));
+ clib_memset (p->dst_address_bits_of_leaves, prefix_len,
+ sizeof (p->dst_address_bits_of_leaves));
PLY_INIT_LEAVES (p);
}
/* See if header is all fixed and specified except for
checksum field. */
- memset (&cmp_mask, ~0, sizeof (cmp_mask));
+ clib_memset (&cmp_mask, ~0, sizeof (cmp_mask));
cmp_mask.checksum = 0;
pg_edit_group_get_fixed_packet_data (s, group_index,
;
else if (unformat (line_input, "via %U",
unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
- memset (&nh, 0, sizeof (nh));
+ clib_memset (&nh, 0, sizeof (nh));
else
{
error = unformat_parse_error (line_input);
else
{
pool_get (rt->pool, reass);
- memset (reass, 0, sizeof (*reass));
+ clib_memset (reass, 0, sizeof (*reass));
reass->id =
((u64) os_get_thread_index () * 1000000000) + rt->id_counter;
++rt->id_counter;
if (ip4_reass_main.max_reass_n > 0 && new_nbuckets > old_nbuckets)
{
clib_bihash_16_8_t new_hash;
- memset (&new_hash, 0, sizeof (new_hash));
+ clib_memset (&new_hash, 0, sizeof (new_hash));
ip4_rehash_cb_ctx ctx;
ctx.failure = 0;
ctx.new_hash = &new_hash;
protocol_port_range_dpo_t *ppr_dpo;
pool_get_aligned (ppr_dpo_pool, ppr_dpo, CLIB_CACHE_LINE_BYTES);
- memset (ppr_dpo, 0, sizeof (*ppr_dpo));
+ clib_memset (ppr_dpo, 0, sizeof (*ppr_dpo));
ppr_dpo->n_free_ranges = N_PORT_RANGES_PER_DPO;
-2 * (sizeof (*ip6) - sizeof (*ip4)) -
sizeof (*inner_frag));
ip6 = vlib_buffer_get_current (p);
- clib_memcpy (u8_ptr_add (ip6, sizeof (*ip6) - sizeof (*ip4)), ip4,
- 20 + 8);
+ memmove (u8_ptr_add (ip6, sizeof (*ip6) - sizeof (*ip4)), ip4,
+ 20 + 8);
ip4 =
(ip4_header_t *) u8_ptr_add (ip6, sizeof (*ip6) - sizeof (*ip4));
icmp = (icmp46_header_t *) (ip4 + 1);
{
vlib_buffer_advance (p, -2 * (sizeof (*ip6) - sizeof (*ip4)));
ip6 = vlib_buffer_get_current (p);
- clib_memcpy (u8_ptr_add (ip6, sizeof (*ip6) - sizeof (*ip4)), ip4,
- 20 + 8);
+ memmove (u8_ptr_add (ip6, sizeof (*ip6) - sizeof (*ip4)), ip4,
+ 20 + 8);
ip4 =
(ip4_header_t *) u8_ptr_add (ip6, sizeof (*ip6) - sizeof (*ip4));
icmp = (icmp46_header_t *) u8_ptr_add (ip4, sizeof (*ip4));
ip6_address_and_mask_t *am = va_arg (*args, ip6_address_and_mask_t *);
ip6_address_t addr, mask;
- memset (&addr, 0, sizeof (ip6_address_t));
- memset (&mask, 0, sizeof (ip6_address_t));
+ clib_memset (&addr, 0, sizeof (ip6_address_t));
+ clib_memset (&mask, 0, sizeof (ip6_address_t));
if (unformat (input, "any"))
;
ip = p;
}
- memset (ip, 0, sizeof (ip[0]));
+ clib_memset (ip, 0, sizeof (ip[0]));
ip->ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (6 << 28);
ip6_hop_by_hop_init (vlib_main_t * vm)
{
ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main;
- memset (hm->options, 0, sizeof (hm->options));
- memset (hm->trace, 0, sizeof (hm->trace));
+ clib_memset (hm->options, 0, sizeof (hm->options));
+ clib_memset (hm->trace, 0, sizeof (hm->trace));
hm->next_override = IP6_LOOKUP_NEXT_POP_HOP_BY_HOP;
return (0);
}
{
icmp6_neighbor_solicitation_header_t p;
- memset (&p, 0, sizeof (p));
+ clib_memset (&p, 0, sizeof (p));
p.ip.ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (0x6 << 28);
hm->unix_time_0 = (u32) time (0); /* Store starting time */
hm->vlib_time_0 = vlib_time_now (vm);
hm->ioam_flag = IOAM_HBYH_MOD;
- memset (hm->add_options, 0, sizeof (hm->add_options));
- memset (hm->pop_options, 0, sizeof (hm->pop_options));
- memset (hm->options_size, 0, sizeof (hm->options_size));
+ clib_memset (hm->add_options, 0, sizeof (hm->add_options));
+ clib_memset (hm->pop_options, 0, sizeof (hm->pop_options));
+ clib_memset (hm->options_size, 0, sizeof (hm->options_size));
vnet_classify_register_unformat_opaque_index_fn (unformat_opaque_ioam);
u8 i;
pool_get (hm->flows, flow);
- memset (flow, 0, sizeof (flow_data_t));
+ clib_memset (flow, 0, sizeof (flow_data_t));
index = flow - hm->flows;
strncpy ((char *) flow->flow_name, (char *) flow_name, 31);
vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
- memset (ca, 0, sizeof (*ca));
+ clib_memset (ca, 0, sizeof (*ca));
ca->fib_index = fib_index;
BV (clib_bihash_foreach_key_value_pair)
nm->if_radv_pool_index_by_sw_if_index[sw_if_index] = ri;
/* initialize default values (most of which are zero) */
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
a->sw_if_index = sw_if_index;
a->max_radv_interval = DEF_MAX_RADV_INTERVAL;
ip0 = (ip6_header_t *) & rp0->ip;
rh0 = (icmp6_multicast_listener_report_header_t *) & rp0->report_hdr;
- memset (rp0, 0x0, sizeof (icmp6_multicast_listener_report_packet_t));
+ clib_memset (rp0, 0x0, sizeof (icmp6_multicast_listener_report_packet_t));
ip0->ip_version_traffic_class_and_flow_label =
clib_host_to_net_u32 (0x6 << 28);
h0 = vlib_buffer_get_current (b0);
- memset (h0, 0, sizeof (icmp6_router_solicitation_header_t));
+ clib_memset (h0, 0, sizeof (icmp6_router_solicitation_header_t));
h0->ip.ip_version_traffic_class_and_flow_label = clib_host_to_net_u32 (0x6 << 28);
h0->ip.payload_length = clib_host_to_net_u16 (sizeof (icmp6_router_solicitation_header_t)
if (time_now - im->nd_throttle_last_seed_change_time[thread_index] > 1e-3)
{
(void) random_u64 (&im->nd_throttle_seeds[thread_index]);
- memset (im->nd_throttle_bitmaps[thread_index], 0,
- ND_THROTTLE_BITS / BITS (u8));
+ clib_memset (im->nd_throttle_bitmaps[thread_index], 0,
+ ND_THROTTLE_BITS / BITS (u8));
im->nd_throttle_last_seed_change_time[thread_index] = time_now;
}
mhash_set (&radv_info->address_to_prefix_index, prefix_addr, pi,
/* old_value */ 0);
- memset (prefix, 0x0, sizeof (ip6_radv_prefix_t));
+ clib_memset (prefix, 0x0, sizeof (ip6_radv_prefix_t));
prefix->prefix_len = prefix_len;
clib_memcpy (&prefix->prefix, prefix_addr, sizeof (ip6_address_t));
/* add call backs */
ip6_add_del_interface_address_callback_t cb;
- memset (&cb, 0x0, sizeof (ip6_add_del_interface_address_callback_t));
+ clib_memset (&cb, 0x0, sizeof (ip6_add_del_interface_address_callback_t));
/* when an interface address changes... */
cb.function = ip6_neighbor_add_del_interface_address;
{
int i, byte, bit, bitnum;
ASSERT (width <= 128);
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
for (i = 0; i < width; i++)
{
bitnum = (7 - (i & 7));
;
else if (unformat (line_input, "via %U",
unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
- memset (&nh, 0, sizeof (nh));
+ clib_memset (&nh, 0, sizeof (nh));
else
{
error = unformat_parse_error (line_input);
else
{
pool_get (rt->pool, reass);
- memset (reass, 0, sizeof (*reass));
+ clib_memset (reass, 0, sizeof (*reass));
reass->id =
((u64) os_get_thread_index () * 1000000000) + rt->id_counter;
++rt->id_counter;
if (ip6_reass_main.max_reass_n > 0 && new_nbuckets > old_nbuckets)
{
clib_bihash_48_8_t new_hash;
- memset (&new_hash, 0, sizeof (new_hash));
+ clib_memset (&new_hash, 0, sizeof (new_hash));
ip6_rehash_cb_ctx ctx;
ctx.failure = 0;
ctx.new_hash = &new_hash;
vl_api_ip_neighbor_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_NEIGHBOR_DETAILS);
mp->context = context;
mp->sw_if_index = htonl (sw_if_index);
mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
if (!mp)
return;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_FIB_DETAILS);
mp->context = context;
mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
if (!mp)
return;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP6_FIB_DETAILS);
mp->context = context;
mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
if (!mp)
return;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_MFIB_DETAILS);
mp->context = context;
mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
if (!mp)
return;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP6_MFIB_DETAILS);
mp->context = context;
{
ip46_address_t nh;
- memset (&nh, 0, sizeof (nh));
+ clib_memset (&nh, 0, sizeof (nh));
if (mp->is_ip6)
{
clib_memcpy (&pfx.fp_addr.ip4, mp->dst_address, sizeof (pfx.fp_addr.ip4));
ip46_address_t nh;
- memset (&nh, 0, sizeof (nh));
+ clib_memset (&nh, 0, sizeof (nh));
memcpy (&nh.ip4, mp->next_hop_address, sizeof (nh.ip4));
n_labels = mp->next_hop_n_out_labels;
clib_memcpy (&pfx.fp_addr.ip6, mp->dst_address, sizeof (pfx.fp_addr.ip6));
ip46_address_t nh;
- memset (&nh, 0, sizeof (nh));
+ clib_memset (&nh, 0, sizeof (nh));
memcpy (&nh.ip6, mp->next_hop_address, sizeof (nh.ip6));
n_labels = mp->next_hop_n_out_labels;
sizeof (pfx.fp_grp_addr.ip4));
clib_memcpy (&pfx.fp_src_addr.ip4, mp->src_address,
sizeof (pfx.fp_src_addr.ip4));
- memset (&nh.ip6, 0, sizeof (nh.ip6));
+ clib_memset (&nh.ip6, 0, sizeof (nh.ip6));
clib_memcpy (&nh.ip4, mp->nh_address, sizeof (nh.ip4));
if (!ip46_address_is_zero (&pfx.fp_src_addr))
pfx.fp_len = 64;
vl_api_ip_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_DETAILS);
mp->sw_if_index = ntohl (sw_if_index);
vl_api_ip_address_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_ADDRESS_DETAILS);
if (is_ipv6)
vl_api_ip_unnumbered_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_UNNUMBERED_DETAILS);
mp->context = context;
vl_api_ip6nd_proxy_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP6ND_PROXY_DETAILS);
mp->context = context;
mp->sw_if_index = htonl (sw_if_index);
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MFIB_SIGNAL_DETAILS);
mp->context = context;
int rv = 0;
clib_error_t *error;
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
ip_set (&args.prefix.fp_addr, mp->ip, mp->is_ip4);
args.prefix.fp_len = mp->plen ? mp->plen : (mp->is_ip4 ? 32 : 128);
args.sw_if_index = clib_net_to_host_u32 (mp->sw_if_index);
if (!mp)
return 1;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_CONTAINER_PROXY_DETAILS);
mp->context = ctx->context;
if (reg && vl_api_can_send_msg (vl_reg))
{
vl_api_ip4_arp_event_t * event = vl_msg_api_alloc (sizeof *event);
- memset (event, 0, sizeof *event);
+ clib_memset (event, 0, sizeof *event);
event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT);
event->client_index = reg->client_index;
event->pid = reg->client_pid;
if (vl_reg && vl_api_can_send_msg (vl_reg))
{
vl_api_ip6_nd_event_t * event = vl_msg_api_alloc (sizeof *event);
- memset (event, 0, sizeof *event);
+ clib_memset (event, 0, sizeof *event);
event->_vl_msg_id = htons (VL_API_IP6_ND_EVENT);
event->client_index = reg->client_index;
event->pid = reg->client_pid;
sizeof (vl_api_ip6_ra_prefix_info_t);
vl_api_ip6_ra_event_t *event =
vl_msg_api_alloc (event_size);
- memset (event, 0, event_size);
+ clib_memset (event, 0, event_size);
event->_vl_msg_id = htons (VL_API_IP6_RA_EVENT);
event->client_index = reg->client_index;
event->pid = reg->client_pid;
pool_put (am->arp_events, event);
goto reply;
}
- memset (event, 0, sizeof (*event));
+ clib_memset (event, 0, sizeof (*event));
/* Python API expects events to have no context */
event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT);
pool_put (am->nd_events, event);
goto reply;
}
- memset (event, 0, sizeof (*event));
+ clib_memset (event, 0, sizeof (*event));
event->_vl_msg_id = ntohs (VL_API_IP6_ND_EVENT);
event->client_index = mp->client_index;
ctx = data;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_PROXY_ARP_DETAILS);
mp->context = ctx->context;
mp->proxy.vrf_id = htonl (fib_index);
ctx = data;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_PROXY_ARP_INTFC_DETAILS);
mp->context = ctx->context;
mp->sw_if_index = htonl (si->sw_if_index);
return;
vl_api_ip_reassembly_get_reply_t *rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_IP_REASSEMBLY_GET_REPLY);
rmp->context = mp->context;
rmp->retval = 0;
ip_main_t *im = &ip_main;
clib_error_t *error = 0;
- memset (im, 0, sizeof (im[0]));
+ clib_memset (im, 0, sizeof (im[0]));
{
ip_protocol_info_t *pi;
u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
ip_neighbor_scan_arg_t arg;
- memset (&arg, 0, sizeof (arg));
+ clib_memset (&arg, 0, sizeof (arg));
arg.mode = IP_SCAN_V46_NEIGHBORS;
/* Get a line of input. */
switch (clib_net_to_host_u32 (af))
{
case ADDRESS_IP4:
- memset (out, 0, sizeof (*out));
+ clib_memset (out, 0, sizeof (*out));
clib_memcpy (&out->ip4, &in->ip4, sizeof (out->ip4));
type = IP46_TYPE_IP4;
break;
u32 hi; /* head index */
pool_get (lm->if_address_pool, a);
- memset (a, ~0, sizeof (a[0]));
+ clib_memset (a, ~0, sizeof (a[0]));
ai = a - lm->if_address_pool;
hi = pi = lm->if_address_pool_index_by_sw_if_index[sw_if_index];
is_del = 0;
table_id = 0;
count = 1;
- memset (&pfx, 0, sizeof (pfx));
+ clib_memset (&pfx, 0, sizeof (pfx));
/* Get a line of input. */
if (!unformat_user (main_input, unformat_line_input, line_input))
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
- memset (&rpath, 0, sizeof (rpath));
+ clib_memset (&rpath, 0, sizeof (rpath));
if (unformat (line_input, "table %d", &table_id))
;
vnm = vnet_get_main ();
is_del = 0;
table_id = 0;
- memset (&pfx, 0, sizeof (pfx));
- memset (&rpath, 0, sizeof (rpath));
+ clib_memset (&pfx, 0, sizeof (pfx));
+ clib_memset (&rpath, 0, sizeof (rpath));
rpath.frp_sw_if_index = ~0;
/* Get a line of input. */
unformat_ip4_address,
&pfx.fp_grp_addr.ip4, &pfx.fp_len))
{
- memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
+ clib_memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
pfx.fp_proto = FIB_PROTOCOL_IP4;
}
else if (unformat (line_input, "%U/%d",
unformat_ip6_address,
&pfx.fp_grp_addr.ip6, &pfx.fp_len))
{
- memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
+ clib_memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
pfx.fp_proto = FIB_PROTOCOL_IP6;
}
else if (unformat (line_input, "%U",
unformat_ip4_address, &pfx.fp_grp_addr.ip4))
{
- memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
+ clib_memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
pfx.fp_proto = FIB_PROTOCOL_IP4;
pfx.fp_len = 32;
}
else if (unformat (line_input, "%U",
unformat_ip6_address, &pfx.fp_grp_addr.ip6))
{
- memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
+ clib_memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
pfx.fp_proto = FIB_PROTOCOL_IP6;
pfx.fp_len = 128;
}
unformat_vnet_sw_interface, vnm,
&rpath.frp_sw_if_index))
{
- memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
+ clib_memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
rpath.frp_weight = 1;
}
else if (unformat (line_input, "via local"))
{
- memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
+ clib_memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
rpath.frp_sw_if_index = ~0;
rpath.frp_weight = 1;
rpath.frp_flags |= FIB_ROUTE_PATH_LOCAL;
vnm = vnet_get_main ();
is_del = 0;
sw_if_index = ~0;
- memset (&pfx, 0, sizeof (pfx));
+ clib_memset (&pfx, 0, sizeof (pfx));
/* Get a line of input. */
if (!unformat_user (main_input, unformat_line_input, line_input))
punt_client_t *v = is_ip4 ? pm->clients_by_dst_port4 :
pm->clients_by_dst_port6;
- memset (&c, 0, sizeof (c));
+ clib_memset (&c, 0, sizeof (c));
memcpy (c.caddr.sun_path, client_pathname, sizeof (c.caddr.sun_path));
c.caddr.sun_family = AF_UNIX;
c.port = port;
return clib_error_return (0, "socket error");
}
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
addr.sun_family = AF_UNIX;
if (*socket_path == '\0')
{
return;;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_IPFIX_EXPORTER_DETAILS);
rmp->context = mp->context;
memcpy (rmp->collector_address, frm->ipfix_collector.data,
return;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_IPFIX_CLASSIFY_STREAM_DETAILS);
rmp->context = mp->context;
rmp->domain_id = htonl (fcm->domain_id);
goto out;
}
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
table = 0;
int i;
ipfix_classify_table_t *table = &fcm->tables[table_index];
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IPFIX_CLASSIFY_TABLE_DETAILS);
mp->context = context;
mp->table_id = htonl (table->classify_table_index);
if (fcm->src_port == 0)
clib_error_return (0, "call 'set ipfix classify stream' first");
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
return VNET_API_ERROR_IF_ALREADY_EXISTS;
pool_get_aligned (gm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
/* Reconcile the real dev_instance and a possible requested instance */
u32 t_idx = t - gm->tunnels; /* tunnel index (or instance) */
{
ipip_main_t *gm = &ipip_main;
- memset (gm, 0, sizeof (gm[0]));
+ clib_memset (gm, 0, sizeof (gm[0]));
gm->vlib_main = vm;
gm->vnet_main = vnet_get_main ();
gm->tunnel_by_key =
fib_table_t *ft;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = htons (VL_API_IPIP_TUNNEL_DETAILS);
if (is_ipv6)
{
/* Get tunnel index */
pool_get_aligned (gm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
u32 t_idx = t - gm->tunnels; /* tunnel index (or instance) */
/* Init tunnel struct */
u64 key;
ipsec_add_del_ipsec_gre_tunnel_args_t args;
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
args.is_add = a->is_add;
args.local_sa_id = a->lsa;
args.remote_sa_id = a->rsa;
return VNET_API_ERROR_INVALID_VALUE;
pool_get_aligned (igm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
if (vec_len (igm->free_ipsec_gre_tunnel_hw_if_indices) > 0)
{
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->lsa = lsa;
a->rsa = rsa;
ipsec_gre_main_t *igm = &ipsec_gre_main;
clib_error_t *error;
- memset (igm, 0, sizeof (igm[0]));
+ clib_memset (igm, 0, sizeof (igm[0]));
igm->vlib_main = vm;
igm->vnet_main = vnet_get_main ();
goto out;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
/* ip addresses sent in network byte order */
clib_memcpy (&(a->src), mp->src_address, 4);
vl_api_ipsec_gre_tunnel_details_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_IPSEC_GRE_TUNNEL_DETAILS);
clib_memcpy (rmp->src_address, &(t->tunnel_src), 4);
clib_memcpy (rmp->dst_address, &(t->tunnel_dst), 4);
{
u8 sig[64];
u8 digest[64];
- memset (sig, 0, sizeof (sig));
- memset (digest, 0, sizeof (digest));
+ clib_memset (sig, 0, sizeof (sig));
+ clib_memset (digest, 0, sizeof (digest));
u8 *icv = ah0->auth_data;
memcpy (digest, icv, icv_size);
- memset (icv, 0, icv_size);
+ clib_memset (icv, 0, icv_size);
if (is_ip6)
{
{
ip_hdr_size = sizeof (ip4_header_t);
oh0 = vlib_buffer_get_current (i_b0);
- memset (oh0, 0, sizeof (ip4_and_ah_header_t));
+ clib_memset (oh0, 0, sizeof (ip4_and_ah_header_t));
if (PREDICT_TRUE (sa0->is_tunnel))
{
}
u8 sig[64];
- memset (sig, 0, sizeof (sig));
+ clib_memset (sig, 0, sizeof (sig));
u8 *digest =
vlib_buffer_get_current (i_b0) + ip_hdr_size +
sizeof (ah_header_t);
- memset (digest, 0, icv_size);
+ clib_memset (digest, 0, icv_size);
unsigned size = hmac_calc (sa0->integ_alg, sa0->integ_key,
sa0->integ_key_len,
ipsec_proto_main_t *em = &ipsec_proto_main;
vlib_thread_main_t *tm = vlib_get_thread_main ();
- memset (em, 0, sizeof (em[0]));
+ clib_memset (em, 0, sizeof (em[0]));
vec_validate (em->ipsec_proto_main_crypto_algs, IPSEC_CRYPTO_N_ALG - 1);
em->ipsec_proto_main_crypto_algs[IPSEC_CRYPTO_ALG_AES_CBC_128].type =
u8 sig[64];
int icv_size =
em->ipsec_proto_main_integ_algs[sa0->integ_alg].trunc_size;
- memset (sig, 0, sizeof (sig));
+ clib_memset (sig, 0, sizeof (sig));
u8 *icv =
vlib_buffer_get_current (i_b0) + i_b0->current_length -
icv_size;
return 1;
}
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
a.is_add = 1;
if (sa->is_initiator)
{
ikev2_sa_proposal_t *proposals = (ikev2_sa_proposal_t *) user;
ikev2_notify_t notify;
u8 *data = vec_new (u8, 4);
- memset (¬ify, 0, sizeof (notify));
+ clib_memset (¬ify, 0, sizeof (notify));
notify.protocol_id = IKEV2_PROTOCOL_ESP;
notify.spi = sa->childs[0].i_proposals->spi;
*(u32 *) data = clib_host_to_net_u32 (notify.spi);
if (ike0->exchange == IKEV2_EXCHANGE_SA_INIT)
{
sa0 = &sa;
- memset (sa0, 0, sizeof (*sa0));
+ clib_memset (sa0, 0, sizeof (*sa0));
if (ike0->flags & IKEV2_HDR_FLAG_INITIATOR)
{
return clib_error_return (0, "policy %v already exists", name);
pool_get (km->profiles, p);
- memset (p, 0, sizeof (*p));
+ clib_memset (p, 0, sizeof (*p));
p->name = vec_dup (name);
p->responder.sw_if_index = ~0;
uword index = p - km->profiles;
/* Prepare the SA and the IKE payload */
ikev2_sa_t sa;
- memset (&sa, 0, sizeof (ikev2_sa_t));
+ clib_memset (&sa, 0, sizeof (ikev2_sa_t));
ikev2_payload_chain_t *chain = 0;
ikev2_payload_new_chain (chain);
vlib_thread_main_t *tm = vlib_get_thread_main ();
int thread_id;
- memset (km, 0, sizeof (ikev2_main_t));
+ clib_memset (km, 0, sizeof (ikev2_main_t));
km->vnet_main = vnet_get_main ();
km->vlib_main = vm;
{
sa->i_dh_data = vec_new (u8, t->key_len);
x_off = len - BN_num_bytes (x);
- memset (sa->i_dh_data, 0, x_off);
+ clib_memset (sa->i_dh_data, 0, x_off);
BN_bn2bin (x, sa->i_dh_data + x_off);
y_off = t->key_len - BN_num_bytes (y);
- memset (sa->i_dh_data + len, 0, y_off - len);
+ clib_memset (sa->i_dh_data + len, 0, y_off - len);
BN_bn2bin (y, sa->i_dh_data + y_off);
const BIGNUM *prv = EC_KEY_get0_private_key (ec);
{
sa->r_dh_data = vec_new (u8, t->key_len);
x_off = len - BN_num_bytes (x);
- memset (sa->r_dh_data, 0, x_off);
+ clib_memset (sa->r_dh_data, 0, x_off);
BN_bn2bin (x, sa->r_dh_data + x_off);
y_off = t->key_len - BN_num_bytes (y);
- memset (sa->r_dh_data + len, 0, y_off - len);
+ clib_memset (sa->r_dh_data + len, 0, y_off - len);
BN_bn2bin (y, sa->r_dh_data + y_off);
x = BN_bin2bn (sa->i_dh_data, len, x);
EC_POINT_get_affine_coordinates_GFp (group, shared_point, x, y,
bn_ctx);
x_off = len - BN_num_bytes (x);
- memset (sa->dh_shared_key, 0, x_off);
+ clib_memset (sa->dh_shared_key, 0, x_off);
BN_bn2bin (x, sa->dh_shared_key + x_off);
y_off = t->key_len - BN_num_bytes (y);
- memset (sa->dh_shared_key + len, 0, y_off - len);
+ clib_memset (sa->dh_shared_key + len, 0, y_off - len);
BN_bn2bin (y, sa->dh_shared_key + y_off);
}
EC_POINT_get_affine_coordinates_GFp (group, shared_point, x, y, bn_ctx);
sa->dh_shared_key = vec_new (u8, t->key_len);
x_off = len - BN_num_bytes (x);
- memset (sa->dh_shared_key, 0, x_off);
+ clib_memset (sa->dh_shared_key, 0, x_off);
BN_bn2bin (x, sa->dh_shared_key + x_off);
y_off = t->key_len - BN_num_bytes (y);
- memset (sa->dh_shared_key + len, 0, y_off - len);
+ clib_memset (sa->dh_shared_key + len, 0, y_off - len);
BN_bn2bin (y, sa->dh_shared_key + y_off);
EC_KEY_free (ec);
c->last_hdr_off = vec_len (c->data);
vec_add2 (c->data, tmp, len);
hdr = (ike_payload_header_t *) tmp;
- memset (hdr, 0, len);
+ clib_memset (hdr, 0, len);
hdr->length = clib_host_to_net_u16 (len);
else /* create new SPD */
{
pool_get (im->spds, spd);
- memset (spd, 0, sizeof (*spd));
+ clib_memset (spd, 0, sizeof (*spd));
spd_index = spd - im->spds;
spd->id = spd_id;
hash_set (im->spd_index_by_spd_id, spd_id, spd_index);
ipsec_rand_seed ();
- memset (im, 0, sizeof (im[0]));
+ clib_memset (im, 0, sizeof (im[0]));
im->vnet_main = vnet_get_main ();
im->vlib_main = vm;
#if WITH_LIBSSL > 0
ipsec_policy_t p;
- memset (&p, 0, sizeof (p));
+ clib_memset (&p, 0, sizeof (p));
p.id = ntohl (mp->spd_id);
p.priority = ntohl (mp->priority);
ipsec_main_t *im = &ipsec_main;
ipsec_sa_t sa;
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.id = ntohl (mp->sad_id);
sa.spi = ntohl (mp->spi);
vl_api_ipsec_spds_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IPSEC_SPDS_DETAILS);
mp->context = context;
vl_api_ipsec_spd_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IPSEC_SPD_DETAILS);
mp->context = context;
#if WITH_LIBSSL > 0
ipsec_add_del_tunnel_args_t tun;
- memset (&tun, 0, sizeof (ipsec_add_del_tunnel_args_t));
+ clib_memset (&tun, 0, sizeof (ipsec_add_del_tunnel_args_t));
tun.is_add = mp->is_add;
tun.esn = mp->esn;
vl_api_ipsec_sa_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IPSEC_SA_DETAILS);
mp->context = context;
u8 *ck = 0, *ik = 0;
clib_error_t *error = NULL;
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
u32 tmp, tmp2;
clib_error_t *error = NULL;
- memset (&p, 0, sizeof (p));
+ clib_memset (&p, 0, sizeof (p));
p.lport.stop = p.rport.stop = ~0;
p.laddr.stop.ip4.as_u32 = p.raddr.stop.ip4.as_u32 = (u32) ~ 0;
p.laddr.stop.ip6.as_u64[0] = p.laddr.stop.ip6.as_u64[1] = (u64) ~ 0;
u8 *ck = 0, *ik = 0;
clib_error_t *error = NULL;
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
u32 num_m_args = 0;
clib_error_t *error = NULL;
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
a.is_add = 1;
/* Get a line of input. */
return VNET_API_ERROR_INVALID_VALUE;
pool_get_aligned (im->tunnel_interfaces, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
dev_instance = t - im->tunnel_interfaces;
if (args->renumber)
dev_instance);
pool_get (im->sad, sa);
- memset (sa, 0, sizeof (*sa));
+ clib_memset (sa, 0, sizeof (*sa));
t->input_sa_index = sa - im->sad;
sa->spi = args->remote_spi;
sa->tunnel_src_addr.ip4.as_u32 = args->remote_ip.as_u32;
}
pool_get (im->sad, sa);
- memset (sa, 0, sizeof (*sa));
+ clib_memset (sa, 0, sizeof (*sa));
t->output_sa_index = sa - im->sad;
sa->spi = args->local_spi;
sa->tunnel_src_addr.ip4.as_u32 = args->local_ip.as_u32;
return VNET_API_ERROR_INVALID_VALUE;
pool_get_aligned (im->tunnel_interfaces, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
t->input_sa_index = isa;
t->output_sa_index = osa;
vl_api_l2_xconnect_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_L2_XCONNECT_DETAILS);
mp->context = context;
mp->rx_sw_if_index = htonl (rx_sw_if_index);
vl_api_l2_fib_table_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_L2_FIB_TABLE_DETAILS);
mp->bd_id =
mp = vl_msg_api_alloc (sizeof (*mp) +
(n_sw_ifs * sizeof (vl_api_bridge_domain_sw_if_t)));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_BRIDGE_DOMAIN_DETAILS);
mp->bd_id = ntohl (bd_config->bd_id);
mp->flood = bd_feature_flood (bd_config);
vl_api_bd_ip_mac_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_BD_IP_MAC_DETAILS);
mp->bd_id = ntohl (bd_id);
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->bd_id = bd_id;
a->flood = (u8) flood;
L2FIB_NUM_BUCKETS, L2FIB_MEMORY_SIZE);
/* verify the key constructor is good, since it is endian-sensitive */
- memset (test_mac, 0, sizeof (test_mac));
+ clib_memset (test_mac, 0, sizeof (test_mac));
test_mac[0] = 0x11;
test_key.raw = 0;
test_key.raw = l2fib_make_key ((u8 *) & test_mac, 0x1234);
/* Clear L2 output config */
out_config = l2output_intf_config (sw_if_index);
- memset (out_config, 0, sizeof (l2_output_config_t));
+ clib_memset (out_config, 0, sizeof (l2_output_config_t));
/* Make sure any L2-output packet to this interface now in L3 mode is
* dropped. This may happen if L2 FIB MAC entry is stale */
skip -= e->skip_n_vectors * sizeof (u32x4);
e->rewrite_n_vectors = (skip + len - 1) / sizeof (u32x4) + 1;
vec_alloc_aligned (e->mask, e->rewrite_n_vectors, sizeof (u32x4));
- memset (e->mask, 0, e->rewrite_n_vectors * sizeof (u32x4));
+ clib_memset (e->mask, 0, e->rewrite_n_vectors * sizeof (u32x4));
vec_alloc_aligned (e->value, e->rewrite_n_vectors, sizeof (u32x4));
- memset (e->value, 0, e->rewrite_n_vectors * sizeof (u32x4));
+ clib_memset (e->value, 0, e->rewrite_n_vectors * sizeof (u32x4));
clib_memcpy (((u8 *) e->value) + skip, value, len);
clib_memcpy (((u8 *) e->mask) + skip, mask, len);
u32 sw_if_index;
/* mac address doesn't really matter */
- memset (address, 0, sizeof (address));
+ clib_memset (address, 0, sizeof (address));
address[2] = 0x12;
/* can returns error iff phy != 0 */
vec_validate (xcm->adj_by_sw_if_index, t->l2_sw_if_index);
a = vec_elt_at_index (xcm->adj_by_sw_if_index, t->l2_sw_if_index);
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->rewrite_header.sw_if_index = tx_fib_index;
a = vec_elt_at_index (xcm->adj_by_sw_if_index, t->l2_sw_if_index);
/* Reset adj to drop traffic */
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
set_int_l2_mode (vm, vnm, MODE_L3, t->l2_sw_if_index, 0,
L2_BD_PORT_TYPE_NORMAL, 0, 0);
return VNET_API_ERROR_INVALID_VALUE;
pool_get (lm->sessions, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
clib_memcpy (&s->our_address, our_address, sizeof (s->our_address));
clib_memcpy (&s->client_address, client_address,
sizeof (s->client_address));
format_vnet_sw_interface_name, lm->vnet_main, si);
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_IF_L2TPV3_TUNNEL_DETAILS);
strncpy ((char *) mp->interface_name,
(char *) if_name, ARRAY_LEN (mp->interface_name) - 1);
{
prefix->fp_len = 32;
prefix->fp_proto = FIB_PROTOCOL_IP4;
- memset (&prefix->fp_addr.pad, 0, sizeof (prefix->fp_addr.pad));
+ clib_memset (&prefix->fp_addr.pad, 0, sizeof (prefix->fp_addr.pad));
memcpy (&prefix->fp_addr.ip4, &addr->ip, sizeof (prefix->fp_addr.ip4));
}
else
vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
fwd_entry_t *fe = 0;
uword *feip = 0;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
feip = hash_get (lcm->fwd_entry_by_mapping_index, dst_map_index);
if (!feip)
lcl_addr))
continue;
- memset (&pair, 0, sizeof (pair));
+ clib_memset (&pair, 0, sizeof (pair));
ip_address_copy (&pair.rmt_loc,
&gid_address_ip (&rmt->address));
ip_address_copy (&pair.lcl_loc, lcl_addr);
u8 type, is_src_dst = 0;
int rv;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
/* remove entry if it already exists */
feip = hash_get (lcm->fwd_entry_by_mapping_index, dst_map_index);
if (!rmts_stored_idxp)
{
pool_get (lcm->lcl_to_rmt_adjacencies, rmts);
- memset (rmts, 0, sizeof (*rmts));
+ clib_memset (rmts, 0, sizeof (*rmts));
rmts_idx = rmts - lcm->lcl_to_rmt_adjacencies;
hash_set (lcm->lcl_to_rmt_adjs_by_lcl_idx, src_map_index, rmts_idx);
}
{
fwd_entry_mt_arg_t a;
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
a.si = si;
a.di = di;
return -1;
}
- memset (ms, 0, sizeof (*ms));
+ clib_memset (ms, 0, sizeof (*ms));
ip_address_copy (&ms->address, addr);
vec_add1 (lcm->map_servers, ms[0]);
gid_address_t *e;
remove_mapping_args_t a;
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
/* do this only in src/dst mode ... */
if (MR_MODE_SRC_DST != lcm->map_request_mode)
{
vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args;
- memset (adj_args, 0, sizeof (adj_args[0]));
+ clib_memset (adj_args, 0, sizeof (adj_args[0]));
gid_address_copy (&adj_args->reid, e);
adj_args->is_add = 0;
if (vnet_lisp_add_del_adjacency (adj_args))
if (is_updated)
is_updated[0] = 0;
- memset (ls_args, 0, sizeof (ls_args[0]));
+ clib_memset (ls_args, 0, sizeof (ls_args[0]));
ls_args->locators = rlocs;
mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &a->eid);
mapping_t *old_map;
u32 mi;
- memset (ls_args, 0, sizeof (ls_args[0]));
- memset (m_args, 0, sizeof (m_args[0]));
+ clib_memset (ls_args, 0, sizeof (ls_args[0]));
+ clib_memset (m_args, 0, sizeof (m_args[0]));
if (res_map_index)
res_map_index[0] = ~0;
locator_set_index = p[0];
pool_get (lcm->mapping_pool, m);
- memset (m, 0, sizeof *m);
+ clib_memset (m, 0, sizeof *m);
m->locator_set_index = locator_set_index;
m->local = 1;
m->nsh_set = 1;
return VNET_API_ERROR_LISP_DISABLED;
}
- memset (ls_args, 0, sizeof (*ls_args));
+ clib_memset (ls_args, 0, sizeof (*ls_args));
if (is_add)
{
/* Create dummy petr locator-set */
- memset (&loc, 0, sizeof (loc));
+ clib_memset (&loc, 0, sizeof (loc));
gid_address_from_ip (&loc.address, ip);
loc.priority = 1;
loc.state = loc.weight = 1;
uword *fei = 0, *rmts_idxp = 0;
u32 **rmts = 0, *remote_idxp = 0, *rmts_copy = 0;
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
map = pool_elt_at_index (lcm->mapping_pool, mapping_index);
else
{
pool_get (lcm->locator_set_pool, ls);
- memset (ls, 0, sizeof (*ls));
+ clib_memset (ls, 0, sizeof (*ls));
ls_index = ls - lcm->locator_set_pool;
if (a->local)
return -1;
}
- memset (mr, 0, sizeof (*mr));
+ clib_memset (mr, 0, sizeof (*mr));
ip_address_copy (&mr->address, &a->address);
vec_add1 (lcm->map_resolvers, *mr);
ip_prefix_t *ippref = &gid_address_ippref (gid);
ip_address_t *rloc = &ip_prefix_addr (ippref);
- memset (gid, 0, sizeof (gid[0]));
+ clib_memset (gid, 0, sizeof (gid[0]));
gid_address_type (gid) = GID_ADDR_IP_PREFIX;
for (i = 0; i < vec_len (loc_set->locator_indices); i++)
{
&& GID_ADDR_SRC_DST != gid_address_type (deid))
{
gid_address_t sd;
- memset (&sd, 0, sizeof (sd));
+ clib_memset (&sd, 0, sizeof (sd));
build_src_dst (&sd, seid, deid);
lisp_msg_put_mreq (lcm, b, seid, &sd, rlocs, is_smr_invoked,
0 /* rloc probe */ , nonce_res);
map_registers_sent++;
pool_get (lcm->pending_map_registers_pool, pmr);
- memset (pmr, 0, sizeof (*pmr));
+ clib_memset (pmr, 0, sizeof (*pmr));
pmr->time_to_expire = PENDING_MREG_EXPIRATION_TIME;
hash_set (lcm->map_register_messages_by_nonce, nonce,
pmr - lcm->pending_map_registers_pool);
{
/* add map-request to pending requests table */
pool_get (lcm->pending_map_requests_pool, pmr);
- memset (pmr, 0, sizeof (*pmr));
+ clib_memset (pmr, 0, sizeof (*pmr));
gid_address_copy (&pmr->src, seid);
gid_address_copy (&pmr->dst, deid);
clib_fifo_add1 (pmr->nonces, nonce);
u32 vni = 0;
icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *opt;
- memset (src, 0, sizeof (*src));
- memset (dst, 0, sizeof (*dst));
+ clib_memset (src, 0, sizeof (*src));
+ clib_memset (dst, 0, sizeof (*dst));
gid_address_type (dst) = GID_ADDR_NO_ADDRESS;
gid_address_type (src) = GID_ADDR_NO_ADDRESS;
if (clib_net_to_host_u16 (ah->opcode)
!= ETHERNET_ARP_OPCODE_request)
{
- memset (&gid_address_arp_ndp_ip (dst), 0,
- sizeof (ip_address_t));
+ clib_memset (&gid_address_arp_ndp_ip (dst), 0,
+ sizeof (ip_address_t));
ip_addr_version (&gid_address_arp_ndp_ip (dst)) = IP4;
gid_address_arp_ndp_bd (dst) = ~0;
return;
ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address)
|| (opt->header.n_data_u64s != 1))
{
- memset (&gid_address_arp_ndp_ip (dst), 0,
- sizeof (ip_address_t));
+ clib_memset (&gid_address_arp_ndp_ip (dst), 0,
+ sizeof (ip_address_t));
ip_addr_version (&gid_address_arp_ndp_ip (dst)) =
IP6;
gid_address_arp_ndp_bd (dst) = ~0;
lisp_cp_lookup_trace_t *tr = vlib_add_trace (vm, node, b0,
sizeof (*tr));
- memset (tr, 0, sizeof (*tr));
+ clib_memset (tr, 0, sizeof (*tr));
gid_address_copy (&tr->dst_eid, &dst);
ip_address_copy (&tr->map_resolver_ip,
&lcm->active_map_resolver);
{
mapping_t *m;
vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args;
- memset (adj_args, 0, sizeof (adj_args[0]));
+ clib_memset (adj_args, 0, sizeof (adj_args[0]));
m = pool_elt_at_index (lcm->mapping_pool, mi);
fe = pool_elt_at_index (lcm->fwd_entry_pool, fei[0]);
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->rmt_eid = fe->reid;
if (fe->is_src_dst)
a->lcl_eid = fe->leid;
{
/* mapping is in use, re-fetch */
map_request_args_t mr_args;
- memset (&mr_args, 0, sizeof (mr_args));
+ clib_memset (&mr_args, 0, sizeof (mr_args));
mr_args.seid = fe->leid;
mr_args.deid = fe->reid;
vec_foreach (m, a->mappings)
{
vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
- memset (m_args, 0, sizeof (m_args[0]));
+ clib_memset (m_args, 0, sizeof (m_args[0]));
gid_address_copy (&m_args->eid, &m->eid);
m_args->action = m->action;
m_args->authoritative = m->authoritative;
{
/* try to program forwarding only if mapping saved or updated */
vnet_lisp_add_del_adjacency_args_t _adj_args, *adj_args = &_adj_args;
- memset (adj_args, 0, sizeof (adj_args[0]));
+ clib_memset (adj_args, 0, sizeof (adj_args[0]));
gid_address_copy (&adj_args->leid, &pmr->src);
gid_address_copy (&adj_args->reid, &m->eid);
clib_memcpy (auth_data, MNOTIFY_DATA (h), auth_data_len);
/* clear auth data */
- memset (MNOTIFY_DATA (h), 0, auth_data_len);
+ clib_memset (MNOTIFY_DATA (h), 0, auth_data_len);
/* get hash of the message */
unsigned char *code = HMAC (get_encrypt_fcn (key_id), key, vec_len (key),
mapping_t m;
locator_t *loc;
- memset (&m, 0, sizeof (m));
+ clib_memset (&m, 0, sizeof (m));
/* parse record eid */
for (i = 0; i < count; i++)
map_records_arg_t *a;
a = map_record_args_get ();
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
mnotif_hdr = vlib_buffer_get_current (b);
vlib_buffer_pull (b, sizeof (*mnotif_hdr));
- memset (&deid, 0, sizeof (deid));
+ clib_memset (&deid, 0, sizeof (deid));
a->nonce = MNOTIFY_NONCE (mnotif_hdr);
key_id = clib_net_to_host_u16 (MNOTIFY_KEY_ID (mnotif_hdr));
vec_add1 (records, m[0]);
add_locators (lcm, &records[0], m->locator_set_index, probed_loc);
- memset (&src, 0, sizeof (src));
+ clib_memset (&src, 0, sizeof (src));
if (!ip_fib_get_first_egress_ip_for_dst (lcm, dst, &src))
{
/* parse eid records and send SMR-invoked map-requests */
for (i = 0; i < MREQ_REC_COUNT (mreq_hdr); i++)
{
- memset (&dst, 0, sizeof (dst));
+ clib_memset (&dst, 0, sizeof (dst));
len = lisp_msg_parse_eid_rec (b, &dst);
if (len == ~0)
{
goto done;
}
rloc_probe_recv++;
- memset (&m, 0, sizeof (m));
+ clib_memset (&m, 0, sizeof (m));
u32 mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, &dst);
// TODO: select best locator; for now use the first one
map_records_arg_t *a;
a = map_record_args_get ();
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
locator_t *locators;
for (i = 0; i < MREP_REC_COUNT (mrep_hdr); i++)
{
- memset (&m, 0, sizeof (m));
+ clib_memset (&m, 0, sizeof (m));
locators = 0;
h = vlib_buffer_get_current (b);
lcm->flags = 0;
lcm->pitr_map_index = ~0;
lcm->petr_map_index = ~0;
- memset (&lcm->active_map_resolver, 0, sizeof (lcm->active_map_resolver));
- memset (&lcm->active_map_server, 0, sizeof (lcm->active_map_server));
+ clib_memset (&lcm->active_map_resolver, 0,
+ sizeof (lcm->active_map_resolver));
+ clib_memset (&lcm->active_map_server, 0, sizeof (lcm->active_map_server));
gid_dictionary_init (&lcm->mapping_index_by_gid);
lcm->do_map_resolver_election = 1;
const lisp_gpe_tunnel_t *lgt;
fwd_entry_t *fe;
- memset (stat, 0, sizeof (*stat));
- memset (&fwd_key, 0, sizeof (fwd_key));
+ clib_memset (stat, 0, sizeof (*stat));
+ clib_memset (&fwd_key, 0, sizeof (fwd_key));
fe = pool_elt_at_index (lcm->fwd_entry_pool, key->fwd_entry_index);
ASSERT (fe != 0);
if (!src)
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
return ip4_lookup_exact_match (sfib4, 0, &sp);
}
else
if (!src)
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
ip_prefix_version (&sp) = IP6;
return ip6_lookup_exact_match (sfib6, 0, &sp);
}
{
uword i;
- memset (db->ip4_prefix_len_refcount, 0,
- sizeof (db->ip4_prefix_len_refcount));
+ clib_memset (db->ip4_prefix_len_refcount, 0,
+ sizeof (db->ip4_prefix_len_refcount));
for (i = 0; i < ARRAY_LEN (db->ip4_fib_masks); i++)
{
else
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
add_del_ip4_key (sfib, 0 /* vni */ , &sp, val, is_add);
}
}
else
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
old_val =
add_del_ip4_key (sfib, 0 /* vni */ , &sp, val, is_add);
}
else
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
old_val = add_del_ip4_key (sfib, 0, &sp, 0, is_add);
}
{
uword i;
- memset (db->ip6_prefix_len_refcount, 0,
- sizeof (db->ip6_prefix_len_refcount));
+ clib_memset (db->ip6_prefix_len_refcount, 0,
+ sizeof (db->ip6_prefix_len_refcount));
for (i = 0; i < ARRAY_LEN (db->ip6_fib_masks); i++)
{
else
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
ip_prefix_version (&sp) = IP6;
add_del_ip6_key (sfib, 0 /* vni */ , &sp, val, is_add);
}
else
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
ip_prefix_version (&sp) = IP6;
old_val =
add_del_ip6_key (sfib, 0 /* vni */ , &sp, val, is_add);
else
{
ip_prefix_t sp;
- memset (&sp, 0, sizeof (sp));
+ clib_memset (&sp, 0, sizeof (sp));
ip_prefix_version (&sp) = IP6;
old_val = add_del_ip6_key (sfib, 0, &sp, 0, is_add);
}
{
/* remote locators */
r = &rmt_locs[i];
- memset (&loc, 0, sizeof (loc));
+ clib_memset (&loc, 0, sizeof (loc));
gid_address_ip_set (&loc.address, &r->addr, r->is_ip4 ? IP4 : IP6);
loc.priority = r->priority;
u8 *locator_name = NULL;
int i;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
locator_name = format (0, "%s", mp->locator_set_name);
a->local = 1;
locator_num = clib_net_to_host_u32 (mp->locator_num);
- memset (&locator, 0, sizeof (locator));
+ clib_memset (&locator, 0, sizeof (locator));
for (i = 0; i < locator_num; i++)
{
ls_loc = &mp->locators[i];
u32 ls_index = ~0;
u8 *locator_name = NULL;
- memset (&locator, 0, sizeof (locator));
- memset (a, 0, sizeof (a[0]));
+ clib_memset (&locator, 0, sizeof (locator));
+ clib_memset (a, 0, sizeof (a[0]));
locator.sw_if_index = ntohl (mp->sw_if_index);
locator.priority = mp->priority;
u32 locator_set_index = ~0, map_index = ~0;
vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
u8 *name = NULL, *key = NULL;
- memset (a, 0, sizeof (a[0]));
- memset (eid, 0, sizeof (eid[0]));
+ clib_memset (a, 0, sizeof (a[0]));
+ clib_memset (eid, 0, sizeof (eid[0]));
rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->eid, mp->prefix_len);
int rv = 0;
ip_address_t addr;
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
int rv = 0;
vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
a->is_add = mp->is_add;
ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
u8 status = 0;
gid_address_t addr;
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
status = lcm->flags & LISP_FLAG_USE_PETR;
if (status)
{
gid_address_t _eid, *eid = &_eid;
u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
- memset (eid, 0, sizeof (eid[0]));
+ clib_memset (eid, 0, sizeof (eid[0]));
rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->eid, mp->eid_len);
if (!mp->is_add)
{
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
gid_address_copy (&a->reid, eid);
a->is_add = 0;
rv = vnet_lisp_add_del_adjacency (a);
if (mp->is_add)
{
vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
- memset (m_args, 0, sizeof (m_args[0]));
+ clib_memset (m_args, 0, sizeof (m_args[0]));
gid_address_copy (&m_args->eid, eid);
m_args->action = mp->action;
m_args->is_static = 1;
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
int rv = 0;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->leid, mp->leid_len);
vl_api_lisp_locator_details_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
rmp->context = context;
u8 *str = 0;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
rmp->context = context;
mac = gid_address_mac (gid);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
if (mp->eid_set)
{
- memset (eid, 0, sizeof (*eid));
+ clib_memset (eid, 0, sizeof (*eid));
unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->eid, mp->prefix_length);
vl_api_lisp_map_server_details_t *rmp = NULL;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
switch (ip_addr_version (ip))
vl_api_lisp_map_resolver_details_t *rmp = NULL;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
switch (ip_addr_version (ip))
vl_api_lisp_eid_table_map_details_t *rmp = NULL;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
rmp->vni = clib_host_to_net_u32 (p->key);
vl_api_lisp_eid_table_vni_details_t *rmp = 0;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
rmp->context = context;
rmp->vni = clib_host_to_net_u32 (vni);
for (i = 0; i < n; i++)
{
adj = vec_elt_at_index (adjs, i);
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
switch (gid_address_type (&adj->reid))
{
u8 *key = 0;
u32 key_id = 0;
- memset (&eid, 0, sizeof (eid));
- memset (a, 0, sizeof (*a));
+ clib_memset (&eid, 0, sizeof (eid));
+ clib_memset (a, 0, sizeof (*a));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&eid, 0, sizeof (eid));
- memset (&rloc, 0, sizeof (rloc));
+ clib_memset (&eid, 0, sizeof (eid));
+ clib_memset (&rloc, 0, sizeof (rloc));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (!is_add)
{
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
gid_address_copy (&a->reid, &eid);
if (vnet_lisp_add_del_adjacency (a))
{
if (is_add)
{
vnet_lisp_add_del_mapping_args_t _map_args, *map_args = &_map_args;
- memset (map_args, 0, sizeof (map_args[0]));
+ clib_memset (map_args, 0, sizeof (map_args[0]));
gid_address_copy (&map_args->eid, &eid);
map_args->action = action;
map_args->is_static = 1;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&reid, 0, sizeof (reid));
- memset (&leid, 0, sizeof (leid));
+ clib_memset (&reid, 0, sizeof (reid));
+ clib_memset (&leid, 0, sizeof (leid));
leid_ippref = &gid_address_ippref (&leid);
reid_ippref = &gid_address_ippref (&reid);
goto done;
}
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
gid_address_copy (&a->leid, &leid);
gid_address_copy (&a->reid, &reid);
a->is_add = is_add;
u8 filter = 0;
clib_error_t *error = NULL;
- memset (&eid, 0, sizeof (eid));
+ clib_memset (&eid, 0, sizeof (eid));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
u32 ls_index = 0;
int rv = 0;
- memset (&locator, 0, sizeof (locator));
- memset (a, 0, sizeof (a[0]));
+ clib_memset (&locator, 0, sizeof (locator));
+ clib_memset (a, 0, sizeof (a[0]));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
u32 ls_index = 0;
- memset (&locator, 0, sizeof (locator));
- memset (a, 0, sizeof (a[0]));
+ clib_memset (&locator, 0, sizeof (locator));
+ clib_memset (a, 0, sizeof (a[0]));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
vec_foreach (loc, locators)
{
u8 *p = vlib_buffer_put_uninit (b, sizeof (locator_hdr_t));
- memset (p, 0, sizeof (locator_hdr_t));
+ clib_memset (p, 0, sizeof (locator_hdr_t));
LOC_PRIORITY (p) = loc->priority;
LOC_MPRIORITY (p) = loc->mpriority;
LOC_WEIGHT (p) = loc->weight;
vlib_buffer_put_uninit (b, sizeof (mapping_record_hdr_t));
gid_address_t *eid = &record->eid;
- memset (p, 0, sizeof (*p));
+ clib_memset (p, 0, sizeof (*p));
MAP_REC_EID_PLEN (p) = gid_address_len (eid);
MAP_REC_TTL (p) = clib_host_to_net_u32 (MAP_REGISTER_DEFAULT_TTL);
MAP_REC_AUTH (p) = record->authoritative ? 1 : 0;
{
eid_record_hdr_t *h = vlib_buffer_put_uninit (b, sizeof (*h));
- memset (h, 0, sizeof (*h));
+ clib_memset (h, 0, sizeof (*h));
EID_REC_MLEN (h) = gid_address_len (eid);
lisp_msg_put_gid (b, eid);
return h;
{
map_reply_hdr_t *h = vlib_buffer_put_uninit (b, sizeof (h[0]));
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
MREP_TYPE (h) = LISP_MAP_REPLY;
MREP_NONCE (h) = nonce;
MREP_REC_COUNT (h) = 1;
/* Basic header init */
map_register_hdr_t *h = vlib_buffer_put_uninit (b, sizeof (h[0]));
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
MREG_TYPE (h) = LISP_MAP_REGISTER;
MREG_NONCE (h) = nonce_build (0);
MREG_WANT_MAP_NOTIFY (h) = want_map_notify ? 1 : 0;
MREG_REC_COUNT (h) = vec_len (records);
auth_data = vlib_buffer_put_uninit (b, auth_data_len);
- memset (auth_data, 0, auth_data_len);
+ clib_memset (auth_data, 0, auth_data_len);
/* Put map register records */
lisp_msg_put_mreg_records (b, records);
/* Basic header init */
map_request_hdr_t *h = vlib_buffer_put_uninit (b, sizeof (h[0]));
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
MREQ_TYPE (h) = LISP_MAP_REQUEST;
MREQ_NONCE (h) = nonce_build (0);
MREQ_SMR_INVOKED (h) = is_smr_invoked ? 1 : 0;
if (gid_address_type (la) != GID_ADDR_IP_PREFIX)
{
/* empty ip4 */
- memset (src_ip, 0, sizeof (src_ip[0]));
- memset (dst_ip, 0, sizeof (dst_ip[0]));
+ clib_memset (src_ip, 0, sizeof (src_ip[0]));
+ clib_memset (dst_ip, 0, sizeof (dst_ip[0]));
}
else
{
lisp_msg_parse_addr (vlib_buffer_t * b, gid_address_t * eid)
{
u32 len;
- memset (eid, 0, sizeof (*eid));
+ clib_memset (eid, 0, sizeof (*eid));
len = gid_address_parse (vlib_buffer_get_current (b), eid);
if (len != ~0)
vlib_buffer_pull (b, len);
{
eid_record_hdr_t *h = vlib_buffer_get_current (b);
u32 len;
- memset (eid, 0, sizeof (*eid));
+ clib_memset (eid, 0, sizeof (*eid));
len = gid_address_parse (EID_REC_ADDR (h), eid);
if (len == ~0)
return len;
vlib_buffer_pull (b, sizeof (mapping_record_hdr_t));
- memset (eid, 0, sizeof (*eid));
+ clib_memset (eid, 0, sizeof (*eid));
len = gid_address_parse (vlib_buffer_get_current (b), eid);
if (len == ~0)
return len;
{
ip_address_t *a = va_arg (*args, ip_address_t *);
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (a)))
ip_addr_version (a) = IP4;
else if (unformat_user (input, unformat_ip6_address, &ip_addr_v6 (a)))
fid_address_t sim1, sim2;
nsh_t nsh;
- memset (&ippref, 0, sizeof (ippref));
- memset (&sim1, 0, sizeof (sim1));
- memset (&sim2, 0, sizeof (sim2));
+ clib_memset (&ippref, 0, sizeof (ippref));
+ clib_memset (&sim1, 0, sizeof (sim1));
+ clib_memset (&sim2, 0, sizeof (sim2));
if (unformat (input, "%U|%U", unformat_fid_address, &sim1,
unformat_fid_address, &sim2))
void
gid_address_from_ip (gid_address_t * g, ip_address_t * ip)
{
- memset (g, 0, sizeof (g[0]));
+ clib_memset (g, 0, sizeof (g[0]));
ip_address_set (&gid_address_ip (g), ip, ip_addr_version (ip));
gid_address_ippref_len (g) = 32;
}
if (IP4 == ip_addr_version (src))
{
/* don't copy any garbage from the union */
- memset (dst, 0, sizeof (*dst));
+ clib_memset (dst, 0, sizeof (*dst));
dst->ip.v4 = src->ip.v4;
dst->version = IP4;
}
ASSERT (ip6);
- memset (mask_6, 0, sizeof (mask_6));
+ clib_memset (mask_6, 0, sizeof (mask_6));
if (128 <= preflen)
{
*(u16 *) p = clib_host_to_net_u16 (LISP_AFI_LCAF);
size += sizeof (u16);
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
LCAF_TYPE (h) = type;
u16 lcaf_len = (*lcaf_body_length_fcts[type]) (lcaf);
LCAF_LENGTH (h) = clib_host_to_net_u16 (lcaf_len);
*(u16 *) p = clib_host_to_net_u16 (LISP_AFI_LCAF);
size += sizeof (u16);
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
LCAF_TYPE (h) = LCAF_SOURCE_DEST;
u16 lcaf_len = sizeof (lcaf_src_dst_hdr_t)
+ fid_addr_size_to_write (&sd_src (sd))
clib_memcpy (p + size, h, sizeof (h[0]));
size += sizeof (h[0]);
- memset (&sd_hdr, 0, sizeof (sd_hdr));
+ clib_memset (&sd_hdr, 0, sizeof (sd_hdr));
LCAF_SD_SRC_ML (&sd_hdr) = fid_address_length (&sd_src (sd));
LCAF_SD_DST_ML (&sd_hdr) = fid_address_length (&sd_dst (sd));
clib_memcpy (p + size, &sd_hdr, sizeof (sd_hdr));
ASSERT (gid_address_type (g) == GID_ADDR_NSH);
- memset (&lcaf, 0, sizeof (lcaf));
- memset (&spi, 0, sizeof (spi));
+ clib_memset (&lcaf, 0, sizeof (lcaf));
+ clib_memset (&spi, 0, sizeof (spi));
LCAF_TYPE (&lcaf) = LCAF_NSH;
LCAF_LENGTH (&lcaf) = clib_host_to_net_u16 (sizeof (lcaf_spi_hdr_t));
/* put lcaf header */
*(u16 *) p = clib_host_to_net_u16 (LISP_AFI_LCAF);
size += sizeof (u16);
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
LCAF_TYPE (h) = LCAF_INSTANCE_ID;
u16 lcaf_len = sizeof (u32) /* Instance ID size */
+ gid_address_size_to_put_no_vni (g);
void
build_src_dst (gid_address_t * sd, gid_address_t * src, gid_address_t * dst)
{
- memset (sd, 0, sizeof (*sd));
+ clib_memset (sd, 0, sizeof (*sd));
gid_address_type (sd) = GID_ADDR_SRC_DST;
gid_address_vni (sd) = gid_address_vni (dst);
gid_address_vni_mask (sd) = gid_address_vni_mask (dst);
{
/* remote locators */
r = &rmt_locs[i];
- memset (&loc, 0, sizeof (loc));
+ clib_memset (&loc, 0, sizeof (loc));
gid_address_ip_set (&loc.address, &r->addr, r->is_ip4 ? IP4 : IP6);
loc.priority = r->priority;
u8 *locator_name = NULL;
int i;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
locator_name = format (0, "%s", mp->locator_set_name);
a->local = 1;
locator_num = clib_net_to_host_u32 (mp->locator_num);
- memset (&locator, 0, sizeof (locator));
+ clib_memset (&locator, 0, sizeof (locator));
for (i = 0; i < locator_num; i++)
{
ls_loc = &mp->locators[i];
u32 ls_index = ~0;
u8 *locator_name = NULL;
- memset (&locator, 0, sizeof (locator));
- memset (a, 0, sizeof (a[0]));
+ clib_memset (&locator, 0, sizeof (locator));
+ clib_memset (a, 0, sizeof (a[0]));
locator.sw_if_index = ntohl (mp->sw_if_index);
locator.priority = mp->priority;
u32 locator_set_index = ~0, map_index = ~0;
vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
u8 *name = NULL, *key = NULL;
- memset (a, 0, sizeof (a[0]));
- memset (eid, 0, sizeof (eid[0]));
+ clib_memset (a, 0, sizeof (a[0]));
+ clib_memset (eid, 0, sizeof (eid[0]));
rv = unformat_one_eid_api (eid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->eid, mp->prefix_len);
int rv = 0;
ip_address_t addr;
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
int rv = 0;
vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
a->is_add = mp->is_add;
ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
u8 status = 0;
gid_address_t addr;
- memset (&addr, 0, sizeof (addr));
+ clib_memset (&addr, 0, sizeof (addr));
status = lcm->flags & LISP_FLAG_USE_PETR;
if (status)
{
gid_address_t _eid, *eid = &_eid;
u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
- memset (eid, 0, sizeof (eid[0]));
+ clib_memset (eid, 0, sizeof (eid[0]));
rv = unformat_one_eid_api (eid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->eid, mp->eid_len);
if (!mp->is_add)
{
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
gid_address_copy (&a->reid, eid);
a->is_add = 0;
rv = vnet_lisp_add_del_adjacency (a);
if (mp->is_add)
{
vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
- memset (m_args, 0, sizeof (m_args[0]));
+ clib_memset (m_args, 0, sizeof (m_args[0]));
gid_address_copy (&m_args->eid, eid);
m_args->action = mp->action;
m_args->is_static = 1;
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
int rv = 0;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
rv = unformat_one_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->leid, mp->leid_len);
vl_api_one_locator_details_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_LOCATOR_DETAILS);
rmp->context = context;
u8 *str = 0;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_LOCATOR_SET_DETAILS);
rmp->context = context;
mac = gid_address_mac (gid);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_EID_TABLE_DETAILS);
ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
if (mp->eid_set)
{
- memset (eid, 0, sizeof (*eid));
+ clib_memset (eid, 0, sizeof (*eid));
unformat_one_eid_api (eid, clib_net_to_host_u32 (mp->vni),
mp->eid_type, mp->eid, mp->prefix_length);
vl_api_one_map_server_details_t *rmp = NULL;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_MAP_SERVER_DETAILS);
switch (ip_addr_version (ip))
vl_api_one_map_resolver_details_t *rmp = NULL;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_MAP_RESOLVER_DETAILS);
switch (ip_addr_version (ip))
vl_api_one_eid_table_map_details_t *rmp = NULL;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_EID_TABLE_MAP_DETAILS);
rmp->vni = clib_host_to_net_u32 (p->key);
vl_api_one_eid_table_vni_details_t *rmp = 0;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ONE_EID_TABLE_VNI_DETAILS);
rmp->context = context;
rmp->vni = clib_host_to_net_u32 (vni);
for (i = 0; i < n; i++)
{
adj = vec_elt_at_index (adjs, i);
- memset (&a, 0, sizeof (a));
+ clib_memset (&a, 0, sizeof (a));
switch (gid_address_type (&adj->reid))
{
vl_api_one_add_del_l2_arp_entry_reply_t *rmp;
int rv = 0;
gid_address_t _arp, *arp = &_arp;
- memset (arp, 0, sizeof (*arp));
+ clib_memset (arp, 0, sizeof (*arp));
gid_address_type (arp) = GID_ADDR_ARP;
gid_address_arp_bd (arp) = clib_net_to_host_u32 (mp->bd);
vl_api_one_add_del_ndp_entry_reply_t *rmp;
int rv = 0;
gid_address_t _g, *g = &_g;
- memset (g, 0, sizeof (*g));
+ clib_memset (g, 0, sizeof (*g));
gid_address_type (g) = GID_ADDR_NDP;
gid_address_ndp_bd (g) = clib_net_to_host_u32 (mp->bd);
u8 *key = 0;
u32 key_id = 0;
- memset (&eid, 0, sizeof (eid));
- memset (a, 0, sizeof (*a));
+ clib_memset (&eid, 0, sizeof (eid));
+ clib_memset (a, 0, sizeof (*a));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
u32 hw_addr_set = 0, ip_set = 0, is_add = 1;
gid_address_t _g, *g = &_g;
- memset (&ip6, 0, sizeof (ip6));
- memset (hw_addr, 0, sizeof (hw_addr));
- memset (g, 0, sizeof (*g));
+ clib_memset (&ip6, 0, sizeof (ip6));
+ clib_memset (hw_addr, 0, sizeof (hw_addr));
+ clib_memset (g, 0, sizeof (*g));
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
u32 hw_addr_set = 0, ip_set = 0, is_add = 1;
gid_address_t _arp, *arp = &_arp;
- memset (&ip4, 0, sizeof (ip4));
- memset (hw_addr, 0, sizeof (hw_addr));
- memset (arp, 0, sizeof (*arp));
+ clib_memset (&ip4, 0, sizeof (ip4));
+ clib_memset (hw_addr, 0, sizeof (hw_addr));
+ clib_memset (arp, 0, sizeof (*arp));
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&eid, 0, sizeof (eid));
- memset (&rloc, 0, sizeof (rloc));
+ clib_memset (&eid, 0, sizeof (eid));
+ clib_memset (&rloc, 0, sizeof (rloc));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (!is_add)
{
vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
gid_address_copy (&a->reid, &eid);
if (vnet_lisp_add_del_adjacency (a))
{
if (is_add)
{
vnet_lisp_add_del_mapping_args_t _map_args, *map_args = &_map_args;
- memset (map_args, 0, sizeof (map_args[0]));
+ clib_memset (map_args, 0, sizeof (map_args[0]));
gid_address_copy (&map_args->eid, &eid);
map_args->action = action;
map_args->is_static = 1;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&reid, 0, sizeof (reid));
- memset (&leid, 0, sizeof (leid));
+ clib_memset (&reid, 0, sizeof (reid));
+ clib_memset (&leid, 0, sizeof (leid));
leid_ippref = &gid_address_ippref (&leid);
reid_ippref = &gid_address_ippref (&reid);
goto done;
}
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
gid_address_copy (&a->leid, &leid);
gid_address_copy (&a->reid, &reid);
a->is_add = is_add;
u8 filter = 0;
clib_error_t *error = NULL;
- memset (&eid, 0, sizeof (eid));
+ clib_memset (&eid, 0, sizeof (eid));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
u32 ls_index = 0;
int rv = 0;
- memset (&locator, 0, sizeof (locator));
- memset (a, 0, sizeof (a[0]));
+ clib_memset (&locator, 0, sizeof (locator));
+ clib_memset (a, 0, sizeof (a[0]));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
u32 ls_index = 0;
- memset (&locator, 0, sizeof (locator));
- memset (a, 0, sizeof (a[0]));
+ clib_memset (&locator, 0, sizeof (locator));
+ clib_memset (a, 0, sizeof (a[0]));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
} phu;
/* pseudo-header */
- memset (&phu, 0, sizeof (phu));
+ clib_memset (&phu, 0, sizeof (phu));
phu.ph.ph_src = ip6->src_address;
phu.ph.ph_dst = ip6->dst_address;
phu.ph.ph_len = clib_host_to_net_u32 (len);
ecm_hdr_t *h;
h = vlib_buffer_push_uninit (b, sizeof (h[0]));
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
h->type = LISP_ENCAP_CONTROL_TYPE;
- memset (h->reserved2, 0, sizeof (h->reserved2));
+ clib_memset (h->reserved2, 0, sizeof (h->reserved2));
return h;
}
locator_pair_t pair, *pairs = 0;
int rv;
- memset (leid, 0, sizeof (*leid));
- memset (reid, 0, sizeof (*reid));
+ clib_memset (leid, 0, sizeof (*leid));
+ clib_memset (reid, 0, sizeof (*reid));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
/* add fwd entry */
vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
a->is_add = is_add;
a->is_negative = is_negative;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&rpath, 0, sizeof (rpath));
+ clib_memset (&rpath, 0, sizeof (rpath));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
lgm->lisp_stats_index_by_key =
hash_create_mem (0, sizeof (lisp_stats_key_t), sizeof (uword));
- memset (&lgm->counters, 0, sizeof (lgm->counters));
+ clib_memset (&lgm->counters, 0, sizeof (lgm->counters));
lgm->counters.name = "LISP counters";
return 0;
if (!file_name)
return clib_error_create ("no pcap file specified!");
- memset (&pm, 0, sizeof (pm));
+ clib_memset (&pm, 0, sizeof (pm));
pm.file_name = (char *) file_name;
error = pcap_read (&pm);
if (error)
{
if (ip46_address_is_ip4 (a))
{
- memset (b, 0, sizeof (*b));
+ clib_memset (b, 0, sizeof (*b));
ip_address_set (b, &a->ip4, IP4);
}
else
return;
lisp_stats_key_t key;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
key.fwd_entry_index = feip[0];
key.tunnel_index = ladj->tunnel_index;
{
pool_get (lisp_adj_pool, ladj);
- memset (ladj, 0, sizeof (*ladj));
+ clib_memset (ladj, 0, sizeof (*ladj));
lai = (ladj - lisp_adj_pool);
ip_address_copy (&ladj->remote_rloc, &pair->rmt_loc);
{
/* local locator */
r = &((vl_api_gpe_locator_t *) locs)[i];
- memset (&pair, 0, sizeof (pair));
+ clib_memset (&pair, 0, sizeof (pair));
ip_address_set (&pair.lcl_loc, &r->addr, r->is_ip4 ? IP4 : IP6);
pair.weight = r->weight;
vec_foreach (path, lfe->paths)
{
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
const lisp_gpe_tunnel_t *lgt;
rmp->_vl_msg_id =
vec_foreach (e, src)
{
- memset (&dst[i], 0, sizeof (*dst));
+ clib_memset (&dst[i], 0, sizeof (*dst));
dst[i].dp_table = e->dp_table;
dst[i].fwd_entry_index = e->fwd_entry_index;
dst[i].vni = e->vni;
int rv = 0;
gpe_add_del_fwd_entry_t_net_to_host (mp);
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
rv = unformat_lisp_eid_api (&a->rmt_eid, mp->vni, mp->eid_type,
mp->rmt_eid, mp->rmt_len);
vnet_gpe_native_fwd_rpath_args_t _a, *a = &_a;
int rv = 0;
- memset (a, 0, sizeof (a[0]));
+ clib_memset (a, 0, sizeof (a[0]));
if (mp->is_ip4)
clib_memcpy (&a->rpath.frp_addr.ip4, mp->nh_addr, sizeof (ip4_address_t));
vec_foreach (e, src)
{
- memset (&dst[i], 0, sizeof (*dst));
+ clib_memset (&dst[i], 0, sizeof (*dst));
table = fib_table_get (e->frp_fib_index, dpo_proto_to_fib (e->frp_proto));
dst[i].fib_index = table->ft_table_id;
dst[i].nh_sw_if_index = e->frp_sw_if_index;
{
uword *p;
- memset (key, 0, sizeof (*key));
+ clib_memset (key, 0, sizeof (*key));
if (GID_ADDR_IP_PREFIX == gid_address_type (&a->rmt_eid))
{
if (LISP_GPE_FWD_ENTRY_TYPE_NORMAL != lfe->type)
return;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
key.fwd_entry_index = fwd_entry_index;
vec_foreach (path, lfe->paths)
return VNET_API_ERROR_INVALID_VALUE;
pool_get (lgm->lisp_fwd_entry_pool, lfe);
- memset (lfe, 0, sizeof (*lfe));
+ clib_memset (lfe, 0, sizeof (*lfe));
lfe->key = clib_mem_alloc (sizeof (key));
memcpy (lfe->key, &key, sizeof (key));
return VNET_API_ERROR_INVALID_VALUE;
pool_get (lgm->lisp_fwd_entry_pool, lfe);
- memset (lfe, 0, sizeof (*lfe));
+ clib_memset (lfe, 0, sizeof (*lfe));
lfe->key = clib_mem_alloc (sizeof (key));
memcpy (lfe->key, &key, sizeof (key));
int rv;
BVT (clib_bihash_kv) kv, value;
- memset (&kv, 0, sizeof (kv));
+ clib_memset (&kv, 0, sizeof (kv));
kv.key[0] = spi_si_net_order;
rv = BV (clib_bihash_search_inline_2) (&lgm->nsh_fib, &kv, &value);
BVT (clib_bihash_kv) kv, value;
u32 old_val = ~0;
- memset (&kv, 0, sizeof (kv));
+ clib_memset (&kv, 0, sizeof (kv));
kv.key[0] = clib_host_to_net_u32 (spi_si_host_order);
kv.value = 0ULL;
return VNET_API_ERROR_INVALID_VALUE;
pool_get (lgm->lisp_fwd_entry_pool, lfe);
- memset (lfe, 0, sizeof (*lfe));
+ clib_memset (lfe, 0, sizeof (*lfe));
lfe->key = clib_mem_alloc (sizeof (key));
memcpy (lfe->key, &key, sizeof (key));
uword *p;
u8 *s;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
key.fwd_entry_index = fwd_entry_index;
key.tunnel_index = ti;
({
if (lfe->key->vni == vni)
{
- memset (&e, 0, sizeof (e));
+ clib_memset (&e, 0, sizeof (e));
e.dp_table = lfe->eid_table_id;
e.vni = lfe->key->vni;
if (lfe->type == LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE)
lisp_gpe_sub_interface_key_t key;
- memset (&key, 0, sizeof (key));
+ clib_memset (&key, 0, sizeof (key));
ip_address_copy (&key.local_rloc, lrloc);
key.vni = vni;
p = hash_get_mem (lisp_gpe_sub_interfaces, &key);
return (INDEX_INVALID);
pool_get (lisp_gpe_sub_interface_pool, l3s);
- memset (l3s, 0, sizeof (*l3s));
+ clib_memset (l3s, 0, sizeof (*l3s));
l3s->key = clib_mem_alloc (sizeof (*l3s->key));
- memset (l3s->key, 0, sizeof (*l3s->key));
+ clib_memset (l3s->key, 0, sizeof (*l3s->key));
ip_address_copy (&l3s->key->local_rloc, lrloc);
l3s->key->vni = vni;
if (NULL == lt)
{
pool_get (lisp_gpe_tenant_pool, lt);
- memset (lt, 0, sizeof (*lt));
+ clib_memset (lt, 0, sizeof (*lt));
lt->lt_vni = vni;
lt->lt_table_id = ~0;
if (NULL == lgt)
{
pool_get (lisp_gpe_tunnel_pool, lgt);
- memset (lgt, 0, sizeof (*lgt));
+ clib_memset (lgt, 0, sizeof (*lgt));
lgt->key = clib_mem_alloc (sizeof (*lgt->key));
- memset (lgt->key, 0, sizeof (*lgt->key));
+ clib_memset (lgt->key, 0, sizeof (*lgt->key));
lgt->key->rmt = pair->rmt_loc;
lgt->key->lcl = pair->lcl_loc;
clib_error_t *error;
llc_main_t *pm = &llc_main;
- memset (pm, 0, sizeof (pm[0]));
+ clib_memset (pm, 0, sizeof (pm[0]));
pm->vlib_main = vm;
pm->protocol_info_by_name = hash_create_string (0, sizeof (uword));
u8 *port_desc = 0, *mgmt_ip4 = 0, *mgmt_ip6 = 0, *mgmt_oid = 0;
u8 no_data[256];
- memset (no_data, 0, 256);
+ clib_memset (no_data, 0, 256);
if (memcmp (mp->port_desc, no_data, strlen ((char *) mp->port_desc)) != 0)
{
if (p == 0)
{
pool_get (lm->intfs, n);
- memset (n, 0, sizeof (*n));
+ clib_memset (n, 0, sizeof (*n));
n->hw_if_index = hw_if_index;
hash_set (lm->intf_by_hw_if_index, n->hw_if_index, n - lm->intfs);
}
{
ethernet_header_t h;
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
/*
* Send to 01:80:C2:00:00:0E - propagation constrained to a single
h.dst_address[0] = 0x01;
h.dst_address[1] = 0x80;
h.dst_address[2] = 0xC2;
- /* h.dst_address[3] = 0x00; (memset) */
- /* h.dst_address[4] = 0x00; (memset) */
+ /* h.dst_address[3] = 0x00; (clib_memset) */
+ /* h.dst_address[4] = 0x00; (clib_memset) */
h.dst_address[5] = 0x0E;
/* leave src address blank (fill in at send time) */
mfib_table_t *mfib_table;
pool_get_aligned(ip4_main.mfibs, mfib_table, CLIB_CACHE_LINE_BYTES);
- memset(mfib_table, 0, sizeof(*mfib_table));
+ clib_memset(mfib_table, 0, sizeof(*mfib_table));
mfib_table->mft_proto = FIB_PROTOCOL_IP4;
mfib_table->mft_index =
}
else if (unformat (input, "%U/%d", unformat_ip4_address, &grp, &mask))
{
- memset(&src, 0, sizeof(src));
+ clib_memset(&src, 0, sizeof(src));
matching = 1;
}
else if (unformat (input, "%U", unformat_ip4_address, &grp))
{
- memset(&src, 0, sizeof(src));
+ clib_memset(&src, 0, sizeof(src));
matching = 1;
mask = 32;
}
};
pool_get_aligned(ip6_main.mfibs, mfib_table, CLIB_CACHE_LINE_BYTES);
- memset(mfib_table, 0, sizeof(*mfib_table));
+ clib_memset(mfib_table, 0, sizeof(*mfib_table));
mfib_table->mft_proto = FIB_PROTOCOL_IP6;
mfib_table->mft_index =
if (_len <= 128) \
{ \
memcpy((_key)->mask+1, &ip6_main.fib_masks[_len], 16); \
- memset((_key)->mask+17, 0, 16); \
+ clib_memset((_key)->mask+17, 0, 16); \
} \
else \
{ \
{
ip6_mfib_node_t *i6mn = clib_mem_alloc(sizeof(*i6mn));
- memset(i6mn->i6mn_nodes, 0, sizeof(i6mn->i6mn_nodes));
+ clib_memset(i6mn->i6mn_nodes, 0, sizeof(i6mn->i6mn_nodes));
IP6_MFIB_MK_KEY_MASK(grp, src, len, &i6mn->i6mn_key);
i6mn->i6mn_entry = mfib_entry_index;
}
else if (unformat (input, "%U/%d", unformat_ip6_address, &grp, &mask))
{
- memset(&src, 0, sizeof(src));
+ clib_memset(&src, 0, sizeof(src));
matching = 1;
}
else if (unformat (input, "%U", unformat_ip6_address, &grp))
{
- memset(&src, 0, sizeof(src));
+ clib_memset(&src, 0, sizeof(src));
matching = 1;
mask = 128;
}
/*
* Some of the members require non-default initialisation
- * so we also init those that don't and thus save on the call to memset.
+ * so we also init those that don't and thus save on the call to clib_memset.
*/
mfib_entry->mfe_flags = 0;
mfib_entry->mfe_fib_index = fib_index;
int res;
mfib_prefix_t all_1s;
- memset(&all_1s, 0xfd, sizeof(all_1s));
+ clib_memset(&all_1s, 0xfd, sizeof(all_1s));
res = 0;
n_entries = pool_elts(mfib_entry_pool);
eos = MPLS_EOS;
is_del = 0;
local_label = MPLS_LABEL_INVALID;
- memset(&pfx, 0, sizeof(pfx));
+ clib_memset(&pfx, 0, sizeof(pfx));
payload_proto = DPO_PROTO_MPLS;
/* Get a line of input. */
return (rv);
ip46_address_t nh;
- memset (&nh, 0, sizeof (nh));
+ clib_memset (&nh, 0, sizeof (nh));
if (DPO_PROTO_IP4 == mp->mr_next_hop_proto)
memcpy (&nh.ip4, mp->mr_next_hop, sizeof (nh.ip4));
fib_route_path_t rpath, *rpaths = NULL;
int ii, rv = 0;
- memset (&rpath, 0, sizeof (rpath));
+ clib_memset (&rpath, 0, sizeof (rpath));
stats_dslock_with_hint (1 /* release hint */ , 5 /* tag */ );
n = fib_path_list_get_n_paths (mt->mt_path_list);
mp = vl_msg_api_alloc (sizeof (*mp) + n * sizeof (vl_api_fib_path_t));
- memset (mp, 0, sizeof (*mp) + n * sizeof (vl_api_fib_path_t));
+ clib_memset (mp, 0, sizeof (*mp) + n * sizeof (vl_api_fib_path_t));
mp->_vl_msg_id = ntohs (VL_API_MPLS_TUNNEL_DETAILS);
mp->context = ctx->context;
mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
if (!mp)
return;
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MPLS_FIB_DETAILS);
mp->context = context;
vnm = vnet_get_main();
pool_get(mpls_tunnel_pool, mt);
- memset (mt, 0, sizeof (*mt));
+ clib_memset (mt, 0, sizeof (*mt));
mti = mt - mpls_tunnel_pool;
fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL);
mt->mt_path_list = FIB_NODE_INDEX_INVALID;
u32 sw_if_index = ~0, payload_proto;
clib_error_t *error = NULL;
- memset(&rpath, 0, sizeof(rpath));
+ clib_memset(&rpath, 0, sizeof(rpath));
payload_proto = DPO_PROTO_MPLS;
/* Get a line of input. */
if ((error = vlib_call_init_function (vm, llc_init)))
return error;
- memset (pm, 0, sizeof (pm[0]));
+ clib_memset (pm, 0, sizeof (pm[0]));
pm->vlib_main = vm;
pm->protocol_info_by_name = hash_create_string (0, sizeof (uword));
pi = pool_elt_at_index (pg->interfaces, a->dev_instance);
vec_free (pi->pcap_file_name);
- memset (&pi->pcap_main, 0, sizeof (pi->pcap_main));
+ clib_memset (&pi->pcap_main, 0, sizeof (pi->pcap_main));
if (a->is_enabled == 0)
return 0;
#else
pcap_main_t pm;
clib_error_t *error;
- memset (&pm, 0, sizeof (pm));
+ clib_memset (&pm, 0, sizeof (pm));
pm.file_name = file_name;
error = pcap_read (&pm);
s->replay_packet_templates = pm.packets_read;
pg_edit_group_t *g = pg_stream_get_group (s, i);
pg_edit_group_free (g);
- memset (g, 0, sizeof (g[0]));
+ clib_memset (g, 0, sizeof (g[0]));
_vec_len (s->edit_groups) = i;
}
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- memset (&c, 0, sizeof (c));
+ clib_memset (&c, 0, sizeof (c));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
name = format (0, "%s", mp->name);
vec_terminate_c_string (name);
- memset (&cfg, 0, sizeof (cfg));
+ clib_memset (&cfg, 0, sizeof (cfg));
cfg.rfc = mp->type;
cfg.rnd_type = mp->round_type;
cfg.rate_type = mp->rate_type;
vl_api_policer_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_POLICER_DETAILS);
mp->context = context;
mp->cir = htonl (config->rb.kbps.cir_kbps);
/*
* clear the hw_params
*/
- memset (hw, 0, sizeof (sse2_qos_pol_hw_params_st));
+ clib_memset (hw, 0, sizeof (sse2_qos_pol_hw_params_st));
hw->allow_negative = SSE2_QOS_POL_ALLOW_NEGATIVE;
int rc;
sse2_qos_pol_cfg_params_st kbps_cfg;
- memset (phys, 0, sizeof (policer_read_response_type_st));
- memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
+ clib_memset (phys, 0, sizeof (policer_read_response_type_st));
+ clib_memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
if (!cfg)
{
sse2_qos_convert_pol_bucket_to_hw_fmt (policer_read_response_type_st * bkt,
sse2_qos_pol_hw_params_st * hw_fmt)
{
- memset (hw_fmt, 0, sizeof (sse2_qos_pol_hw_params_st));
+ clib_memset (hw_fmt, 0, sizeof (sse2_qos_pol_hw_params_st));
#if !defined (INTERNAL_SS) && !defined (X86)
hw_fmt->rfc = (u8) bkt->rfc;
hw_fmt->allow_negative = (u8) bkt->an;
sse2_qos_pol_hw_params_st pol_hw;
sse2_qos_pol_cfg_params_st kbps_cfg;
- memset (&pol_hw, 0, sizeof (sse2_qos_pol_hw_params_st));
- memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
+ clib_memset (&pol_hw, 0, sizeof (sse2_qos_pol_hw_params_st));
+ clib_memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
if (!phys)
{
{
ppp_main_t *pm = &ppp_main;
- memset (pm, 0, sizeof (pm[0]));
+ clib_memset (pm, 0, sizeof (pm[0]));
pm->vlib_main = vm;
pm->protocol_info_by_name = hash_create_string (0, sizeof (uword));
pool_get_aligned (qem_pool, qem, CLIB_CACHE_LINE_BYTES);
qemi = qem - qem_pool;
- memset (qem, 0, sizeof (*qem));
+ clib_memset (qem, 0, sizeof (*qem));
hash_set (qem_db, mid, qemi);
}
void *iface_ip;
pool_get (tm->listener_pool, listener);
- memset (listener, 0, sizeof (*listener));
+ clib_memset (listener, 0, sizeof (*listener));
listener->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
SCTP_PRIMARY_PATH_IDX;
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
+ clib_memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
pool_put_index (tm->listener_pool, listener_index);
}
sctp_connection_t *sctp_conn;
pool_get (sctp_main->connections[thread_index], sctp_conn);
- memset (sctp_conn, 0, sizeof (*sctp_conn));
+ clib_memset (sctp_conn, 0, sizeof (*sctp_conn));
sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
SCTP_PRIMARY_PATH_IDX;
sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
sctp_connection_t *sctp_conn = 0;
ASSERT (vlib_get_thread_index () == 0);
pool_get (tm->half_open_connections, sctp_conn);
- memset (sctp_conn, 0, sizeof (*sctp_conn));
+ clib_memset (sctp_conn, 0, sizeof (*sctp_conn));
sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index =
sctp_conn - tm->half_open_connections;
sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx =
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
+ clib_memset (sctp_conn, 0xFA, sizeof (*sctp_conn));
pool_put (tm->connections[thread_index], sctp_conn);
}
pool_put_index (sctp_main->half_open_connections,
tc->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index);
if (CLIB_DEBUG)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
clib_spinlock_unlock_if_init (&sctp_main->half_open_lock);
}
}
else
{
- memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
+ clib_memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
}
clib_memcpy (&t0->sctp_connection, sctp_conn,
sizeof (t0->sctp_connection));
{
h->param_hdr.length = FQDN_MAX_LENGTH;
h->param_hdr.type = clib_host_to_net_u16 (SCTP_HOSTNAME_ADDRESS_TYPE);
- memset (h->hostname, '0', FQDN_MAX_LENGTH);
+ clib_memset (h->hostname, '0', FQDN_MAX_LENGTH);
memcpy (h->hostname, hostname, FQDN_MAX_LENGTH);
}
pool_get (ecm->sessions, session);
clib_spinlock_unlock_if_init (&ecm->sessions_lock);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - ecm->sessions;
session->bytes_to_send = ecm->bytes_to_send;
session->bytes_to_receive = ecm->no_return ? 0ULL : ecm->bytes_to_send;
u64 options[16];
clib_error_t *error = 0;
- memset (a, 0, sizeof (*a));
- memset (options, 0, sizeof (options));
+ clib_memset (a, 0, sizeof (*a));
+ clib_memset (options, 0, sizeof (options));
a->api_client_index = ecm->my_client_index;
a->session_cb_vft = &echo_clients;
clib_error_t *error = 0;
int i;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
for (i = 0; i < n_clients; i++)
{
a->uri = (char *) ecm->connect_uri;
u64 options[APP_OPTIONS_N_OPTIONS];
u32 segment_size = 512 << 20;
- memset (a, 0, sizeof (*a));
- memset (options, 0, sizeof (options));
+ clib_memset (a, 0, sizeof (*a));
+ clib_memset (options, 0, sizeof (options));
if (esm->no_echo)
echo_server_session_cb_vft.builtin_app_rx_callback =
}
esm->app_index = a->app_index;
- memset (a_cert, 0, sizeof (*a_cert));
+ clib_memset (a_cert, 0, sizeof (*a_cert));
a_cert->app_index = a->app_index;
vec_validate (a_cert->cert, test_srv_crt_rsa_len);
clib_memcpy (a_cert->cert, test_srv_crt_rsa, test_srv_crt_rsa_len);
vnet_app_add_tls_cert (a_cert);
- memset (a_key, 0, sizeof (*a_key));
+ clib_memset (a_key, 0, sizeof (*a_key));
a_key->app_index = a->app_index;
vec_validate (a_key->key, test_srv_key_rsa_len);
clib_memcpy (a_key->key, test_srv_key_rsa, test_srv_key_rsa_len);
{
echo_server_main_t *esm = &echo_server_main;
vnet_bind_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->app_index = esm->app_index;
a->uri = esm->server_uri;
return vnet_bind_uri (a);
vnet_app_attach_args_t _a, *a = &_a;
u32 segment_size = 128 << 20;
- memset (a, 0, sizeof (*a));
- memset (options, 0, sizeof (options));
+ clib_memset (a, 0, sizeof (*a));
+ clib_memset (options, 0, sizeof (options));
if (hsm->private_segment_size)
segment_size = hsm->private_segment_size;
}
hsm->app_index = a->app_index;
- memset (a_cert, 0, sizeof (*a_cert));
+ clib_memset (a_cert, 0, sizeof (*a_cert));
a_cert->app_index = a->app_index;
vec_validate (a_cert->cert, test_srv_crt_rsa_len);
clib_memcpy (a_cert->cert, test_srv_crt_rsa, test_srv_crt_rsa_len);
vnet_app_add_tls_cert (a_cert);
- memset (a_key, 0, sizeof (*a_key));
+ clib_memset (a_key, 0, sizeof (*a_key));
a_key->app_index = a->app_index;
vec_validate (a_key->key, test_srv_key_rsa_len);
clib_memcpy (a_key->key, test_srv_key_rsa, test_srv_key_rsa_len);
{
http_server_main_t *hsm = &http_server_main;
vnet_bind_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->app_index = hsm->app_index;
a->uri = "tcp://0.0.0.0/80";
if (hsm->uri)
if (ps)
{
if (CLIB_DEBUG > 0)
- memset (ps, 0xFE, sizeof (*ps));
+ clib_memset (ps, 0xFE, sizeof (*ps));
pool_put (pm->sessions, ps);
}
/* $$$ your message in this space: parse url, etc. */
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
clib_spinlock_lock_if_init (&pm->sessions_lock);
pool_get (pm->sessions, ps);
- memset (ps, 0, sizeof (*ps));
+ clib_memset (ps, 0, sizeof (*ps));
ps->server_rx_fifo = rx_fifo;
ps->server_tx_fifo = tx_fifo;
ps->vpp_server_handle = session_handle (s);
vnet_app_attach_args_t _a, *a = &_a;
u32 segment_size = 512 << 20;
- memset (a, 0, sizeof (*a));
- memset (options, 0, sizeof (options));
+ clib_memset (a, 0, sizeof (*a));
+ clib_memset (options, 0, sizeof (options));
if (pm->private_segment_size)
segment_size = pm->private_segment_size;
vnet_app_attach_args_t _a, *a = &_a;
u64 options[16];
- memset (a, 0, sizeof (*a));
- memset (options, 0, sizeof (options));
+ clib_memset (a, 0, sizeof (*a));
+ clib_memset (options, 0, sizeof (options));
a->api_client_index = pm->active_open_client_index;
a->session_cb_vft = &active_open_clients;
{
proxy_main_t *pm = &proxy_main;
vnet_bind_args_t _a, *a = &_a;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->app_index = pm->server_app_index;
a->uri = (char *) pm->server_uri;
return vnet_bind_uri (a);
{
app_listener_t *app_listener;
pool_get (app->listeners, app_listener);
- memset (app_listener, 0, sizeof (*app_listener));
+ clib_memset (app_listener, 0, sizeof (*app_listener));
app_listener->al_index = app_listener - app->listeners;
return app_listener;
}
clib_bitmap_free (app_listener->workers);
pool_put (app->listeners, app_listener);
if (CLIB_DEBUG)
- memset (app_listener, 0xfa, sizeof (*app_listener));
+ clib_memset (app_listener, 0xfa, sizeof (*app_listener));
}
static app_listener_t *
{
app_listener_t *app_listener;
pool_get (app->local_listeners, app_listener);
- memset (app_listener, 0, sizeof (*app_listener));
+ clib_memset (app_listener, 0, sizeof (*app_listener));
app_listener->al_index = app_listener - app->local_listeners;
return app_listener;
}
clib_bitmap_free (app_listener->workers);
pool_put (app->local_listeners, app_listener);
if (CLIB_DEBUG)
- memset (app_listener, 0xfa, sizeof (*app_listener));
+ clib_memset (app_listener, 0xfa, sizeof (*app_listener));
}
static app_worker_map_t *
{
app_worker_map_t *map;
pool_get (app->worker_maps, map);
- memset (map, 0, sizeof (*map));
+ clib_memset (map, 0, sizeof (*map));
return map;
}
{
application_t *app;
pool_get (app_main.app_pool, app);
- memset (app, 0, sizeof (*app));
+ clib_memset (app, 0, sizeof (*app));
app->app_index = app - app_main.app_pool;
return app;
}
{
app_worker_t *app_wrk;
pool_get (app_main.workers, app_wrk);
- memset (app_wrk, 0, sizeof (*app_wrk));
+ clib_memset (app_wrk, 0, sizeof (*app_wrk));
app_wrk->wrk_index = app_wrk - app_main.workers;
app_wrk->app_index = app->app_index;
app_wrk->wrk_map_index = ~0;
pool_put (app_main.workers, app_wrk);
if (CLIB_DEBUG)
- memset (app_wrk, 0xfe, sizeof (*app_wrk));
+ clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
}
int
{
local_session_t *s;
pool_get (app_wrk->local_sessions, s);
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
s->app_wrk_index = app_wrk->wrk_index;
s->session_index = s - app_wrk->local_sessions;
s->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
{
pool_put (app->local_sessions, s);
if (CLIB_DEBUG)
- memset (s, 0xfc, sizeof (*s));
+ clib_memset (s, 0xfc, sizeof (*s));
}
local_session_t *
{
local_session_t *ll;
pool_get (app->local_listen_sessions, ll);
- memset (ll, 0, sizeof (*ll));
+ clib_memset (ll, 0, sizeof (*ll));
return ll;
}
{
pool_put (app->local_listen_sessions, ll);
if (CLIB_DEBUG)
- memset (ll, 0xfb, sizeof (*ll));
+ clib_memset (ll, 0xfb, sizeof (*ll));
}
int
SVM_Q_WAIT, &app_evt->msg);
svm_msg_q_unlock (mq);
app_evt->evt = svm_msg_q_msg_data (mq, &app_evt->msg);
- memset (app_evt->evt, 0, sizeof (*app_evt->evt));
+ clib_memset (app_evt->evt, 0, sizeof (*app_evt->evt));
app_evt->evt->event_type = evt_type;
}
{
app_namespace_t *app_ns;
pool_get (app_namespace_pool, app_ns);
- memset (app_ns, 0, sizeof (*app_ns));
+ clib_memset (app_ns, 0, sizeof (*app_ns));
app_ns->ns_id = vec_dup (ns_id);
hash_set_mem (app_namespace_lookup_table, app_ns->ns_id,
app_ns - app_namespace_pool);
{
RTT (mma_rule) * rule;
pool_get (srt->rules, rule);
- memset (rule, 0, sizeof (*rule));
+ clib_memset (rule, 0, sizeof (*rule));
return rule;
}
RT (mma_rule_free) (RTT (mma_rules_table) * srt, RTT (mma_rule) * rule)
{
pool_put (srt->rules, rule);
- memset (rule, 0xfa, sizeof (*rule));
+ clib_memset (rule, 0xfa, sizeof (*rule));
return rule;
}
ssvm_delete (&fs->ssvm);
if (CLIB_DEBUG)
- memset (fs, 0xfb, sizeof (*fs));
+ clib_memset (fs, 0xfb, sizeof (*fs));
pool_put (sm->segments, fs);
}
{
pool_get (sm->segments, seg);
}
- memset (seg, 0, sizeof (*seg));
+ clib_memset (seg, 0, sizeof (*seg));
/*
* Initialize ssvm segment and svm fifo private header
segment_manager_main_t *smm = &segment_manager_main;
segment_manager_t *sm;
pool_get (smm->segment_managers, sm);
- memset (sm, 0, sizeof (*sm));
+ clib_memset (sm, 0, sizeof (*sm));
clib_rwlock_init (&sm->segments_rwlock);
return sm;
}
clib_rwlock_free (&sm->segments_rwlock);
if (CLIB_DEBUG)
- memset (sm, 0xfe, sizeof (*sm));
+ clib_memset (sm, 0xfe, sizeof (*sm));
pool_put (smm->segment_managers, sm);
}
pool_get_aligned (session_manager_main.sessions[thread_index], s,
CLIB_CACHE_LINE_BYTES);
}
- memset (s, 0, sizeof (*s));
+ clib_memset (s, 0, sizeof (*s));
s->session_index = s - session_manager_main.sessions[thread_index];
s->thread_index = thread_index;
return s;
{
pool_put (session_manager_main.sessions[s->thread_index], s);
if (CLIB_DEBUG)
- memset (s, 0xFA, sizeof (*s));
+ clib_memset (s, 0xFA, sizeof (*s));
}
void
if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index)
{
vec_add2 (smm->pending_disconnects[s->thread_index], evt, 1);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->session_handle = session_handle (s);
evt->event_type = FIFO_EVENT_DISCONNECT;
}
}
mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT);
mp->segment_size = sp->ssvm_size;
mp->fd_flags = fd_flags;
}
mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_UNMAP_SEGMENT);
strncpy ((char *) mp->segment_name, (char *) fs->name,
sizeof (mp->segment_name) - 1);
}
mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id =
clib_host_to_net_u16 (VL_API_APP_CUT_THROUGH_REGISTRATION_ADD);
}
mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_ACCEPT_SESSION);
mp->context = server_wrk->wrk_index;
}
mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_DISCONNECT_SESSION);
mp->handle = session_handle (s);
mp->context = app->api_client_index;
}
mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_RESET_SESSION);
mp->handle = session_handle (s);
vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
return -1;
evt = svm_msg_q_msg_data (app_mq, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_ACCEPTED;
mp = (session_accepted_msg_t *) evt->data;
mp->context = app->app_index;
if (mq_try_lock_and_alloc_msg (app_mq, msg))
return;
evt = svm_msg_q_msg_data (app_mq, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
mp = (session_disconnected_msg_t *) evt->data;
mp->handle = session_handle (s);
if (mq_try_lock_and_alloc_msg (app_mq, msg))
return;
evt = svm_msg_q_msg_data (app_mq, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
mp = (session_disconnected_msg_t *) evt->data;
mp->handle = application_local_session_handle (ls);
if (mq_try_lock_and_alloc_msg (app_mq, msg))
return;
evt = svm_msg_q_msg_data (app_mq, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_RESET;
mp = (session_reset_msg_t *) evt->data;
mp->handle = session_handle (s);
if (mq_try_lock_and_alloc_msg (app_mq, msg))
return -1;
evt = svm_msg_q_msg_data (app_mq, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_CONNECTED;
mp = (session_connected_msg_t *) evt->data;
mp->context = api_context;
return -1;
evt = svm_msg_q_msg_data (app_mq, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_BOUND;
mp = (session_bound_msg_t *) evt->data;
mp->context = api_context;
sizeof (mp->options),
"Out of options, fix api message definition");
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->api_client_index = mp->client_index;
a->options = mp->options;
app = application_lookup (mp->client_index);
if (app)
{
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->uri = (char *) mp->uri;
a->app_index = app->app_index;
rv = vnet_bind_uri (a);
app = application_lookup (mp->client_index);
if (app)
{
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->uri = (char *) mp->uri;
a->api_context = mp->context;
a->app_index = app->app_index;
}
ip46 = (ip46_address_t *) mp->ip;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->sep.is_ip4 = mp->is_ip4;
a->sep.ip = *ip46;
a->sep.port = mp->port;
svm_queue_t *client_q;
ip46_address_t *ip46 = (ip46_address_t *) mp->ip;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
client_q = vl_api_client_index_to_input_queue (mp->client_index);
mp->client_queue_address = pointer_to_uword (client_q);
a->sep.is_ip4 = mp->is_ip4;
u8 fib_proto;
int rv = 0;
- memset (&args, 0, sizeof (args));
+ clib_memset (&args, 0, sizeof (args));
fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
table_args->lcl.fp_len = mp->lcl_plen;
args.scope = mp->scope;
args.transport_proto = mp->transport_proto;
- memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
- memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
+ clib_memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
+ clib_memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4);
ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4);
error = vnet_session_rule_add_del (&args);
(session_mask_or_match_4_t *) & rule->mask;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
rmp->context = context;
(session_mask_or_match_6_t *) & rule->mask;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
rmp->context = context;
rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->app_index = app->app_index;
cert_len = clib_net_to_host_u16 (mp->cert_len);
if (cert_len > 10000)
rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->app_index = app->app_index;
key_len = clib_net_to_host_u16 (mp->key_len);
if (key_len > 10000)
u8 *is_ip4 = va_arg (*args, u8 *);
u8 tuple_is_set = 0;
- memset (lcl, 0, sizeof (*lcl));
- memset (rmt, 0, sizeof (*rmt));
+ clib_memset (lcl, 0, sizeof (*lcl));
+ clib_memset (rmt, 0, sizeof (*rmt));
if (unformat (input, "tcp"))
{
return kv4.value;
if (use_rules)
{
- memset (&lcl4, 0, sizeof (lcl4));
+ clib_memset (&lcl4, 0, sizeof (lcl4));
srt = &st->session_rules[sep->transport_proto];
ai = session_rules_table_lookup4 (srt, &lcl4, &sep->ip.ip4, 0,
sep->port);
if (use_rules)
{
- memset (&lcl6, 0, sizeof (lcl6));
+ clib_memset (&lcl6, 0, sizeof (lcl6));
srt = &st->session_rules[sep->transport_proto];
ai = session_rules_table_lookup6 (srt, &lcl6, &sep->ip.ip6, 0,
sep->port);
/*
* Check if endpoint has special rules associated
*/
- memset (&lcl4, 0, sizeof (lcl4));
+ clib_memset (&lcl4, 0, sizeof (lcl4));
srt = &st->session_rules[sep->transport_proto];
ai = session_rules_table_lookup4 (srt, &lcl4, &sep->ip.ip4, 0,
sep->port);
session_kv6_t kv6;
ip6_address_t lcl6;
- memset (&lcl6, 0, sizeof (lcl6));
+ clib_memset (&lcl6, 0, sizeof (lcl6));
srt = &st->session_rules[sep->transport_proto];
ai = session_rules_table_lookup6 (srt, &lcl6, &sep->ip.ip6, 0,
sep->port);
}
if (args->scope & SESSION_RULE_SCOPE_LOCAL)
{
- memset (&args->table_args.lcl, 0, sizeof (args->table_args.lcl));
+ clib_memset (&args->table_args.lcl, 0, sizeof (args->table_args.lcl));
args->table_args.lcl.fp_proto = args->table_args.rmt.fp_proto;
args->table_args.lcl_port = 0;
st = app_namespace_get_local_table (app_ns);
app_namespace_t *app_ns;
clib_error_t *error;
- memset (&lcl_ip, 0, sizeof (lcl_ip));
- memset (&rmt_ip, 0, sizeof (rmt_ip));
+ clib_memset (&lcl_ip, 0, sizeof (lcl_ip));
+ clib_memset (&rmt_ip, 0, sizeof (rmt_ip));
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "del"))
session_table_t *st;
u8 *ns_id = 0, fib_proto;
- memset (&lcl_ip, 0, sizeof (lcl_ip));
- memset (&rmt_ip, 0, sizeof (rmt_ip));
+ clib_memset (&lcl_ip, 0, sizeof (lcl_ip));
+ clib_memset (&rmt_ip, 0, sizeof (rmt_ip));
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "%U", unformat_transport_proto, &transport_proto))
SVM_Q_WAIT, msg);
svm_msg_q_unlock (app_wrk->event_queue);
evt = svm_msg_q_msg_data (app_wrk->event_queue, msg);
- memset (evt, 0, sizeof (*evt));
+ clib_memset (evt, 0, sizeof (*evt));
evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
rmp = (session_disconnected_reply_msg_t *) evt->data;
rmp->handle = mp->handle;
{
mma_rule_16_t _rule;
rule = &_rule;
- memset (rule, 0, sizeof (*rule));
+ clib_memset (rule, 0, sizeof (*rule));
session_rules_table_init_rule_16 (rule, &args->lcl,
args->lcl_port, &args->rmt,
args->rmt_port);
{
mma_rule_40_t _rule;
rule = &_rule;
- memset (rule, 0, sizeof (*rule));
+ clib_memset (rule, 0, sizeof (*rule));
session_rules_table_init_rule_40 (rule, &args->lcl,
args->lcl_port, &args->rmt,
args->rmt_port);
mma_rule_40_t *rule6;
fib_prefix_t null_prefix;
- memset (&null_prefix, 0, sizeof (null_prefix));
+ clib_memset (&null_prefix, 0, sizeof (null_prefix));
srt4 = &srt->session_rules_tables_16;
rule4 = session_rules_table_alloc_rule_16 (srt4, &null_prefix, 0,
{
session_table_t *slt;
pool_get_aligned (lookup_tables, slt, CLIB_CACHE_LINE_BYTES);
- memset (slt, 0, sizeof (*slt));
+ clib_memset (slt, 0, sizeof (*slt));
return slt;
}
{
u8 intf_mac[6];
- memset (intf_mac, 0, sizeof (intf_mac));
+ clib_memset (intf_mac, 0, sizeof (intf_mac));
if (vnet_create_loopback_interface (sw_if_index, intf_mac, 0, 0))
{
clib_error_t *error = 0;
u32 server_index;
- memset (options, 0, sizeof (options));
+ clib_memset (options, 0, sizeof (options));
options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
server_sep.port = dummy_port;
client_sep.is_ip4 = 1;
client_sep.port = dummy_port;
- memset (options, 0, sizeof (options));
+ clib_memset (options, 0, sizeof (options));
options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
vnet_app_attach_args_t attach_args = {
}
}
- memset (srt, 0, sizeof (*srt));
+ clib_memset (srt, 0, sizeof (*srt));
session_rules_table_init (srt);
ip4_address_t lcl_ip = {
server_sep.is_ip4 = 1;
server_sep.port = dummy_port;
- memset (options, 0, sizeof (options));
+ clib_memset (options, 0, sizeof (options));
vnet_app_attach_args_t attach_args = {
.api_client_index = ~0,
app_ns = app_namespace_get_default ();
app_ns->sw_if_index = sw_if_index;
- memset (options, 0, sizeof (options));
+ clib_memset (options, 0, sizeof (options));
options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_ACCEPT_REDIRECT;
options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_IS_PROXY;
return -1;
}
- memset (lcl_addr, 0, sizeof (*lcl_addr));
+ clib_memset (lcl_addr, 0, sizeof (*lcl_addr));
if (rmt->is_ip4)
{
{
snap_main_t *sm = &snap_main;
- memset (sm, 0, sizeof (sm[0]));
+ clib_memset (sm, 0, sizeof (sm[0]));
sm->vlib_main = vm;
mhash_init (&sm->protocol_hash, sizeof (uword),
clib_bitmap_foreach (i, b, (
{
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_SPAN_DETAILS);
rmp->context = mp->context;
{
vl_api_sr_mpls_steering_add_del_reply_t *rmp;
ip46_address_t prefix;
- memset (&prefix, 0, sizeof (ip46_address_t));
+ clib_memset (&prefix, 0, sizeof (ip46_address_t));
if (mp->traffic_type == SR_STEER_IPV4)
memcpy (&prefix.ip4, mp->prefix_addr, sizeof (prefix.ip4));
else
int rv = 0;
ip46_address_t endpoint;
- memset (&endpoint, 0, sizeof (ip46_address_t));
+ clib_memset (&endpoint, 0, sizeof (ip46_address_t));
if (mp->endpoint_type == SR_STEER_IPV4)
memcpy (&endpoint.ip4, mp->endpoint, sizeof (endpoint.ip4));
else
u32 ii;
pool_get (sm->sid_lists, segment_list);
- memset (segment_list, 0, sizeof (*segment_list));
+ clib_memset (segment_list, 0, sizeof (*segment_list));
vec_add1 (sr_policy->segments_lists, segment_list - sm->sid_lists);
}
/* Add an SR policy object */
pool_get (sm->sr_policies, sr_policy);
- memset (sr_policy, 0, sizeof (*sr_policy));
+ clib_memset (sr_policy, 0, sizeof (*sr_policy));
/* the first policy needs to lock the MPLS table so it doesn't
* disappear with policies in it */
u8 endpoint_type = 0;
char clear = 0, color_set = 0, bsid_set = 0;
- memset (&endpoint, 0, sizeof (ip46_address_t));
+ clib_memset (&endpoint, 0, sizeof (ip46_address_t));
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
if (!color_table)
{
mhash_t color_t;
- memset (&color_t, 0, sizeof (mhash_t));
+ clib_memset (&color_t, 0, sizeof (mhash_t));
mhash_init (&color_t, sizeof (u32), sizeof (ip46_address_t));
mhash_set_mem (&sm->sr_policies_c2e2eclabel_hash, &color,
(uword *) & color_t, NULL);
mpls_sr_policy_t *sr_policy = 0;
uword *p = 0;
- memset (&key, 0, sizeof (sr_mpls_steering_key_t));
+ clib_memset (&key, 0, sizeof (sr_mpls_steering_key_t));
if (traffic_type != SR_STEER_IPV4 && traffic_type != SR_STEER_IPV6)
return -1;
/* Create a new steering policy */
pool_get (sm->steer_policies, steer_pl);
- memset (steer_pl, 0, sizeof (*steer_pl));
+ clib_memset (steer_pl, 0, sizeof (*steer_pl));
clib_memcpy (&steer_pl->classify.prefix, prefix, sizeof (ip46_address_t));
clib_memcpy (&steer_pl->next_hop, next_hop, sizeof (ip46_address_t));
steer_pl->nh_type = nh_type;
fib_prefix_t pfx = { 0 };
uword *p = 0;
- memset (&key, 0, sizeof (sr_mpls_steering_key_t));
+ clib_memset (&key, 0, sizeof (sr_mpls_steering_key_t));
/* Compute the steer policy key */
if (traffic_type != SR_STEER_IPV4 && traffic_type != SR_STEER_IPV6)
u8 sr_policy_set = 0;
- memset (&prefix, 0, sizeof (ip46_address_t));
- memset (&nh, 0, sizeof (ip46_address_t));
+ clib_memset (&prefix, 0, sizeof (ip46_address_t));
+ clib_memset (&nh, 0, sizeof (ip46_address_t));
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
if (dst_address)
clib_memcpy (h->ethernet.dst_address, dst_address, sizeof (h->ethernet.dst_address));
else
- memset (h->ethernet.dst_address, ~0, sizeof (h->ethernet.dst_address)); /* broadcast */
+ clib_memset (h->ethernet.dst_address, ~0, sizeof (h->ethernet.dst_address)); /* broadcast */
h->ethernet.type = clib_host_to_net_u16 (type);
else
{
pool_get (sm->interface_pool, si);
- memset (si, 0, sizeof (si[0]));
+ clib_memset (si, 0, sizeof (si[0]));
}
for (s = 0; s < SRP_N_SIDE; s++)
{
if (! unformat_user (input, unformat_ethernet_address, &address))
{
- memset (address, 0, sizeof (address));
+ clib_memset (address, 0, sizeof (address));
address[0] = 0xde;
address[1] = 0xad;
address[5] = instance;
srp_ring_type_t tx_ring,
srp_ips_header_t * i)
{
- memset (i, 0, sizeof (i[0]));
+ clib_memset (i, 0, sizeof (i[0]));
i->srp.ttl = 1;
i->srp.is_inner_ring = tx_ring;
ip46_address_t prefix;
- memset (&prefix, 0, sizeof (ip46_address_t));
+ clib_memset (&prefix, 0, sizeof (ip46_address_t));
if ((mp->nh_addr4[0] | mp->nh_addr4[1] | mp->
nh_addr4[2] | mp->nh_addr4[3]) != 0)
memcpy (&prefix.ip4, mp->nh_addr4, sizeof (prefix.ip4));
vl_api_sr_localsids_details_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_SR_LOCALSIDS_DETAILS);
clib_memcpy (rmp->addr.addr, &t->localsid, sizeof (ip6_address_t));
rmp->end_psp = t->end_psp;
rmp = vl_msg_api_alloc (sizeof (*rmp) +
vec_len (t->segments_lists) *
sizeof (vl_api_srv6_sid_list_t));
- memset (rmp, 0,
- (sizeof (*rmp) +
- vec_len (t->segments_lists) * sizeof (vl_api_srv6_sid_list_t)));
+ clib_memset (rmp, 0,
+ (sizeof (*rmp) +
+ vec_len (t->segments_lists) *
+ sizeof (vl_api_srv6_sid_list_t)));
rmp->_vl_msg_id = ntohs (VL_API_SR_POLICIES_DETAILS);
clib_memcpy (rmp->bsid.addr, &t->bsid, sizeof (ip6_address_t));
ip6_sr_main_t *sm = &sr_main;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_SR_STEERING_POL_DETAILS);
//Get the SR policy BSID
/* Create a new localsid registry */
pool_get (sm->localsids, ls);
- memset (ls, 0, sizeof (*ls));
+ clib_memset (ls, 0, sizeof (*ls));
clib_memcpy (&ls->localsid, localsid_addr, sizeof (ip6_address_t));
ls->end_psp = end_psp;
int rv;
- memset (&resulting_address, 0, sizeof (ip6_address_t));
+ clib_memset (&resulting_address, 0, sizeof (ip6_address_t));
ip46_address_reset (&next_hop);
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
plugin - sm->plugin_functions);
}
- memset (plugin, 0, sizeof (*plugin));
+ clib_memset (plugin, 0, sizeof (*plugin));
plugin->sr_localsid_function_number = (plugin - sm->plugin_functions);
plugin->sr_localsid_function_number += SR_BEHAVIOR_LAST;
ip6_sr_sl_t *segment_list;
pool_get (sm->sid_lists, segment_list);
- memset (segment_list, 0, sizeof (*segment_list));
+ clib_memset (segment_list, 0, sizeof (*segment_list));
vec_add1 (sr_policy->segments_lists, segment_list - sm->sid_lists);
/* Add an SR policy object */
pool_get (sm->sr_policies, sr_policy);
- memset (sr_policy, 0, sizeof (*sr_policy));
+ clib_memset (sr_policy, 0, sizeof (*sr_policy));
clib_memcpy (&sr_policy->bsid, bsid, sizeof (ip6_address_t));
sr_policy->type = behavior;
sr_policy->fib_table = (fib_table != (u32) ~ 0 ? fib_table : 0); //Is default FIB 0 ?
ip6_sr_policy_t *sr_policy = 0;
uword *p = 0;
- memset (&key, 0, sizeof (sr_steering_key_t));
+ clib_memset (&key, 0, sizeof (sr_steering_key_t));
/* Compute the steer policy key */
if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
/* Create a new steering policy */
pool_get (sm->steer_policies, steer_pl);
- memset (steer_pl, 0, sizeof (*steer_pl));
+ clib_memset (steer_pl, 0, sizeof (*steer_pl));
if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
{
u8 sr_policy_set = 0;
- memset (&prefix, 0, sizeof (ip46_address_t));
+ clib_memset (&prefix, 0, sizeof (ip46_address_t));
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
void *iface_ip;
pool_get (tm->listener_pool, listener);
- memset (listener, 0, sizeof (*listener));
+ clib_memset (listener, 0, sizeof (*listener));
listener->c_c_index = listener - tm->listener_pool;
listener->c_lcl_port = lcl->port;
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
pool_put_index (tm->listener_pool, listener_index);
}
clib_spinlock_lock_if_init (&tm->half_open_lock);
pool_put_index (tm->half_open_connections, tc->c_c_index);
if (CLIB_DEBUG)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
clib_spinlock_unlock_if_init (&tm->half_open_lock);
}
tcp_connection_t *tc = 0;
ASSERT (vlib_get_thread_index () == 0);
pool_get (tm->half_open_connections, tc);
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->c_c_index = tc - tm->half_open_connections;
return tc;
}
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
pool_put (tm->connections[thread_index], tc);
}
}
tcp_connection_t *tc;
pool_get (tm->connections[thread_index], tc);
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->c_c_index = tc - tm->connections[thread_index];
tc->c_thread_index = thread_index;
return tc;
if (tc->c_is_ip4)
{
ip4_tcp_hdr_t hdr;
- memset (&hdr, 0, sizeof (hdr));
+ clib_memset (&hdr, 0, sizeof (hdr));
hdr.ip.protocol = IP_PROTOCOL_TCP;
hdr.ip.address_pair.src.as_u32 = tc->c_lcl_ip.ip4.as_u32;
hdr.ip.address_pair.dst.as_u32 = tc->c_rmt_ip.ip4.as_u32;
else
{
ip6_tcp_hdr_t hdr;
- memset (&hdr, 0, sizeof (hdr));
+ clib_memset (&hdr, 0, sizeof (hdr));
hdr.ip.protocol = IP_PROTOCOL_TCP;
clib_memcpy (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
sizeof (ip6_address_t));
ip4_address_t * hi_addr, u32 fib_index,
int is_del);
- memset (&prefix, 0, sizeof (prefix));
+ clib_memset (&prefix, 0, sizeof (prefix));
fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
fib_node_index_t fei;
u32 sw_if_index;
- memset (&prefix, 0, sizeof (prefix));
+ clib_memset (&prefix, 0, sizeof (prefix));
fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id);
if (!tc)
return s;
- memset (dummy_tc, 0, sizeof (*dummy_tc));
+ clib_memset (dummy_tc, 0, sizeof (*dummy_tc));
tcp_connection_timers_init (dummy_tc);
scoreboard_init (&dummy_tc->sack_sb);
dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (hole, 0xfe, sizeof (*hole));
+ clib_memset (hole, 0xfe, sizeof (*hole));
pool_put (sb->holes, hole);
}
u32 hole_index;
pool_get (sb->holes, hole);
- memset (hole, 0, sizeof (*hole));
+ clib_memset (hole, 0, sizeof (*hole));
hole->start = start;
hole->end = end;
initial_wnd = tcp_initial_window_to_advertise (tc);
/* Make and write options */
- memset (&snd_opts, 0, sizeof (snd_opts));
+ clib_memset (&snd_opts, 0, sizeof (snd_opts));
tcp_opts_len = tcp_make_syn_options (&snd_opts, tc->rcv_wscale);
tcp_hdr_opts_len = tcp_opts_len + sizeof (tcp_header_t);
tcp_header_t *th;
u16 initial_wnd;
- memset (snd_opts, 0, sizeof (*snd_opts));
+ clib_memset (snd_opts, 0, sizeof (*snd_opts));
tcp_reuse_buffer (vm, b);
initial_wnd = tcp_initial_window_to_advertise (tc);
if (now > rt->next_reset)
{
- memset (rt->syn_counts, 0, vec_len (rt->syn_counts));
+ clib_memset (rt->syn_counts, 0, vec_len (rt->syn_counts));
rt->next_reset = now + rt->reset_interval;
}
tls_ctx_t *ctx;
pool_get (tm->listener_ctx_pool, ctx);
- memset (ctx, 0, sizeof (*ctx));
+ clib_memset (ctx, 0, sizeof (*ctx));
return ctx - tm->listener_ctx_pool;
}
ctx_index = ctx - tm->half_open_ctx_pool;
clib_rwlock_reader_unlock (&tm->half_open_rwlock);
}
- memset (ctx, 0, sizeof (*ctx));
+ clib_memset (ctx, 0, sizeof (*ctx));
return ctx_index;
}
}
sep->transport_proto = TRANSPORT_PROTO_TCP;
- memset (args, 0, sizeof (*args));
+ clib_memset (args, 0, sizeof (*args));
args->app_index = tm->app_index;
args->sep_ext = *sep;
if (vnet_bind (args))
num_threads = 1 /* main thread */ + vtm->n_threads;
- memset (a, 0, sizeof (*a));
- memset (options, 0, sizeof (options));
+ clib_memset (a, 0, sizeof (*a));
+ clib_memset (options, 0, sizeof (options));
a->session_cb_vft = &tls_app_cb_vft;
a->api_client_index = APP_INVALID_INDEX;
pool_get_aligned (um->connections[thread_index], uc,
CLIB_CACHE_LINE_BYTES);
}
- memset (uc, 0, sizeof (*uc));
+ clib_memset (uc, 0, sizeof (*uc));
uc->c_c_index = uc - um->connections[thread_index];
uc->c_thread_index = thread_index;
uc->c_proto = TRANSPORT_PROTO_UDP;
{
pool_put (udp_main.connections[uc->c_thread_index], uc);
if (CLIB_DEBUG)
- memset (uc, 0xFA, sizeof (*uc));
+ clib_memset (uc, 0xFA, sizeof (*uc));
}
u32
return -1;
pool_get (um->listener_pool, listener);
- memset (listener, 0, sizeof (udp_connection_t));
+ clib_memset (listener, 0, sizeof (udp_connection_t));
listener->c_lcl_port = lcl->port;
listener->c_c_index = listener - um->listener_pool;
vl_api_udp_encap_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_UDP_ENCAP_DETAILS);
mp->context = context;
udp = p;
}
- memset (udp, 0, sizeof (udp[0]));
+ clib_memset (udp, 0, sizeof (udp[0]));
if (unformat (input, "src-port %d dst-port %d", &src_port, &dst_port))
{
udp->src_port = clib_host_to_net_u16 (src_port);
clib_spinlock_init (&pm->lock);
/* Write file header. */
- memset (&fh, 0, sizeof (fh));
+ clib_memset (&fh, 0, sizeof (fh));
fh.magic = 0xa1b2c3d4;
fh.major_version = 2;
fh.minor_version = 4;
vl_api_sw_interface_event_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
mp->sw_if_index = ntohl (sw_if_index);
u8 *tag;
vnet_tap_connect_args_t _a, *ap = &_a;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->intfc_name = mp->tap_name;
if (!mp->use_random_mac)
vlib_main_t *vm = vlib_get_main ();
vnet_tap_connect_args_t _a, *ap = &_a;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->orig_sw_if_index = ntohl (mp->sw_if_index);
ap->intfc_name = mp->tap_name;
{
vl_api_sw_interface_tap_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_TAP_DETAILS);
mp->sw_if_index = ntohl (tap_if->sw_if_index);
strncpy ((char *) mp->dev_name,
if ((dev_net_tun_fd = open ("/dev/net/tun", O_RDWR)) < 0)
return VNET_API_ERROR_SYSCALL_ERROR_1;
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
strncpy (ifr.ifr_name, (char *) ap->intfc_name, sizeof (ifr.ifr_name) - 1);
ifr.ifr_flags = flags;
if (ioctl (dev_net_tun_fd, TUNSETIFF, (void *) &ifr) < 0)
struct ifreq ifr;
struct sockaddr_ll sll;
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
strncpy (ifr.ifr_name, (char *) ap->intfc_name,
sizeof (ifr.ifr_name) - 1);
if (ioctl (dev_tap_fd, SIOCGIFINDEX, &ifr) < 0)
}
/* Bind the provisioning socket to the interface. */
- memset (&sll, 0, sizeof (sll));
+ clib_memset (&sll, 0, sizeof (sll));
sll.sll_family = AF_PACKET;
sll.sll_ifindex = ifr.ifr_ifindex;
sll.sll_protocol = htons (ETH_P_ALL);
/* ip4: mask defaults to /24 */
u32 mask = clib_host_to_net_u32 (0xFFFFFF00);
- memset (&sin, 0, sizeof (sin));
+ clib_memset (&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
/* sin.sin_port = 0; */
sin.sin_addr.s_addr = ap->ip4_address->as_u32;
goto error;
}
- memset (&ifr2, 0, sizeof (ifr));
+ clib_memset (&ifr2, 0, sizeof (ifr));
strncpy (ifr2.ifr_name, (char *) ap->intfc_name,
sizeof (ifr2.ifr_name) - 1);
if (ioctl (sockfd6, SIOCGIFINDEX, &ifr2) < 0)
user_hwaddr = 1;
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->orig_sw_if_index = sw_if_index;
ap->intfc_name = intfc_name;
ap->sw_if_indexp = &new_sw_if_index;
goto done;
}
- memset (ap, 0, sizeof (*ap));
+ clib_memset (ap, 0, sizeof (*ap));
ap->intfc_name = intfc_name;
ap->hwaddr_arg = hwaddr_arg;
if (sfd < 0)
clib_unix_warning ("provisioning socket");
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name) - 1);
/* get flags, modify to bring down interface... */
goto done;
}
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name) - 1);
ifr.ifr_flags = flags;
if (ioctl (tm->dev_net_tun_fd, TUNSETIFF, (void *) &ifr) < 0)
struct ifreq ifr;
struct sockaddr_ll sll;
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name) - 1);
if (ioctl (tm->dev_tap_fd, SIOCGIFINDEX, &ifr) < 0)
{
}
/* Bind the provisioning socket to the interface. */
- memset (&sll, 0, sizeof (sll));
+ clib_memset (&sll, 0, sizeof (sll));
sll.sll_family = AF_PACKET;
sll.sll_ifindex = ifr.ifr_ifindex;
sll.sll_protocol = htons (ETH_P_ALL);
return;
/** See if we already know about this subif */
- memset (&subif_addr, 0, sizeof (subif_addr));
+ clib_memset (&subif_addr, 0, sizeof (subif_addr));
subif_addr.sw_if_index = sw_if_index;
clib_memcpy (&subif_addr.addr, address, sizeof (*address));
}
/* Use subif pool index to select alias device. */
- memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr, 0, sizeof (ifr));
snprintf (ifr.ifr_name, sizeof (ifr.ifr_name),
"%s:%d", tm->tun_name, (int) (ap - tm->subifs));
return;
/* See if we already know about this subif */
- memset (&subif_addr, 0, sizeof (subif_addr));
+ clib_memset (&subif_addr, 0, sizeof (subif_addr));
subif_addr.sw_if_index = sw_if_index;
subif_addr.is_v6 = 1;
clib_memcpy (&subif_addr.addr, address, sizeof (*address));
}
/* Use subif pool index to select alias device. */
- memset (&ifr, 0, sizeof (ifr));
- memset (&ifr6, 0, sizeof (ifr6));
+ clib_memset (&ifr, 0, sizeof (ifr));
+ clib_memset (&ifr6, 0, sizeof (ifr6));
snprintf (ifr.ifr_name, sizeof (ifr.ifr_name),
"%s:%d", tm->tun_name, (int) (ap - tm->subifs));
{
struct radix_mask *rm = clib_mem_alloc(sizeof(struct radix_mask));
- memset(rm, 0, sizeof(*rm));
+ clib_memset(rm, 0, sizeof(*rm));
return (rm);
}
#define R_Malloc(p, t, n) \
{ \
p = (t) clib_mem_alloc((unsigned int)(n)); \
- memset(p, 0, n); \
+ clib_memset(p, 0, n); \
}
#define Free(p) clib_mem_free((p))
#define log(a,b, c...)
return mask_rnhead->rnh_nodes;
}
if (m0 < last_zeroed)
- memset(addmask_key + m0, 0, last_zeroed - m0);
+ clib_memset(addmask_key + m0, 0, last_zeroed - m0);
*addmask_key = last_zeroed = mlen;
x = rn_search(addmask_key, rn_masktop);
if (memcmp(addmask_key, x->rn_key, mlen) != 0)
R_Malloc(x, struct radix_node *, max_keylen + 2 * sizeof (*x));
if ((saved_x = x) == NULL)
return NULL;
- memset(x, 0, max_keylen + 2 * sizeof (*x));
+ clib_memset(x, 0, max_keylen + 2 * sizeof (*x));
cp = netmask = (void *)(x + 2);
memmove(x + 2, addmask_key, mlen);
x = rn_insert(cp, mask_rnhead, &maskduplicated, x);
log(LOG_ERR, "Mask for route not entered\n");
return NULL;
}
- memset(m, 0, sizeof(*m));
+ clib_memset(m, 0, sizeof(*m));
m->rm_b = tt->rn_b;
m->rm_flags = tt->rn_flags;
if (tt->rn_flags & RNF_NORMAL)
struct radix_node *tt;
struct radix_node *ttt;
- memset(rnh, 0, sizeof(*rnh));
+ clib_memset(rnh, 0, sizeof(*rnh));
t = rn_newpair(rn_zeros, off, rnh->rnh_nodes);
ttt = rnh->rnh_nodes + 2;
t->rn_r = ttt;
if (rn_zeros == NULL)
return (clib_error_return (0, "RN Zeros..."));
- memset(rn_zeros, 0, 3 * max_keylen);
+ clib_memset(rn_zeros, 0, 3 * max_keylen);
rn_ones = cp = rn_zeros + max_keylen;
addmask_key = cplim = rn_ones + max_keylen;
while (cp < cplim)
if (time_now - t->last_seed_change_time[thread_index] > t->time)
{
(void) random_u32 (&t->seeds[thread_index]);
- memset (t->bitmaps[thread_index], 0, THROTTLE_BITS / BITS (u8));
+ clib_memset (t->bitmaps[thread_index], 0, THROTTLE_BITS / BITS (u8));
t->last_seed_change_time[thread_index] = time_now;
}
u32 thread_index = vlib_get_thread_index ();
if (is_ip4)
- memset (&last4, 0xff, sizeof last4);
+ clib_memset (&last4, 0xff, sizeof last4);
else
- memset (&last6, 0xff, sizeof last6);
+ clib_memset (&last6, 0xff, sizeof last6);
u32 next_index = node->cached_next_index;
vxlan_gbp_header_t *vxlan_gbp;
/* Fixed portion of the (outer) ip header */
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
if (!is_ip6)
{
ip4_header_t *ip = &h.h4.ip4;
return VNET_API_ERROR_INVALID_DECAP_NEXT;
pool_get_aligned (vxm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
dev_instance = t - vxm->tunnels;
/* copy from arg structure */
IP46_TYPE_IP4 : IP46_TYPE_IP6);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_VXLAN_GBP_TUNNEL_DETAILS);
ip_address_encode (&t->src, itype, &rmp->tunnel.src);
u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
if (is_ip4)
- memset (&last_key4, 0xff, sizeof (last_key4));
+ clib_memset (&last_key4, 0xff, sizeof (last_key4));
else
- memset (&last_key6, 0xff, sizeof (last_key6));
+ clib_memset (&last_key6, 0xff, sizeof (last_key6));
from = vlib_frame_vector_args (from_frame);
n_left_from = from_frame->n_vectors;
return VNET_API_ERROR_TUNNEL_EXIST;
pool_get_aligned (ngm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
/* copy from arg structure */
/* *INDENT-OFF* */
goto done;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->is_ip6 = ipv6_set;
rv = VNET_API_ERROR_SAME_SRC_DST;
goto out;
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->is_add = mp->is_add;
a->is_ip6 = mp->is_ipv6;
u8 is_ipv6 = !(t->flags & VXLAN_GPE_TUNNEL_IS_IPV4);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_VXLAN_GPE_TUNNEL_DETAILS);
if (is_ipv6)
{
u32 thread_index = vlib_get_thread_index ();
if (is_ip4)
- memset (&last4, 0xff, sizeof last4);
+ clib_memset (&last4, 0xff, sizeof last4);
else
- memset (&last6, 0xff, sizeof last6);
+ clib_memset (&last6, 0xff, sizeof last6);
u32 *from = vlib_frame_vector_args (from_frame);
u32 n_left_from = from_frame->n_vectors;
vxlan_header_t *vxlan;
/* Fixed portion of the (outer) ip header */
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
if (!is_ip6)
{
ip4_header_t *ip = &h.h4.ip4;
vxlan_tunnel_t *t;
pool_get_aligned (vxm->tunnels, t, CLIB_CACHE_LINE_BYTES);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
dev_instance = t - vxm->tunnels;
/* copy from arg structure */
u8 is_ipv6 = !ip46_address_is_ip4 (&t->dst);
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_VXLAN_TUNNEL_DETAILS);
if (is_ipv6)
{
init (void)
{
vac_main_t *pm = &vac_main;
- memset(pm, 0, sizeof(*pm));
+ clib_memset(pm, 0, sizeof(*pm));
pthread_mutex_init(&pm->queue_lock, NULL);
pthread_cond_init(&pm->suspend_cv, NULL);
pthread_cond_init(&pm->resume_cv, NULL);
pthread_cond_destroy(&pm->timeout_cv);
pthread_cond_destroy(&pm->timeout_cancel_cv);
pthread_cond_destroy(&pm->terminate_cv);
- memset(pm, 0, sizeof(*pm));
+ clib_memset(pm, 0, sizeof(*pm));
}
/*
case VL_API_MEMCLNT_KEEPALIVE:
mp = (void *)msg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs(VL_API_MEMCLNT_KEEPALIVE_REPLY);
rmp->context = mp->context;
shmem_hdr = am->shmem_hdr;
/* Handle an alive-check ping from vpp. */
mp = (void *)msg;
rmp = vl_msg_api_alloc (sizeof (*rmp));
- memset (rmp, 0, sizeof (*rmp));
+ clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs(VL_API_MEMCLNT_KEEPALIVE_REPLY);
rmp->context = mp->context;
shmem_hdr = am->shmem_hdr;
int mfd = -1;
int sock;
- memset (sm, 0, sizeof (*sm));
+ clib_memset (sm, 0, sizeof (*sm));
if ((sock = socket (AF_UNIX, SOCK_SEQPACKET, 0)) < 0)
{
perror ("Couldn't open socket");
#define M_NOALLOC(T,t) \
do { \
result_ready = 0; \
- memset (mp, 0, sizeof (*mp)); \
+ clib_memset (mp, 0, sizeof (*mp)); \
mp->_vl_msg_id = ntohs (VL_API_##T); \
mp->client_index = am->my_client_index; \
} while(0);
{
goto fail;
}
- memset (ctx->vapi_msg_id_t_to_vl_msg_id, ~0,
- __vapi_metadata.count * sizeof (*ctx->vapi_msg_id_t_to_vl_msg_id));
+ clib_memset (ctx->vapi_msg_id_t_to_vl_msg_id, ~0,
+ __vapi_metadata.count *
+ sizeof (*ctx->vapi_msg_id_t_to_vl_msg_id));
ctx->event_cbs = calloc (__vapi_metadata.count, sizeof (*ctx->event_cbs));
if (!ctx->event_cbs)
{
return VAPI_ENOMEM;
}
ctx->requests = tmp;
- memset (ctx->requests, 0, size);
+ clib_memset (ctx->requests, 0, size);
/* coverity[MISSING_LOCK] - 177211 requests_mutex is not needed here */
ctx->requests_start = ctx->requests_count = 0;
if (chroot_prefix)
requests_start].callback_ctx,
VAPI_ENORESP, true,
NULL);
- memset (&ctx->requests[ctx->requests_start], 0,
- sizeof (ctx->requests[ctx->requests_start]));
+ clib_memset (&ctx->requests[ctx->requests_start], 0,
+ sizeof (ctx->requests[ctx->requests_start]));
++ctx->requests_start;
--ctx->requests_count;
if (ctx->requests_start == ctx->requests_size)
}
if (is_last)
{
- memset (&ctx->requests[ctx->requests_start], 0,
- sizeof (ctx->requests[ctx->requests_start]));
+ clib_memset (&ctx->requests[ctx->requests_start], 0,
+ sizeof (ctx->requests[ctx->requests_start]));
++ctx->requests_start;
--ctx->requests_count;
if (ctx->requests_start == ctx->requests_size)
return;
rmp = vl_msg_api_alloc (msg_size);
- memset (rmp, 0, msg_size);
+ clib_memset (rmp, 0, msg_size);
rmp->_vl_msg_id = htons (VL_API_SHOW_THREADS_REPLY);
rmp->context = mp->context;
rmp->count = htonl (count);
*regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
regp = *regpp;
- memset (regp, 0, sizeof (*regp));
+ clib_memset (regp, 0, sizeof (*regp));
regp->registration_type = REGISTRATION_TYPE_SHMEM;
regp->vl_api_registration_pool_index = regpp - am->vl_clients;
regp->vlib_rp = svm;
u8 *s;
u8 null_mac[6];
- memset (null_mac, 0, sizeof (null_mac));
+ clib_memset (null_mac, 0, sizeof (null_mac));
s = format (0, "SCRIPT: tap_connect ");
s = format (s, "tapname %s ", mp->tap_name);
u8 *s;
u8 null_mac[6];
- memset (null_mac, 0, sizeof (null_mac));
+ clib_memset (null_mac, 0, sizeof (null_mac));
s = format (0, "SCRIPT: tap_modify ");
s = format (s, "sw_if_index %d ", ntohl (mp->sw_if_index));
u8 *s;
u8 null_mac[6];
- memset (null_mac, 0, sizeof (null_mac));
+ clib_memset (null_mac, 0, sizeof (null_mac));
s = format (0, "SCRIPT: tap_create_v2 ");
s = format (s, "id %u ", ntohl (mp->id));
u8 *s;
u8 null_mac[6];
- memset (null_mac, 0, sizeof (null_mac));
+ clib_memset (null_mac, 0, sizeof (null_mac));
s = format (0, "SCRIPT: bond_create ");
if (memcmp (mp->mac_address, null_mac, 6))
u8 *s;
u8 null_mac[6];
- memset (null_mac, 0, sizeof (null_mac));
+ clib_memset (null_mac, 0, sizeof (null_mac));
s = format (0, "SCRIPT: ip_neighbor_add_del ");
u8 *s;
u8 null_data[256];
- memset (null_data, 0, sizeof (null_data));
+ clib_memset (null_data, 0, sizeof (null_data));
s = format (0, "SCRIPT: sw_interface_set_lldp ");
s = format (s, "sw_if_index %d ", ntohl (mp->sw_if_index));
gm->vlib_main = vm;
- memset (ma, 0, sizeof (*ma));
+ clib_memset (ma, 0, sizeof (*ma));
ma->root_path = am->root_path;
ma->uid = am->api_uid;
ma->gid = am->api_gid;
vat_json_print (FILE * ofp, vat_json_node_t * node)
{
vat_print_ctx_t ctx;
- memset (&ctx, 0, sizeof ctx);
+ clib_memset (&ctx, 0, sizeof ctx);
ctx.indent = 0;
ctx.ofp = ofp;
fformat (ofp, "\n");
_vec_len (pm->plugin_info) = vec_len (pm->plugin_info) - 1;
continue;
}
- memset (pi, 0, sizeof (*pi));
+ clib_memset (pi, 0, sizeof (*pi));
hash_set_mem (pm->plugin_by_name_hash, plugin_name,
pi - pm->plugin_info);
}
exit (1);
}
- memset (&tm->send_data_addr, 0, sizeof (tm->send_data_addr));
+ clib_memset (&tm->send_data_addr, 0, sizeof (tm->send_data_addr));
tm->send_data_addr.sin_family = AF_INET;
tm->send_data_addr.sin_addr.s_addr = collector_ip.as_u32;
tm->send_data_addr.sin_port = htons (collector_port);
break;
/* Poll for stats */
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_VNET_GET_SUMMARY_STATS);
mp->client_index = tm->my_client_index;
vl_msg_api_send_shmem (tm->vl_input_queue, (u8 *) & mp);
/* Request admin / link up down messages */
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_WANT_INTERFACE_EVENTS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_want_stats_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_WANT_STATS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_want_oam_events_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_WANT_OAM_EVENTS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
ip4_address_t tmp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_OAM_ADD_DEL);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_dump_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_DUMP);
mp->client_index = tm->my_client_index;
mp->name_filter_valid = 1;
u32 tmp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_ADD_DEL_ROUTE);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
u64 tmp[2];
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_ADD_DEL_ROUTE);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
u32 tmp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_ADD_DEL_ADDRESS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
u64 tmp[2];
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_ADD_DEL_ADDRESS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_add_del_address_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_ADD_DEL_ADDRESS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_set_table_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_SET_TABLE);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_tap_connect_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_TAP_CONNECT);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_create_vlan_subif_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_CREATE_VLAN_SUBIF);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
u32 tmp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_PROXY_ARP_ADD_DEL);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_proxy_arp_intfc_enable_disable_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_PROXY_ARP_INTFC_ENABLE_DISABLE);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
u32 tmp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_NEIGHBOR_ADD_DEL);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
mp->sw_if_index = ntohl (6);
mp->is_add = add_del;
- memset (mp->mac_address, 0xbe, sizeof (mp->mac_address));
+ clib_memset (mp->mac_address, 0xbe, sizeof (mp->mac_address));
tmp = ntohl (0x0101010a);
clib_memcpy (mp->dst_address, &tmp, 4);
u64 tmp[2];
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_IP_NEIGHBOR_ADD_DEL);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
mp->is_add = add_del;
mp->is_ipv6 = 1;
- memset (mp->mac_address, 0xbe, sizeof (mp->mac_address));
+ clib_memset (mp->mac_address, 0xbe, sizeof (mp->mac_address));
tmp[0] = clib_host_to_net_u64 (0xdb01000000000000ULL);
tmp[1] = clib_host_to_net_u64 (0x11ULL);
vl_api_reset_fib_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_RESET_FIB);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_dhcp_proxy_set_vss_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_DHCP_PROXY_SET_VSS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_dhcp_proxy_set_vss_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_DHCP_PROXY_SET_VSS);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_dhcp_proxy_config_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_DHCP_PROXY_CONFIG);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_set_ip_flow_hash_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SET_IP_FLOW_HASH);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_ip6nd_ra_config_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
u64 tmp[2];
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_ip6_enable_disable_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_create_loopback_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_CREATE_LOOPBACK);
mp->client_index = tm->my_client_index;
u64 tmp[2];
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_set_flags_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_SET_FLAGS);
mp->client_index = tm->my_client_index;
vl_api_l2_patch_add_del_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_L2_PATCH_ADD_DEL);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_set_l2_xconnect_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_SET_L2_XCONNECT);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_sw_interface_set_l2_bridge_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_SET_L2_BRIDGE);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_api_control_ping_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_CONTROL_PING);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
for (i = 1; i < 32; i++)
{
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.sa_sigaction = (void *) unix_signal_handler;
sa.sa_flags = SA_SIGINFO;
setup_signal_handlers ();
- memset (ma, 0, sizeof (*ma));
+ clib_memset (ma, 0, sizeof (*ma));
ma->root_path = chroot_path;
ma->uid = uid;
ma->gid = gid;
return -1;
}
- memset (&serveraddr, 0, sizeof (serveraddr));
+ clib_memset (&serveraddr, 0, sizeof (serveraddr));
serveraddr.sin6_family = AF_INET6;
serveraddr.sin6_port = htons (port);
serveraddr.sin6_addr = in6addr_any;
if (is_interactive)
{
/* Capture terminal resize events */
- memset (&sa, 0, sizeof (struct sigaction));
+ clib_memset (&sa, 0, sizeof (struct sigaction));
sa.sa_handler = signal_handler_winch;
if (sigaction (SIGWINCH, &sa, 0) < 0)
{
vec_validate (t->template, 0);
h = t->template;
- memset (h, 0, sizeof (*h));
+ clib_memset (h, 0, sizeof (*h));
h->ip4.src_address.as_u32 = t->src_address.as_u32;
h->ip4.dst_address.as_u32 = t->dst_address.as_u32;
return VNET_API_ERROR_INVALID_REGISTRATION; /* already there... */
pool_get (om->targets, t);
- memset (t, 0, sizeof (*t));
+ clib_memset (t, 0, sizeof (*t));
t->src_address.as_u32 = src_address->as_u32;
t->dst_address.as_u32 = dst_address->as_u32;
t->fib_id = fib_id;
continue;
}
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + sizeof (*vp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id =
ntohs (VL_API_VNET_PER_INTERFACE_COMBINED_COUNTERS);
}
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + sizeof (*vp));
- memset (mp, 0, sizeof (*mp));
+ clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_VNET_PER_INTERFACE_SIMPLE_COUNTERS);
/*
rmp->context = mp->context;
rmp->retval = 0;
- memset (total_pkts, 0, sizeof (total_pkts));
- memset (total_bytes, 0, sizeof (total_bytes));
+ clib_memset (total_pkts, 0, sizeof (total_pkts));
+ clib_memset (total_bytes, 0, sizeof (total_bytes));
vnet_interface_counter_lock (im);
sm->data_structure_lock =
clib_mem_alloc_aligned (sizeof (data_structure_lock_t),
CLIB_CACHE_LINE_BYTES);
- memset (sm->data_structure_lock, 0, sizeof (*sm->data_structure_lock));
+ clib_memset (sm->data_structure_lock, 0, sizeof (*sm->data_structure_lock));
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
/* Preserve global parse flags. */
parse_flags = p->flags & (X86_INSN_PARSE_32_BIT | X86_INSN_PARSE_64_BIT);
- memset (p, 0, sizeof (p[0]));
+ clib_memset (p, 0, sizeof (p[0]));
p->flags = parse_flags;
/* 64 implies 32 bit parsing. */
static inline int
clib_bihash_is_free_16_8 (clib_bihash_kv_16_8_t * v)
{
- /* Free values are memset to 0xff, check a bit... */
+ /* Free values are clib_memset to 0xff, check a bit... */
if (v->key[0] == ~0ULL && v->value == ~0ULL)
return 1;
return 0;
static inline int
clib_bihash_is_free_16_8_32 (clib_bihash_kv_16_8_32_t * v)
{
- /* Free values are memset to 0xff, check a bit... */
+ /* Free values are clib_memset to 0xff, check a bit... */
if (v->key[0] == ~0ULL && v->value == ~0ULL)
return 1;
return 0;
static inline int
clib_bihash_is_free_24_8 (const clib_bihash_kv_24_8_t * v)
{
- /* Free values are memset to 0xff, check a bit... */
+ /* Free values are clib_memset to 0xff, check a bit... */
if (v->key[0] == ~0ULL && v->value == ~0ULL)
return 1;
return 0;
static inline int
clib_bihash_is_free_40_8 (const clib_bihash_kv_40_8_t * v)
{
- /* Free values are memset to 0xff, check a bit... */
+ /* Free values are clib_memset to 0xff, check a bit... */
if (v->key[0] == ~0ULL && v->value == ~0ULL)
return 1;
return 0;
static inline int
clib_bihash_is_free_48_8 (const clib_bihash_kv_48_8_t * v)
{
- /* Free values are memset to 0xff, check a bit... */
+ /* Free values are clib_memset to 0xff, check a bit... */
if (v->key[0] == ~0ULL && v->value == ~0ULL)
return 1;
return 0;
(void) close (h->memfd);
#endif
clib_mem_vm_free ((void *) (uword) (alloc_arena (h)), alloc_arena_size (h));
- memset (h, 0, sizeof (*h));
+ clib_memset (h, 0, sizeof (*h));
}
static
* if we replace (1<<log2_pages) with vec_len(rv).
* No clue.
*/
- memset (rv, 0xff, sizeof (*rv) * (1 << log2_pages));
+ clib_memset (rv, 0xff, sizeof (*rv) * (1 << log2_pages));
return rv;
}
ASSERT (vec_len (h->freelists) > log2_pages);
if (CLIB_DEBUG > 0)
- memset (v, 0xFE, sizeof (*v) * (1 << log2_pages));
+ clib_memset (v, 0xFE, sizeof (*v) * (1 << log2_pages));
v->next_free_as_u64 = (u64) h->freelists[log2_pages];
h->freelists[log2_pages] = (u64) BV (clib_bihash_get_offset) (h, v);
v = BV (clib_bihash_get_value) (h, b->offset);
- clib_memcpy (working_copy, v, sizeof (*v) * (1 << b->log2_pages));
+ _clib_memcpy (working_copy, v, sizeof (*v) * (1 << b->log2_pages));
working_bucket.as_u64 = b->as_u64;
working_bucket.offset = BV (clib_bihash_get_offset) (h, working_copy);
CLIB_MEMORY_BARRIER ();
/* Empty slot */
if (BV (clib_bihash_is_free) (&(new_v->kvp[j])))
{
- clib_memcpy (&(new_v->kvp[j]), &(old_values->kvp[i]),
- sizeof (new_v->kvp[j]));
+ _clib_memcpy (&(new_v->kvp[j]), &(old_values->kvp[i]),
+ sizeof (new_v->kvp[j]));
goto doublebreak;
}
}
if (BV (clib_bihash_is_free) (&(new_values->kvp[j])))
{
/* Copy the old value and move along */
- clib_memcpy (&(new_values->kvp[j]), &(old_values->kvp[i]),
- sizeof (new_values->kvp[j]));
+ _clib_memcpy (&(new_values->kvp[j]), &(old_values->kvp[i]),
+ sizeof (new_values->kvp[j]));
j++;
goto doublebreak;
}
if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
{
CLIB_MEMORY_BARRIER (); /* Add a delay */
- clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
+ _clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
BV (clib_bihash_unlock_bucket) (b);
return (0);
}
* Copy the value first, so that if a reader manages
* to match the new key, the value will be right...
*/
- clib_memcpy (&(v->kvp[i].value),
- &add_v->value, sizeof (add_v->value));
+ _clib_memcpy (&(v->kvp[i].value),
+ &add_v->value, sizeof (add_v->value));
CLIB_MEMORY_BARRIER (); /* Make sure the value has settled */
- clib_memcpy (&(v->kvp[i]), &add_v->key, sizeof (add_v->key));
+ _clib_memcpy (&(v->kvp[i]), &add_v->key, sizeof (add_v->key));
b->refcnt++;
ASSERT (b->refcnt > 0);
BV (clib_bihash_unlock_bucket) (b);
if (is_stale_cb (&(v->kvp[i]), arg))
{
CLIB_MEMORY_BARRIER ();
- clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
+ _clib_memcpy (&(v->kvp[i]), add_v, sizeof (*add_v));
BV (clib_bihash_unlock_bucket) (b);
return (0);
}
/* Found the key? Kill it... */
if (!memcmp (&(v->kvp[i]), &add_v->key, sizeof (add_v->key)))
{
- memset (&(v->kvp[i]), 0xff, sizeof (*(add_v)));
+ clib_memset (&(v->kvp[i]), 0xff, sizeof (*(add_v)));
/* Is the bucket empty? */
if (PREDICT_TRUE (b->refcnt > 1))
{
{
if (BV (clib_bihash_is_free) (&(new_v->kvp[i])))
{
- clib_memcpy (&(new_v->kvp[i]), add_v, sizeof (*add_v));
+ _clib_memcpy (&(new_v->kvp[i]), add_v, sizeof (*add_v));
goto expand_ok;
}
}
always_inline void
clib_cuckoo_kv_set_free_8_8 (clib_cuckoo_kv_8_8_t * v)
{
- memset (v, 0xff, sizeof (*v));
+ clib_memset (v, 0xff, sizeof (*v));
}
/** Format a clib_cuckoo_kv_8_8_t instance
CVT (clib_cuckoo_bucket) * bucket;
/* *INDENT-OFF* */
clib_cuckoo_foreach_bucket (
- bucket, h, { memset (bucket->elts, 0xff, sizeof (bucket->elts)); });
+ bucket, h, { clib_memset (bucket->elts, 0xff, sizeof (bucket->elts)); });
/* *INDENT-ON* */
h->name = name;
h->garbage_callback = garbage_callback;
void CV (clib_cuckoo_free) (CVT (clib_cuckoo) * h)
{
- memset (h, 0, sizeof (*h));
+ clib_memset (h, 0, sizeof (*h));
}
static clib_cuckoo_bucket_aux_t
{
clib_cuckoo_path_t *path;
pool_get (h->paths, path);
- memset (path, 0, sizeof (*path));
+ clib_memset (path, 0, sizeof (*path));
#if CLIB_CUCKOO_DEBUG_PATH_DETAIL
CLIB_CUCKOO_DBG ("Get path @%lu", (long unsigned) (path - h->paths));
#endif
static void CV (clib_cuckoo_free_locked_elt) (CVT (clib_cuckoo_kv) * elt)
{
/*
- * FIXME - improve performance by getting rid of this memset - make all
+ * FIXME - improve performance by getting rid of this clib_memset - make all
* functions in this file not rely on clib_cuckoo_kv_is_free but instead
* take use_count into account */
- memset (elt, 0xff, sizeof (*elt));
+ clib_memset (elt, 0xff, sizeof (*elt));
}
static void CV (clib_cuckoo_free_elt_in_bucket) (CVT (clib_cuckoo_bucket) * b,
CVT (clib_cuckoo_bucket) * bucket;
for (bucket = new + old_nbuckets; bucket < vec_end (new); ++bucket)
{
- memset (bucket->elts, 0xff, sizeof (bucket->elts));
+ clib_memset (bucket->elts, 0xff, sizeof (bucket->elts));
}
/*
* this for loop manipulates the new (unseen) memory, so no locks
clib_dlist_init (dlist_elt_t * pool, u32 index)
{
dlist_elt_t *head = pool_elt_at_index (pool, index);
- memset (head, 0xFF, sizeof (*head));
+ clib_memset (head, 0xFF, sizeof (*head));
}
static inline void
{
char *save = em->file_name;
- memset (em, 0, sizeof (em[0]));
+ clib_memset (em, 0, sizeof (em[0]));
em->file_name = save;
}
static void
string_table_init (string_table_builder_t * b, u8 * old_table)
{
- memset (b, 0, sizeof (b[0]));
+ clib_memset (b, 0, sizeof (b[0]));
b->old_table = old_table;
b->hash = hash_create_string (0, sizeof (uword));
}
always_inline void
elf_main_init (elf_main_t * em)
{
- memset (em, 0, sizeof (em[0]));
+ clib_memset (em, 0, sizeof (em[0]));
}
always_inline void
void
elog_init (elog_main_t * em, u32 n_events)
{
- memset (em, 0, sizeof (em[0]));
+ clib_memset (em, 0, sizeof (em[0]));
em->lock = 0;
elog_track_t newt;
int i;
- memset (&newt, 0, sizeof (newt));
+ clib_memset (&newt, 0, sizeof (newt));
/* Acquire src and dst events */
elog_get_events (src);
n = vec_elt_at_index (f->nodes, ni);
- memset (n, 0, sizeof (n[0]));
+ clib_memset (n, 0, sizeof (n[0]));
n->parent = n->first_child = n->next_sibling = n->prev_sibling = ~0;
n->key = key;
fheap_node_t *save_nodes = f->nodes;
u32 *save_root_list = f->root_list_by_rank;
- memset (f, 0, sizeof (f[0]));
+ clib_memset (f, 0, sizeof (f[0]));
f->nodes = save_nodes;
f->root_list_by_rank = save_root_list;
/* Zero empty space. */
n_zero_bytes = (n_new_elts - n_old_elts) * elt_bytes;
- memset (v_new + n_copy_bytes, 0, n_zero_bytes);
+ clib_memset (v_new + n_copy_bytes, 0, n_zero_bytes);
clib_fifo_free (v_old);
/* Fill free elements list */
int i;
- memset(h->entries, 0, sizeof(h->entries[0]) * entries);
+ clib_memset(h->entries, 0, sizeof(h->entries[0]) * entries);
for (i = 1; i <= collision_buckets; i++)
{
h->free_buckets_indices[-i] =
if (n_left > 0)
{
vec_insert (s, n_left, i0);
- memset (s + i0, fi->pad_char, n_left);
+ clib_memset (s + i0, fi->pad_char, n_left);
l1 = vec_len (s);
}
if (n_right > 0)
{
vec_resize (s, n_right);
- memset (s + l1, fi->pad_char, n_right);
+ clib_memset (s + l1, fi->pad_char, n_right);
}
}
return s;
uword (*fill_buffer) (unformat_input_t *),
void *fill_buffer_arg)
{
- memset (i, 0, sizeof (i[0]));
+ clib_memset (i, 0, sizeof (i[0]));
i->fill_buffer = fill_buffer;
i->fill_buffer_arg = fill_buffer_arg;
}
{
vec_free (i->buffer);
vec_free (i->buffer_marks);
- memset (i, 0, sizeof (i[0]));
+ clib_memset (i, 0, sizeof (i[0]));
}
always_inline uword
index = src_node - g->nodes;
pool_put (g->nodes, src_node);
- memset (src_node, ~0, sizeof (src_node[0]));
+ clib_memset (src_node, ~0, sizeof (src_node[0]));
return index;
}
always_inline void
zero_pair (hash_t * h, hash_pair_t * p)
{
- memset (p, 0, hash_pair_bytes (h));
+ clib_memset (p, 0, hash_pair_bytes (h));
}
always_inline void
init_pair (hash_t * h, hash_pair_t * p)
{
- memset (p->value, ~0, hash_value_bytes (h));
+ clib_memset (p->value, ~0, hash_value_bytes (h));
}
always_inline hash_pair_union_t *
{
/* Restore flags. */
h->flags = hn->f;
- memset (hn, 0, sizeof (hn[0]));
+ clib_memset (hn, 0, sizeof (hn[0]));
return 0;
}
_format_pair,_format_pair_arg) \
({ \
hash_t _h; \
- memset (&_h, 0, sizeof (_h)); \
+ clib_memset (&_h, 0, sizeof (_h)); \
_h.user = (_user); \
_h.key_sum = (hash_key_sum_function_t *) (_key_sum); \
_h.key_equal = (_key_equal); \
heap_header_t *h = heap_header (v);
heap_header_t zero;
- memset (&zero, 0, sizeof (zero));
+ clib_memset (&zero, 0, sizeof (zero));
if (!v)
h = &zero;
return 0;
h = memory;
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
h->max_len = max_len;
h->elt_bytes = elt_bytes;
h->flags = HEAP_IS_STATIC;
clib_spinlock_init (clib_spinlock_t * p)
{
*p = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES);
- memset ((void *) *p, 0, CLIB_CACHE_LINE_BYTES);
+ clib_memset ((void *) *p, 0, CLIB_CACHE_LINE_BYTES);
}
static inline void
clib_rwlock_init (clib_rwlock_t * p)
{
*p = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES);
- memset ((void *) *p, 0, CLIB_CACHE_LINE_BYTES);
+ clib_memset ((void *) *p, 0, CLIB_CACHE_LINE_BYTES);
}
always_inline void
if (mm->flags & CLIB_MAPLOG_FLAG_INIT)
return (-2);
- memset (mm, 0, sizeof (*mm));
+ clib_memset (mm, 0, sizeof (*mm));
record_size_in_cache_lines =
(a->record_size_in_bytes + CLIB_CACHE_LINE_BYTES -
(void) close (fd);
}
- memset (h, 0, sizeof (*h));
+ clib_memset (h, 0, sizeof (*h));
h->maplog_major_version = MAPLOG_MAJOR_VERSION;
h->maplog_minor_version = MAPLOG_MINOR_VERSION;
h->maplog_patch_version = MAPLOG_PATCH_VERSION;
vec_free (mm->file_basename);
vec_free (mm->header_filename);
- memset (mm, 0, sizeof (*mm));
+ clib_memset (mm, 0, sizeof (*mm));
}
/**
#endif
#include <vppinfra/os.h>
-#include <vppinfra/string.h> /* memcpy, memset */
+#include <vppinfra/string.h> /* memcpy, clib_memset */
#include <vppinfra/valgrind.h>
#define CLIB_MAX_MHEAPS 256
return;
/* Spurious Coverity warnings be gone. */
- memset (&trace, 0, sizeof (trace));
+ clib_memset (&trace, 0, sizeof (trace));
/* Skip our frame and mspace_get_aligned's frame */
n_callers = clib_backtrace (trace.callers, ARRAY_LEN (trace.callers), 2);
{
hash_unset_mem (tm->trace_by_callers, t->callers);
vec_add1 (tm->trace_free_list, trace_index);
- memset (t, 0, sizeof (t[0]));
+ clib_memset (t, 0, sizeof (t[0]));
}
tm->enabled = save_enabled;
clib_spinlock_unlock (&tm->lock);
}
static inline void *
-clib_memcpy (void *dst, const void *src, size_t n)
+_clib_memcpy (void *dst, const void *src, size_t n)
{
uword dstu = (uword) dst;
uword srcu = (uword) src;
}
static inline void *
-clib_memcpy (void *dst, const void *src, size_t n)
+_clib_memcpy (void *dst, const void *src, size_t n)
{
uword dstu = (uword) dst;
uword srcu = (uword) src;
})
static inline void *
-clib_memcpy (void *dst, const void *src, size_t n)
+_clib_memcpy (void *dst, const void *src, size_t n)
{
__m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8;
uword dstu = (uword) dst;
vec_free (h->key_tmps);
hash_free (h->hash);
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
h->n_key_bytes = n_key_bytes;
#if 0
clib_mem_vm_map (h, sizeof (h[0]));
/* Zero vector header: both heap header and vector length. */
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
_vec_len (v) = 0;
h->vm_alloc_offset_from_header = (void *) h - memory;
(clib_address_t) v, h->max_size);
/* Initialize free list heads to empty. */
- memset (h->first_free_elt_uoffset_by_bin, 0xFF,
- sizeof (h->first_free_elt_uoffset_by_bin));
+ clib_memset (h->first_free_elt_uoffset_by_bin, 0xFF,
+ sizeof (h->first_free_elt_uoffset_by_bin));
return v;
}
mheap_elt_t *e;
uword i, n_hist;
- memset (hist, 0, sizeof (hist));
+ clib_memset (hist, 0, sizeof (hist));
n_hist = 0;
for (e = v;
mheap_trace_t trace;
/* Spurious Coverity warnings be gone. */
- memset (&trace, 0, sizeof (trace));
+ clib_memset (&trace, 0, sizeof (trace));
n_callers = clib_backtrace (trace.callers, ARRAY_LEN (trace.callers),
/* Skip mheap_get_aligned's frame */ 1);
{
hash_unset_mem (tm->trace_by_callers, t->callers);
vec_add1 (tm->trace_free_list, trace_index);
- memset (t, 0, sizeof (t[0]));
+ clib_memset (t, 0, sizeof (t[0]));
}
}
/* clear any state from previous attempts */
if (vec_bytes (pm->tabh))
- memset (pm->tabh, ~0, vec_bytes (pm->tabh));
+ clib_memset (pm->tabh, ~0, vec_bytes (pm->tabh));
vec_validate (pm->tabb_sort, vec_len (pm->tabb) - 1);
for (i = 0; i < vec_len (pm->tabb_sort); i++)
phash_main_free_working_memory (pm);
vec_free (pm->tab);
vec_free (pm->keys);
- memset (pm, 0, sizeof (pm[0]));
+ clib_memset (pm, 0, sizeof (pm[0]));
}
/* Slow hash computation for general keys. */
/* Set the entire free bitmap */
clib_bitmap_alloc (fh->free_bitmap, max_elts);
- memset (fh->free_bitmap, 0xff, vec_len (fh->free_bitmap) * sizeof (uword));
+ clib_memset (fh->free_bitmap, 0xff,
+ vec_len (fh->free_bitmap) * sizeof (uword));
/* Clear any extraneous set bits */
set_bits = vec_len (fh->free_bitmap) * BITS (uword);
CLIB_CACHE_LINE_BYTES);
vec_resize (h->hash_key_valid_bitmap,
1 << (l - QHASH_LOG2_KEYS_PER_BUCKET));
- memset (v, ~0, elt_bytes << l);
+ clib_memset (v, ~0, elt_bytes << l);
return v;
}
if (!v)
{
- memset (result_indices, ~0, sizeof (result_indices[0]) * n_search_keys);
+ clib_memset (result_indices, ~0,
+ sizeof (result_indices[0]) * n_search_keys);
return;
}
uword dl = round_pow2 (1 + i - l, 8);
v = _vec_resize (v, dl, (l + dl) * elt_bytes, sizeof (h[0]),
/* align */ sizeof (uword));
- memset (v + l * elt_bytes, ~0, dl * elt_bytes);
+ clib_memset (v + l * elt_bytes, ~0, dl * elt_bytes);
}
}
{
uword i, j;
- memset (b, 0, sizeof (b[0]));
+ clib_memset (b, 0, sizeof (b[0]));
/* Seed ISAAC. */
for (i = 0; i < ARRAY_LEN (b->ctx); i++)
return;
}
- memset (&h, 0, sizeof (h));
+ clib_memset (&h, 0, sizeof (h));
#define _(f) unserialize_integer (m, &h.f, sizeof (h.f));
foreach_serialize_heap_header_integer;
#undef _
void
serialize_open_data (serialize_main_t * m, u8 * data, uword n_data_bytes)
{
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
m->stream.buffer = data;
m->stream.n_buffer_bytes = n_data_bytes;
}
void
serialize_open_vector (serialize_main_t * m, u8 * vector)
{
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
m->header.data_function = serialize_vector_write;
m->stream.buffer = vector;
m->stream.current_buffer_index = 0;
if (s->buffer)
_vec_len (s->buffer) = s->current_buffer_index;
result = s->buffer;
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
return result;
}
serialize_open_clib_file_descriptor_helper (serialize_main_t * m, int fd,
uword is_read)
{
- memset (m, 0, sizeof (m[0]));
+ clib_memset (m, 0, sizeof (m[0]));
vec_resize (m->stream.buffer, 4096);
if (!is_read)
format_function_t format_user_element)
{
clib_slist_elt_t *head;
- memset (sp, 0, sizeof (sp[0]));
+ clib_memset (sp, 0, sizeof (sp[0]));
sp->branching_factor = branching_factor;
sp->format_user_element = format_user_element;
sp->compare = compare;
* Initial negotiating position, only the head_elt is
* lighter than the supplied key
*/
- memset (sp->path, 0, vec_len (head_elt->n.nexts) * sizeof (u32));
+ clib_memset (sp->path, 0, vec_len (head_elt->n.nexts) * sizeof (u32));
/* Walk the fastest lane first */
level = vec_len (head_elt->n.nexts) - 1;
{
struct sockaddr_in a;
- memset (&a, 0, sizeof (a)); /* Warnings be gone */
+ clib_memset (&a, 0, sizeof (a)); /* Warnings be gone */
a.sin_family = PF_INET;
a.sin_addr.s_addr = INADDR_ANY;
if (num_fds > 0)
{
struct cmsghdr *cmsg;
- memset (&ctl, 0, sizeof (ctl));
+ clib_memset (&ctl, 0, sizeof (ctl));
mh.msg_control = ctl;
mh.msg_controllen = sizeof (ctl);
cmsg = CMSG_FIRSTHDR (&mh);
mh.msg_control = ctl;
mh.msg_controllen = sizeof (ctl);
- memset (ctl, 0, sizeof (ctl));
+ clib_memset (ctl, 0, sizeof (ctl));
/* receive the incoming message */
size = recvmsg (s->fd, &mh, 0);
clib_error_t *err = 0;
socklen_t len = 0;
- memset (client, 0, sizeof (client[0]));
+ clib_memset (client, 0, sizeof (client[0]));
/* Accept the new socket connection. */
client->fd = accept (server->fd, 0, 0);
vec_free (s->rx_buffer);
if (clib_mem_is_heap_object (s->config))
vec_free (s->config);
- memset (s, 0, sizeof (s[0]));
+ clib_memset (s, 0, sizeof (s[0]));
}
always_inline clib_error_t *
}
}
+void
+clib_c11_violation (const char *s)
+{
+ _clib_error (CLIB_ERROR_WARNING, (char *) __FUNCTION__, 0, (char *) s);
+}
+
+errno_t
+memcpy_s (void *__restrict__ dest, rsize_t dmax,
+ const void *__restrict__ src, rsize_t n)
+{
+ return memcpy_s_inline (dest, dmax, src, n);
+}
+
+errno_t
+memset_s (void *s, rsize_t smax, int c, rsize_t n)
+{
+ return memset_s_inline (s, smax, c, n);
+}
+
/*
* fd.io coding-style-patch-verification: ON
*
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+/** \file
+
+ Optimized string handling code, including c11-compliant
+ "safe C library" variants.
+*/
+
#ifndef included_clib_string_h
#define included_clib_string_h
#elif __SSSE3__
#include <vppinfra/memcpy_sse3.h>
#else
-#define clib_memcpy(a,b,c) memcpy(a,b,c)
+#define _clib_memcpy(a,b,c) memcpy(a,b,c)
#endif
#else /* __COVERITY__ */
-#define clib_memcpy(a,b,c) memcpy(a,b,c)
+#define _clib_memcpy(a,b,c) memcpy(a,b,c)
#endif
+/* c-11 string manipulation variants */
+
+#ifndef EOK
+#define EOK 0
+#endif
+#ifndef EINVAL
+#define EINVAL 22
+#endif
+
+typedef int errno_t;
+typedef uword rsize_t;
+
+void clib_c11_violation (const char *s);
+errno_t memcpy_s (void *__restrict__ dest, rsize_t dmax,
+ const void *__restrict__ src, rsize_t n);
+
+always_inline errno_t
+memcpy_s_inline (void *__restrict__ dest, rsize_t dmax,
+ const void *__restrict__ src, rsize_t n)
+{
+ uword low, hi;
+ u8 bad;
+
+ /*
+ * call bogus if: src or dst NULL, trying to copy
+ * more data than we have space in dst, or src == dst.
+ * n == 0 isn't really "bad", so check first in the
+ * "wall-of-shame" department...
+ */
+ bad = (dest == 0) + (src == 0) + (n > dmax) + (dest == src) + (n == 0);
+ if (PREDICT_FALSE (bad != 0))
+ {
+ /* Not actually trying to copy anything is OK */
+ if (n == 0)
+ return EOK;
+ if (dest == NULL)
+ clib_c11_violation ("dest NULL");
+ if (src == NULL)
+ clib_c11_violation ("src NULL");
+ if (n > dmax)
+ clib_c11_violation ("n > dmax");
+ if (dest == src)
+ clib_c11_violation ("dest == src");
+ return EINVAL;
+ }
+
+ /* Check for src/dst overlap, which is not allowed */
+ low = (uword) (src < dest ? src : dest);
+ hi = (uword) (src < dest ? dest : src);
+
+ if (PREDICT_FALSE (low + (n - 1) >= hi))
+ {
+ clib_c11_violation ("src/dest overlap");
+ return EINVAL;
+ }
+
+ _clib_memcpy (dest, src, n);
+ return EOK;
+}
+
+/*
+ * Note: $$$ This macro is a crutch. Folks need to manually
+ * inspect every extant clib_memcpy(...) call and
+ * attempt to provide a real destination buffer size
+ * argument...
+ */
+#define clib_memcpy(d,s,n) memcpy_s_inline(d,n,s,n)
+
+errno_t memset_s (void *s, rsize_t smax, int c, rsize_t n);
+
+always_inline errno_t
+memset_s_inline (void *s, rsize_t smax, int c, rsize_t n)
+{
+ u8 bad;
+
+ bad = (s == 0) + (n > smax);
+
+ if (PREDICT_FALSE (bad != 0))
+ {
+ if (s == 0)
+ clib_c11_violation ("s NULL");
+ if (n > smax)
+ clib_c11_violation ("n > smax");
+ return (EINVAL);
+ }
+ memset (s, c, n);
+ return (EOK);
+}
+
+/*
+ * This macro is not [so much of] a crutch.
+ * It's super-typical to write:
+ *
+ * ep = pool_get (<pool>);
+ * clib_memset(ep, 0, sizeof (*ep));
+ *
+ * The compiler should delete the not-so useful
+ * (n > smax) test. TBH the NULL pointer check isn't
+ * so useful in this case, but so be it.
+ */
+#define clib_memset(s,c,n) memset_s_inline(s,n,c,n)
+
/*
* Copy 64 bytes of data to 4 destinations
* this function is typically used in quad-loop case when whole cacheline
return count;
}
-
#endif /* included_clib_string_h */
/*
unformat_input_t i;
clib_error_t *error;
test_main_t *tm = &test_main;
- memset (&test_main, 0, sizeof (test_main));
+ clib_memset (&test_main, 0, sizeof (test_main));
clib_mem_init (0, 3ULL << 30);
return error;
/* Put in new null terminated string. */
- memset (s->contents, 0, vec_len (s->contents));
+ clib_memset (s->contents, 0, vec_len (s->contents));
clib_memcpy (s->contents, interp, strlen (interp));
return 0;
unformat_input_t i;
clib_error_t *error = 0;
- memset (tm, 0, sizeof (tm[0]));
+ clib_memset (tm, 0, sizeof (tm[0]));
unformat_init_command_line (&i, argv);
while (unformat_check_input (&i) != UNFORMAT_END_OF_INPUT)
vec_resize (objects, 1000);
if (vec_bytes (objects) > 0) /* stupid warning be gone */
- memset (objects, ~0, vec_bytes (objects));
+ clib_memset (objects, ~0, vec_bytes (objects));
vec_resize (handles, vec_len (objects));
objects_used = 0;
clib_warning ("unknown input '%U'", format_unformat_error, input);
}
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->mm = mm;
a->file_basename = "/tmp/maplog_test";
a->file_size_in_bytes = 4096;
}
if (noclose)
- memset (mm, 0, sizeof (*mm));
+ clib_memset (mm, 0, sizeof (*mm));
else
clib_maplog_close (mm);
vec_resize (objects, n_objects);
if (vec_bytes (objects) > 0) /* stupid warning be gone */
- memset (objects, ~0, vec_bytes (objects));
+ clib_memset (objects, ~0, vec_bytes (objects));
objects_used = 0;
/* Allocate initial heap. */
test_qhash_main_t _tm, *tm = &_tm;
uword i, iter;
- memset (tm, 0, sizeof (tm[0]));
+ clib_memset (tm, 0, sizeof (tm[0]));
tm->n_iter = 10;
tm->seed = 1;
tm->n_keys = 10;
serialize_main_t *um = &tm->unserialize_main;
uword i;
- memset (tm, 0, sizeof (tm[0]));
+ clib_memset (tm, 0, sizeof (tm[0]));
tm->n_iter = 100;
tm->seed = 1;
tm->max_len = 128;
fformat (stdout, "Test daylight time rules:\n");
- memset (cp, 0, sizeof (*cp));
+ clib_memset (cp, 0, sizeof (*cp));
/* Just before DST starts */
cp->year = 2011;
timing_wheel_t *w = &tm->timing_wheel;
uword iter, i;
- memset (tm, 0, sizeof (tm[0]));
+ clib_memset (tm, 0, sizeof (tm[0]));
tm->n_iter = 10;
tm->time_per_status_update = 0;
tm->n_events = 100;
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (j = 0; j < tm->ntimers / 4; j++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (j = 0; j < tm->ntimers / 4; j++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
expiration_time = get_expiration_time (tm);
max_expiration_time = clib_max (expiration_time, max_expiration_time);
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (j = 0; j < tm->ntimers / 4; j++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
for (j = 0; j < tm->ntimers / 4; j++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
do
{
expected_to_expire = timer_arg + offset;
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
e->expected_to_expire = expected_to_expire;
e->stop_timer_handle = tw_timer_start_2t_1w_2048sl
(&tm->single_wheel, e - tm->test_elts, 1 /* timer id */ ,
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
e->expected_to_expire = i + offset + 1;
e->stop_timer_handle = tw_timer_start_16t_2w_512sl
/* Prime the pump */
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
/* 1 glacier ring tick from now */
expiration_time = TW_SLOTS_PER_RING * TW_SLOTS_PER_RING;
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
expiration_time = 512;
for (i = 0; i < tm->ntimers; i++)
{
pool_get (tm->test_elts, e);
- memset (e, 0, sizeof (*e));
+ clib_memset (e, 0, sizeof (*e));
expiration_time = i + 1;
int is_test5 = 0;
int overflow = 0;
- memset (tm, 0, sizeof (*tm));
+ clib_memset (tm, 0, sizeof (*tm));
/* Default values */
tm->ntimers = 100000;
tm->seed = 0xDEADDABEB00BFACE;
vhash_t *vh = &tm->vhash;
uword i, j;
- memset (tm, 0, sizeof (tm[0]));
+ clib_memset (tm, 0, sizeof (tm[0]));
tm->n_iter = 100;
tm->seed = 1;
tm->n_keys = 1;
void
clib_time_init (clib_time_t * c)
{
- memset (c, 0, sizeof (c[0]));
+ clib_memset (c, 0, sizeof (c[0]));
c->clocks_per_second = os_cpu_clock_frequency ();
c->seconds_per_clock = 1 / c->clocks_per_second;
c->log2_clocks_per_second = min_log2_u64 ((u64) c->clocks_per_second);
clib_timebase_init (clib_timebase_t * tb, i32 timezone_offset_in_hours,
clib_timebase_daylight_time_t daylight_type)
{
- memset (tb, 0, sizeof (*tb));
+ clib_memset (tb, 0, sizeof (*tb));
clib_time_init (&tb->clib_time);
tb->time_zero = unix_time_now ();
{
/* Set timer for to go off in future. */
struct itimerval itv;
- memset (&itv, 0, sizeof (itv));
+ clib_memset (&itv, 0, sizeof (itv));
f64_to_tv (dt, &itv.it_value);
if (setitimer (ITIMER_REAL, &itv, 0) < 0)
clib_unix_error ("sititmer");
{
sigset_t block_timer;
- memset (&block_timer, 0, sizeof (block_timer));
+ clib_memset (&block_timer, 0, sizeof (block_timer));
sigaddset (&block_timer, TIMER_SIGNAL);
sigprocmask (SIG_BLOCK, &block_timer, save);
}
/* Initialize time_resolution before first call to timer_interrupt */
time_resolution = 0.75 / (f64) HZ;
- memset (&sa, 0, sizeof (sa));
+ clib_memset (&sa, 0, sizeof (sa));
sa.sa_handler = timer_interrupt;
if (sigaction (TIMER_SIGNAL, &sa, 0) < 0)
{
/* Poison free elements so we never use them by mistake. */
if (CLIB_DEBUG > 0)
- memset (ev, ~0, vec_len (ev) * sizeof (ev[0]));
+ clib_memset (ev, ~0, vec_len (ev) * sizeof (ev[0]));
_vec_len (ev) = 0;
vec_add1 (w->free_elt_vectors, ev);
}
ASSERT (interval);
pool_get (tw->timers, t);
- memset (t, 0xff, sizeof (*t));
+ clib_memset (t, 0xff, sizeof (*t));
t->user_handle = TW (make_internal_timer_handle) (user_id, timer_id);
int ring, slot;
tw_timer_wheel_slot_t *ts;
TWT (tw_timer) * t;
- memset (tw, 0, sizeof (*tw));
+ clib_memset (tw, 0, sizeof (*tw));
tw->expired_timer_callback = expired_timer_callback;
tw->max_expirations = max_expirations;
if (timer_interval_in_seconds == 0.0)
{
ts = &tw->w[ring][slot];
pool_get (tw->timers, t);
- memset (t, 0xff, sizeof (*t));
+ clib_memset (t, 0xff, sizeof (*t));
t->next = t->prev = t - tw->timers;
ts->head_index = t - tw->timers;
}
#if TW_OVERFLOW_VECTOR > 0
ts = &tw->overflow;
pool_get (tw->timers, t);
- memset (t, 0xff, sizeof (*t));
+ clib_memset (t, 0xff, sizeof (*t));
t->next = t->prev = t - tw->timers;
ts->head_index = t - tw->timers;
#endif
pool_put (tw->timers, head);
#endif
- memset (tw, 0, sizeof (*tw));
+ clib_memset (tw, 0, sizeof (*tw));
}
/**
if (!token_chars)
token_chars = (u8 *) "a-zA-Z0-9_";
- memset (map, 0, sizeof (map));
+ clib_memset (map, 0, sizeof (map));
for (s = token_chars; *s;)
{
/* Parse range. */
uword signs[2], sign_index = 0;
uword n_input = 0;
- memset (values, 0, sizeof (values));
- memset (n_digits, 0, sizeof (n_digits));
- memset (signs, 0, sizeof (signs));
+ clib_memset (values, 0, sizeof (values));
+ clib_memset (n_digits, 0, sizeof (n_digits));
+ clib_memset (signs, 0, sizeof (signs));
while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
{
if (index == ~0 || template->baseva < ch->baseva)
{
pool_get (vam->chunks, new_ch);
- memset (new_ch, 0, sizeof (*new_ch));
+ clib_memset (new_ch, 0, sizeof (*new_ch));
if (index != ~0)
{
index = ch - vam->chunks;
pool_get (vam->chunks, new_ch);
- memset (new_ch, 0, sizeof (*new_ch));
+ clib_memset (new_ch, 0, sizeof (*new_ch));
ch = pool_elt_at_index (vam->chunks, index);
int need_lock)
{
ASSERT (template && template->baseva && template->size);
- memset (vam, 0, sizeof (*vam));
+ clib_memset (vam, 0, sizeof (*vam));
if (need_lock)
clib_spinlock_init (&vam->lock);
pool_get (vam->chunks, new_ch);
/* ch might have just moved */
ch = pool_elt_at_index (vam->chunks, index);
- memset (new_ch, 0, sizeof (*new_ch));
+ clib_memset (new_ch, 0, sizeof (*new_ch));
new_ch->next = new_ch->prev = ~0;
new_ch->baseva = ch->baseva + size;
new_ch->size = ch->size - size;
next_ch->prev = ch->prev;
}
ASSERT (ch - vam->chunks != vam->first_index);
- memset (ch, 0xfe, sizeof (*ch));
+ clib_memset (ch, 0xfe, sizeof (*ch));
pool_put (vam->chunks, ch);
/* See about combining with next elt */
ch = prev_ch;
n2_ch->prev = ch - vam->chunks;
}
ASSERT (next_ch - vam->chunks != vam->first_index);
- memset (next_ch, 0xfe, sizeof (*ch));
+ clib_memset (next_ch, 0xfe, sizeof (*ch));
pool_put (vam->chunks, next_ch);
}
}
new = clib_mem_alloc_aligned_at_offset (data_bytes, data_align, header_bytes, 1 /* yes, call os_out_of_memory */
);
data_bytes = clib_mem_size (new);
- memset (new, 0, data_bytes);
+ clib_memset (new, 0, data_bytes);
v = new + header_bytes;
_vec_len (v) = length_increment;
return v;
v = new;
/* Zero new memory. */
- memset (v + old_alloc_bytes, 0, new_alloc_bytes - old_alloc_bytes);
+ clib_memset (v + old_alloc_bytes, 0, new_alloc_bytes - old_alloc_bytes);
return v + header_bytes;
}
vec_resize_ha ((V), 1 + (_v(i) - _v(l)), (H), (A)); \
/* Must zero new space since user may have previously \
used e.g. _vec_len (v) -= 10 */ \
- memset ((V) + _v(l), 0, (1 + (_v(i) - _v(l))) * sizeof ((V)[0])); \
+ clib_memset ((V) + _v(l), 0, (1 + (_v(i) - _v(l))) * sizeof ((V)[0])); \
} \
} while (0)
memmove ((V) + _v(m) + _v(n), \
(V) + _v(m), \
(_v(l) - _v(m)) * sizeof ((V)[0])); \
- memset ((V) + _v(m), INIT, _v(n) * sizeof ((V)[0])); \
+ clib_memset ((V) + _v(m), INIT, _v(n) * sizeof ((V)[0])); \
} while (0)
/** \brief Insert N vector elements starting at element M,
(_v(l) - _v(n) - _v(m)) * sizeof ((V)[0])); \
/* Zero empty space at end (for future re-allocation). */ \
if (_v(n) > 0) \
- memset ((V) + _v(l) - _v(n), 0, _v(n) * sizeof ((V)[0])); \
+ clib_memset ((V) + _v(l) - _v(n), 0, _v(n) * sizeof ((V)[0])); \
_vec_len (V) -= _v(n); \
} while (0)
#define vec_zero(var) \
do { \
if (var) \
- memset ((var), 0, vec_len (var) * sizeof ((var)[0])); \
+ clib_memset ((var), 0, vec_len (var) * sizeof ((var)[0])); \
} while (0)
/** \brief Set all vector elements to given value. Null-pointer tolerant.
uword i, j, m;
vhash_search_bucket_t *b;
- memset (h, 0, sizeof (h[0]));
+ clib_memset (h, 0, sizeof (h[0]));
/* Must have at least 4 keys (e.g. one search bucket). */
log2_n_keys = clib_max (log2_n_keys, 2);
printf ("--- Create/delete loopbacks using blocking API ---\n");
const size_t num_ifs = 5;
u8 mac_addresses[num_ifs][6];
- memset (&mac_addresses, 0, sizeof (mac_addresses));
+ clib_memset (&mac_addresses, 0, sizeof (mac_addresses));
u32 sw_if_indexes[num_ifs];
- memset (&sw_if_indexes, 0xff, sizeof (sw_if_indexes));
+ clib_memset (&sw_if_indexes, 0xff, sizeof (sw_if_indexes));
test_create_loopback_ctx_t clcs[num_ifs];
- memset (&clcs, 0, sizeof (clcs));
+ clib_memset (&clcs, 0, sizeof (clcs));
test_delete_loopback_ctx_t dlcs[num_ifs];
- memset (&dlcs, 0, sizeof (dlcs));
+ clib_memset (&dlcs, 0, sizeof (dlcs));
int i;
for (i = 0; i < num_ifs; ++i)
{
for (i = 0; i < attempts; ++i)
{
dctx.last_called = false;
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
dump = vapi_alloc_sw_interface_dump (ctx);
dump->payload.name_filter_valid = 0;
- memset (dump->payload.name_filter, 0,
- sizeof (dump->payload.name_filter));
+ clib_memset (dump->payload.name_filter, 0,
+ sizeof (dump->payload.name_filter));
while (VAPI_EAGAIN ==
(rv =
vapi_sw_interface_dump (ctx, dump, sw_interface_dump_cb,
ck_assert_int_eq (true, seen[j]);
}
}
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
for (i = 0; i < num_ifs; ++i)
{
vapi_msg_delete_loopback *dl = vapi_alloc_delete_loopback (ctx);
printf ("Deleted loopback with sw_if_index %u\n", sw_if_indexes[i]);
}
dctx.last_called = false;
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
dump = vapi_alloc_sw_interface_dump (ctx);
dump->payload.name_filter_valid = 0;
- memset (dump->payload.name_filter, 0, sizeof (dump->payload.name_filter));
+ clib_memset (dump->payload.name_filter, 0,
+ sizeof (dump->payload.name_filter));
while (VAPI_EAGAIN ==
(rv =
vapi_sw_interface_dump (ctx, dump, sw_interface_dump_cb, &dctx)))
vapi_error_e rv;
const size_t num_req = 5;
int contexts[num_req];
- memset (contexts, 0, sizeof (contexts));
+ clib_memset (contexts, 0, sizeof (contexts));
int i;
for (i = 0; i < num_req; ++i)
{
{
ck_assert_int_eq (1, contexts[i]);
}
- memset (contexts, 0, sizeof (contexts));
+ clib_memset (contexts, 0, sizeof (contexts));
rv = vapi_dispatch (ctx);
ck_assert_int_eq (VAPI_OK, rv);
for (i = 0; i < num_req; ++i)
vapi_error_e rv;
const size_t num_ifs = 5;
u8 mac_addresses[num_ifs][6];
- memset (&mac_addresses, 0, sizeof (mac_addresses));
+ clib_memset (&mac_addresses, 0, sizeof (mac_addresses));
u32 sw_if_indexes[num_ifs];
- memset (&sw_if_indexes, 0xff, sizeof (sw_if_indexes));
+ clib_memset (&sw_if_indexes, 0xff, sizeof (sw_if_indexes));
test_create_loopback_ctx_t clcs[num_ifs];
- memset (&clcs, 0, sizeof (clcs));
+ clib_memset (&clcs, 0, sizeof (clcs));
test_delete_loopback_ctx_t dlcs[num_ifs];
- memset (&dlcs, 0, sizeof (dlcs));
+ clib_memset (&dlcs, 0, sizeof (dlcs));
int i;
for (i = 0; i < num_ifs; ++i)
{
sw_if_indexes[i]);
}
bool seen[num_ifs];
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
sw_interface_dump_ctx dctx = { false, num_ifs, sw_if_indexes, seen, 0 };
vapi_msg_sw_interface_dump *dump = vapi_alloc_sw_interface_dump (ctx);
dump->payload.name_filter_valid = 0;
- memset (dump->payload.name_filter, 0, sizeof (dump->payload.name_filter));
+ clib_memset (dump->payload.name_filter, 0,
+ sizeof (dump->payload.name_filter));
while (VAPI_EAGAIN ==
(rv =
vapi_sw_interface_dump (ctx, dump, sw_interface_dump_cb, &dctx)))
{
ck_assert_int_eq (false, seen[i]);
}
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
ck_assert_int_eq (false, dctx.last_called);
rv = vapi_dispatch (ctx);
ck_assert_int_eq (VAPI_OK, rv);
{
ck_assert_int_eq (true, seen[i]);
}
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
ck_assert_int_eq (true, dctx.last_called);
for (i = 0; i < num_ifs; ++i)
{
ck_assert_int_eq (1, dlcs[i].called);
printf ("Deleted loopback with sw_if_index %u\n", sw_if_indexes[i]);
}
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
dctx.last_called = false;
dump = vapi_alloc_sw_interface_dump (ctx);
dump->payload.name_filter_valid = 0;
- memset (dump->payload.name_filter, 0, sizeof (dump->payload.name_filter));
+ clib_memset (dump->payload.name_filter, 0,
+ sizeof (dump->payload.name_filter));
while (VAPI_EAGAIN ==
(rv =
vapi_sw_interface_dump (ctx, dump, sw_interface_dump_cb, &dctx)))
{
ck_assert_int_eq (false, seen[i]);
}
- memset (&seen, 0, sizeof (seen));
+ clib_memset (&seen, 0, sizeof (seen));
ck_assert_int_eq (true, dctx.last_called);
}
Code Review / vpp.git / commitdiff