#include <vnet/cop/cop.h>
#include <vnet/ip/ip6_hop_by_hop.h>
#include <vnet/devices/af_packet/af_packet.h>
+#include <vnet/policer/policer.h>
+#include <vnet/devices/netmap/netmap.h>
#undef BIHASH_TYPE
#undef __included_bihash_template_h__
_(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable) \
_(LISP_ENABLE_DISABLE, lisp_enable_disable) \
_(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface) \
+_(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping) \
+_(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set) \
_(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump) \
_(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump) \
_(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump) \
lisp_enable_disable_status_dump) \
_(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del) \
_(AF_PACKET_CREATE, af_packet_create) \
-_(AF_PACKET_DELETE, af_packet_delete)
+_(AF_PACKET_DELETE, af_packet_delete) \
+_(POLICER_ADD_DEL, policer_add_del) \
+_(POLICER_DUMP, policer_dump) \
+_(NETMAP_CREATE, netmap_create) \
+_(NETMAP_DELETE, netmap_delete)
#define QUOTE_(x) #x
#define QUOTE(x) QUOTE_(x)
decap_fib_index = ntohl(mp->decap_vrf_id);
}
+ /* Check src & dst are different */
+ if ((a->is_ip6 && memcmp(mp->local, mp->remote, 16) == 0) ||
+ (!a->is_ip6 && memcmp(mp->local, mp->remote, 4) == 0)) {
+ rv = VNET_API_ERROR_SAME_SRC_DST;
+ goto out;
+ }
memset (a, 0, sizeof (*a));
a->is_add = mp->is_add;
+ a->is_ip6 = mp->is_ipv6;
/* ip addresses sent in network byte order */
- a->local.as_u32 = ntohl(mp->local);
- a->remote.as_u32 = ntohl(mp->remote);
+ if (a->is_ip6) {
+ clib_memcpy(&(a->local.ip6), mp->local, 16);
+ clib_memcpy(&(a->remote.ip6), mp->remote, 16);
+ } else {
+ clib_memcpy(&(a->local.ip4), mp->local, 4);
+ clib_memcpy(&(a->remote.ip4), mp->remote, 4);
+ }
a->encap_fib_index = encap_fib_index;
a->decap_fib_index = decap_fib_index;
a->protocol = protocol;
REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY);
}
+static void
+vl_api_lisp_pitr_set_locator_set_t_handler(
+ vl_api_lisp_pitr_set_locator_set_t *mp)
+{
+ vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
+ int rv = 0;
+ u8 * ls_name = 0;
+
+ ls_name = format (0, "%s", mp->ls_name);
+ rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
+ vec_free (ls_name);
+
+ REPLY_MACRO(VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
+}
+
+/** Used for transferring locators via VPP API */
+typedef CLIB_PACKED(struct
+{
+ u8 is_ip4; /**< is locator an IPv4 address */
+ u8 addr[16]; /**< IPv4/IPv6 address */
+}) rloc_t;
+
static void
send_lisp_locator_set_details_set_address
(vl_api_lisp_locator_set_details_t *rmp,
ip_address_copy_addr(rmp->ip_address, &ip_prefix_addr(ip_addr));
}
+static void
+vl_api_lisp_add_del_remote_mapping_t_handler (
+ vl_api_lisp_add_del_remote_mapping_t *mp)
+{
+ u32 i;
+ ip_address_t rloc, * rlocs = 0;
+ vl_api_lisp_add_del_remote_mapping_reply_t * rmp;
+ int rv = 0;
+ gid_address_t _seid, * seid = &_seid;
+ gid_address_t _deid, * deid = &_deid;
+ ip_prefix_t * seid_pref = &gid_address_ippref(seid);
+ ip_prefix_t * deid_pref = &gid_address_ippref(deid);
+
+ gid_address_type(seid) = GID_ADDR_IP_PREFIX;
+ gid_address_type(deid) = GID_ADDR_IP_PREFIX;
+ ip_address_t * seid_addr = &ip_prefix_addr(seid_pref);
+ ip_address_t * deid_addr = &ip_prefix_addr(deid_pref);
+ ip_prefix_len(seid_pref) = mp->seid_len;
+ ip_prefix_len(deid_pref) = mp->deid_len;
+ gid_address_set_vni (seid, ntohl (mp->vni));
+ gid_address_set_vni (deid, ntohl (mp->vni));
+
+ if (mp->eid_is_ip4) {
+ ip_prefix_version(seid_pref) = IP4;
+ ip_prefix_version(deid_pref) = IP4;
+ clib_memcpy (&ip_addr_v4(seid_addr),
+ mp->seid, sizeof (ip_addr_v4(seid_addr)));
+ clib_memcpy (&ip_addr_v4(deid_addr),
+ mp->deid, sizeof (ip_addr_v4(deid_addr)));
+ } else {
+ ip_prefix_version(seid_pref) = IP6;
+ ip_prefix_version(deid_pref) = IP6;
+ clib_memcpy (&ip_addr_v6(seid_addr),
+ mp->seid, sizeof (ip_addr_v6(seid_addr)));
+ clib_memcpy (&ip_addr_v6(deid_addr),
+ mp->deid, sizeof (ip_addr_v6(deid_addr)));
+ }
+
+ for (i = 0; i < mp->rloc_num; i++) {
+ rloc_t * r = &((rloc_t *) mp->rlocs)[i];
+ if (r->is_ip4) {
+ clib_memcpy (&ip_addr_v4(&rloc), &r->addr, sizeof (rloc_t));
+ ip_addr_version (&rloc) = IP4;
+ } else {
+ clib_memcpy (&ip_addr_v6(&rloc), &r->addr, sizeof (rloc_t));
+ ip_addr_version (&rloc) = IP6;
+ }
+ vec_add1 (rlocs, rloc);
+ }
+
+ rv = vnet_lisp_add_del_remote_mapping (deid, seid, rlocs,
+ mp->action, mp->is_add);
+ vec_free (rlocs);
+ REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY);
+}
+
static void
send_lisp_locator_set_details (lisp_cp_main_t *lcm,
locator_set_t *lsit,
/*
* Keep the number of memcpy ops to a minimum (e.g. 1).
- * The current size of the serialized vector is
- * slightly under 4K.
*/
- vec_validate (vector, 4095);
+ vec_validate (vector, 16384);
vec_reset_length (vector);
- vector = vlib_node_serialize (&vm->node_main, vector);
+ /* $$$$ FIXME */
+ vector = vlib_node_serialize (&vm->node_main, vector,
+ (u32)~0 /* all threads */,
+ 1 /* include nexts */,
+ 1 /* include stats */);
svm_pop_heap (oldheap);
pthread_mutex_unlock (&am->vlib_rp->mutex);
vec_add1 (host_if_name, 0);
rv = af_packet_create_if(vm, host_if_name,
- mp->use_random_hw_addr ? 0 : mp->hw_addr);
+ mp->use_random_hw_addr ? 0 : mp->hw_addr, 0);
vec_free(host_if_name);
REPLY_MACRO(VL_API_AF_PACKET_DELETE_REPLY);
}
+static void
+vl_api_policer_add_del_t_handler
+(vl_api_policer_add_del_t *mp)
+{
+ vlib_main_t * vm = vlib_get_main();
+ vl_api_policer_add_del_reply_t *rmp;
+ int rv = 0;
+ u8 *name = NULL;
+ sse2_qos_pol_cfg_params_st cfg;
+ clib_error_t * error;
+
+ name = format(0, "%s", mp->name);
+
+ memset (&cfg, 0, sizeof (cfg));
+ cfg.rfc = mp->type;
+ cfg.rnd_type = mp->round_type;
+ cfg.rate_type = mp->rate_type;
+ cfg.rb.kbps.cir_kbps = mp->cir;
+ cfg.rb.kbps.eir_kbps = mp->eir;
+ cfg.rb.kbps.cb_bytes = mp->cb;
+ cfg.rb.kbps.eb_bytes = mp->eb;
+
+ error = policer_add_del(vm, name, &cfg, mp->is_add);
+
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+
+ REPLY_MACRO(VL_API_POLICER_ADD_DEL_REPLY);
+}
+
+static void
+send_policer_details (u8 *name,
+ sse2_qos_pol_cfg_params_st *config,
+ policer_read_response_type_st *templ,
+ unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ vl_api_policer_details_t * mp;
+
+ mp = vl_msg_api_alloc (sizeof (*mp));
+ 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);
+ mp->eir = htonl(config->rb.kbps.eir_kbps);
+ mp->cb = htonl(config->rb.kbps.cb_bytes);
+ mp->eb = htonl(config->rb.kbps.eb_bytes);
+ mp->rate_type = config->rate_type;
+ mp->round_type = config->rnd_type;
+ mp->type = config->rfc;
+ mp->single_rate = templ->single_rate ? 1 : 0;
+ mp->color_aware = templ->color_aware ? 1 : 0;
+ mp->scale = htonl(templ->scale);
+ mp->cir_tokens_per_period = htonl(templ->cir_tokens_per_period);
+ mp->pir_tokens_per_period = htonl(templ->pir_tokens_per_period);
+ mp->current_limit = htonl(templ->current_limit);
+ mp->current_bucket = htonl(templ->current_bucket);
+ mp->extended_limit = htonl(templ->extended_limit);
+ mp->extended_bucket = htonl(templ->extended_bucket);
+ mp->last_update_time = clib_host_to_net_u64(templ->last_update_time);
+
+ strncpy ((char *) mp->name, (char *) name, ARRAY_LEN(mp->name) - 1);
+
+ vl_msg_api_send_shmem (q, (u8 *)&mp);
+}
+
+static void
+vl_api_policer_dump_t_handler
+(vl_api_policer_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q;
+ vnet_policer_main_t * pm = &vnet_policer_main;
+ hash_pair_t * hp;
+ uword * p;
+ u32 pool_index;
+ u8 * match_name = 0;
+ u8 * name;
+ sse2_qos_pol_cfg_params_st *config;
+ policer_read_response_type_st *templ;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0)
+ return;
+
+ if (mp->match_name_valid) {
+ match_name = format(0, "%s%c", mp->match_name, 0);
+ }
+
+ if (mp->match_name_valid) {
+ p = hash_get_mem (pm->policer_config_by_name, match_name);
+ if (p) {
+ pool_index = p[0];
+ config = pool_elt_at_index (pm->configs, pool_index);
+ templ = pool_elt_at_index (pm->policer_templates, pool_index);
+ send_policer_details(match_name, config, templ, q, mp->context);
+ }
+ } else {
+ hash_foreach_pair (hp, pm->policer_config_by_name,
+ ({
+ name = (u8 *) hp->key;
+ pool_index = hp->value[0];
+ config = pool_elt_at_index (pm->configs, pool_index);
+ templ = pool_elt_at_index (pm->policer_templates, pool_index);
+ send_policer_details(name, config, templ, q, mp->context);
+ }));
+ }
+}
+
+static void
+vl_api_netmap_create_t_handler
+(vl_api_netmap_create_t *mp)
+{
+ vlib_main_t *vm = vlib_get_main();
+ vl_api_netmap_create_reply_t *rmp;
+ int rv = 0;
+ u8 *if_name = NULL;
+
+ if_name = format(0, "%s", mp->netmap_if_name);
+ vec_add1 (if_name, 0);
+
+ rv = netmap_create_if(vm, if_name, mp->use_random_hw_addr ? 0 : mp->hw_addr,
+ mp->is_pipe, mp->is_master, 0);
+
+ vec_free(if_name);
+
+ REPLY_MACRO(VL_API_NETMAP_CREATE_REPLY);
+}
+
+static void
+vl_api_netmap_delete_t_handler
+(vl_api_netmap_delete_t *mp)
+{
+ vlib_main_t * vm = vlib_get_main();
+ vl_api_netmap_delete_reply_t *rmp;
+ int rv = 0;
+ u8 *if_name = NULL;
+
+ if_name = format(0, "%s", mp->netmap_if_name);
+ vec_add1 (if_name, 0);
+
+ rv = netmap_delete_if(vm, if_name);
+
+ vec_free(if_name);
+
+ REPLY_MACRO(VL_API_NETMAP_DELETE_REPLY);
+}
+
#define BOUNCE_HANDLER(nn) \
static void vl_api_##nn##_t_handler ( \
vl_api_##nn##_t *mp) \
* Thread-safe API messages
*/
am->is_mp_safe [VL_API_IP_ADD_DEL_ROUTE] = 1;
+ am->is_mp_safe [VL_API_GET_NODE_GRAPH] = 1;
return 0;
}
Code Review / vpp.git / blobdiff