void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
-typedef struct {
+typedef struct
+{
u32 sw_if_index;
u32 fib_index;
ip4_address_t ip4_address;
} ethernet_arp_ip4_key_t;
-typedef struct {
+typedef struct
+{
ethernet_arp_ip4_key_t key;
u8 ethernet_address[6];
u64 cpu_time_last_updated;
- u32 * adjacencies;
+ u32 *adjacencies;
} ethernet_arp_ip4_entry_t;
-typedef struct {
+typedef struct
+{
u32 lo_addr;
u32 hi_addr;
u32 fib_index;
} ethernet_proxy_arp_t;
-typedef struct {
+typedef struct
+{
u32 next_index;
uword node_index;
uword type_opaque;
uword data;
/* Used for arp event notification only */
- void * data_callback;
+ void *data_callback;
u32 pid;
} pending_resolution_t;
-typedef struct {
+typedef struct
+{
/* Hash tables mapping name to opcode. */
- uword * opcode_by_name;
+ uword *opcode_by_name;
/* lite beer "glean" adjacency handling */
- uword * pending_resolutions_by_address;
- pending_resolution_t * pending_resolutions;
+ uword *pending_resolutions_by_address;
+ pending_resolution_t *pending_resolutions;
/* Mac address change notification */
- uword * mac_changes_by_address;
- pending_resolution_t * mac_changes;
+ uword *mac_changes_by_address;
+ pending_resolution_t *mac_changes;
- ethernet_arp_ip4_entry_t * ip4_entry_pool;
+ ethernet_arp_ip4_entry_t *ip4_entry_pool;
mhash_t ip4_entry_by_key;
-
+
/* ARP attack mitigation */
u32 arp_delete_rotor;
u32 limit_arp_cache_size;
/* Proxy arp vector */
- ethernet_proxy_arp_t * proxy_arps;
+ ethernet_proxy_arp_t *proxy_arps;
} ethernet_arp_main_t;
static ethernet_arp_main_t ethernet_arp_main;
-static u8 * format_ethernet_arp_hardware_type (u8 * s, va_list * va)
+static u8 *
+format_ethernet_arp_hardware_type (u8 * s, va_list * va)
{
ethernet_arp_hardware_type_t h = va_arg (*va, ethernet_arp_hardware_type_t);
- char * t = 0;
+ char *t = 0;
switch (h)
{
#define _(n,f) case n: t = #f; break;
return format (s, "%s", t);
}
-static u8 * format_ethernet_arp_opcode (u8 * s, va_list * va)
+static u8 *
+format_ethernet_arp_opcode (u8 * s, va_list * va)
{
ethernet_arp_opcode_t o = va_arg (*va, ethernet_arp_opcode_t);
- char * t = 0;
+ char *t = 0;
switch (o)
{
#define _(f) case ETHERNET_ARP_OPCODE_##f: t = #f; break;
unformat_ethernet_arp_opcode_host_byte_order (unformat_input_t * input,
va_list * args)
{
- int * result = va_arg (*args, int *);
- ethernet_arp_main_t * am = ðernet_arp_main;
+ int *result = va_arg (*args, int *);
+ ethernet_arp_main_t *am = ðernet_arp_main;
int x, i;
/* Numeric opcode. */
- if (unformat (input, "0x%x", &x)
- || unformat (input, "%d", &x))
+ if (unformat (input, "0x%x", &x) || unformat (input, "%d", &x))
{
if (x >= (1 << 16))
return 0;
unformat_ethernet_arp_opcode_net_byte_order (unformat_input_t * input,
va_list * args)
{
- int * result = va_arg (*args, int *);
- if (! unformat_user (input, unformat_ethernet_arp_opcode_host_byte_order, result))
+ int *result = va_arg (*args, int *);
+ if (!unformat_user
+ (input, unformat_ethernet_arp_opcode_host_byte_order, result))
return 0;
- *result = clib_host_to_net_u16 ((u16) *result);
+ *result = clib_host_to_net_u16 ((u16) * result);
return 1;
}
-static u8 * format_ethernet_arp_header (u8 * s, va_list * va)
+static u8 *
+format_ethernet_arp_header (u8 * s, va_list * va)
{
- ethernet_arp_header_t * a = va_arg (*va, ethernet_arp_header_t *);
+ ethernet_arp_header_t *a = va_arg (*va, ethernet_arp_header_t *);
u32 max_header_bytes = va_arg (*va, u32);
uword indent;
u16 l2_type, l3_type;
format_ethernet_arp_hardware_type, l2_type,
format_ethernet_type, l3_type,
a->n_l2_address_bytes, a->n_l3_address_bytes);
-
+
if (l2_type == ETHERNET_ARP_HARDWARE_TYPE_ethernet
&& l3_type == ETHERNET_TYPE_IP4)
{
uword n3 = a->n_l3_address_bytes;
s = format (s, "\n%U%U/%U -> %U/%U",
format_white_space, indent,
- format_hex_bytes, a->data + 0*n2 + 0*n3, n2,
- format_hex_bytes, a->data + 1*n2 + 0*n3, n3,
- format_hex_bytes, a->data + 1*n2 + 1*n3, n2,
- format_hex_bytes, a->data + 2*n2 + 1*n3, n3);
+ format_hex_bytes, a->data + 0 * n2 + 0 * n3, n2,
+ format_hex_bytes, a->data + 1 * n2 + 0 * n3, n3,
+ format_hex_bytes, a->data + 1 * n2 + 1 * n3, n2,
+ format_hex_bytes, a->data + 2 * n2 + 1 * n3, n3);
}
return s;
}
-static u8 * format_ethernet_arp_ip4_entry (u8 * s, va_list * va)
+static u8 *
+format_ethernet_arp_ip4_entry (u8 * s, va_list * va)
{
- vnet_main_t * vnm = va_arg (*va, vnet_main_t *);
- ethernet_arp_ip4_entry_t * e = va_arg (*va, ethernet_arp_ip4_entry_t *);
- vnet_sw_interface_t * si;
- ip4_fib_t * fib;
- u8 * flags = 0;
+ vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
+ ethernet_arp_ip4_entry_t *e = va_arg (*va, ethernet_arp_ip4_entry_t *);
+ vnet_sw_interface_t *si;
+ ip4_fib_t *fib;
+ u8 *flags = 0;
- if (! e)
+ if (!e)
return format (s, "%=12s%=6s%=16s%=6s%=20s%=24s", "Time", "FIB", "IP4",
- "Flags", "Ethernet", "Interface");
+ "Flags", "Ethernet", "Interface");
fib = find_ip4_fib_by_table_index_or_id (&ip4_main, e->key.fib_index,
- IP4_ROUTE_FLAG_FIB_INDEX);
+ IP4_ROUTE_FLAG_FIB_INDEX);
si = vnet_get_sw_interface (vnm, e->key.sw_if_index);
if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_GLEAN)
- flags = format(flags, "G");
+ flags = format (flags, "G");
if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC)
- flags = format(flags, "S");
+ flags = format (flags, "S");
s = format (s, "%=12U%=6u%=16U%=6s%=20U%=24U",
format_vlib_cpu_time, vnm->vlib_main, e->cpu_time_last_updated,
- fib->table_id,
+ fib->table_id,
format_ip4_address, &e->key.ip4_address,
flags ? (char *) flags : "",
format_ethernet_address, e->ethernet_address,
format_vnet_sw_interface_name, vnm, si);
- vec_free(flags);
+ vec_free (flags);
return s;
}
-typedef struct {
+typedef struct
+{
u8 packet_data[64];
} ethernet_arp_input_trace_t;
-static u8 * format_ethernet_arp_input_trace (u8 * s, va_list * va)
+static u8 *
+format_ethernet_arp_input_trace (u8 * s, va_list * va)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
- ethernet_arp_input_trace_t * t = va_arg (*va, ethernet_arp_input_trace_t *);
+ ethernet_arp_input_trace_t *t = va_arg (*va, ethernet_arp_input_trace_t *);
s = format (s, "%U",
format_ethernet_arp_header,
clib_error_t *
ethernet_arp_sw_interface_up_down (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 flags)
+ u32 sw_if_index, u32 flags)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- ethernet_arp_ip4_entry_t * e;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ethernet_arp_ip4_entry_t *e;
u32 i;
- u32 * to_add_del = 0;
+ u32 *to_add_del = 0;
- pool_foreach (e, am->ip4_entry_pool, ({
+ /* *INDENT-OFF* */
+ pool_foreach (e, am->ip4_entry_pool, ({
if (e->key.sw_if_index == sw_if_index)
vec_add1 (to_add_del, e - am->ip4_entry_pool);
}));
+ /* *INDENT-ON* */
for (i = 0; i < vec_len (to_add_del); i++)
{
arp_add.ip4.as_u32 = e->key.ip4_address.as_u32;
if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
- {
+ {
vnet_arp_set_ip4_over_ethernet (vnm,
- e->key.sw_if_index, e->key.fib_index, &arp_add,
- e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC);
- }
+ e->key.sw_if_index,
+ e->key.fib_index, &arp_add,
+ e->flags &
+ ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC);
+ }
else if ((e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC) == 0)
- {
+ {
vnet_arp_unset_ip4_over_ethernet (vnm,
- e->key.sw_if_index, e->key.fib_index, &arp_add);
- }
+ e->key.sw_if_index,
+ e->key.fib_index, &arp_add);
+ }
}
vec_free (to_add_del);
vnet_arp_set_ip4_over_ethernet_internal (vnet_main_t * vnm,
u32 sw_if_index,
u32 fib_index,
- void * a_arg,
- int is_static);
+ void *a_arg, int is_static);
static int
vnet_arp_unset_ip4_over_ethernet_internal (vnet_main_t * vnm,
u32 sw_if_index,
- u32 fib_index,
- void * a_arg);
+ u32 fib_index, void *a_arg);
-typedef struct {
+typedef struct
+{
u32 sw_if_index;
u32 fib_index;
ethernet_arp_ip4_over_ethernet_address_t a;
int is_static;
- int is_remove; /* set is_remove=1 to clear arp entry */
+ int is_remove; /* set is_remove=1 to clear arp entry */
} vnet_arp_set_ip4_over_ethernet_rpc_args_t;
-static void set_ip4_over_ethernet_rpc_callback
-( vnet_arp_set_ip4_over_ethernet_rpc_args_t * a)
+static void set_ip4_over_ethernet_rpc_callback
+ (vnet_arp_set_ip4_over_ethernet_rpc_args_t * a)
{
- vnet_main_t * vm = vnet_get_main();
- ASSERT(os_get_cpu_number() == 0);
+ vnet_main_t *vm = vnet_get_main ();
+ ASSERT (os_get_cpu_number () == 0);
if (a->is_remove)
- vnet_arp_unset_ip4_over_ethernet_internal(vm,
- a->sw_if_index,
- a->fib_index,
- &(a->a));
+ vnet_arp_unset_ip4_over_ethernet_internal (vm,
+ a->sw_if_index,
+ a->fib_index, &(a->a));
else
vnet_arp_set_ip4_over_ethernet_internal (vm,
a->sw_if_index,
a->fib_index,
- &(a->a),
- a->is_static);
+ &(a->a), a->is_static);
}
int
vnet_arp_set_ip4_over_ethernet (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 fib_index,
- void * a_arg,
- int is_static)
+ u32 sw_if_index,
+ u32 fib_index, void *a_arg, int is_static)
{
- ethernet_arp_ip4_over_ethernet_address_t * a = a_arg;
+ ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
args.sw_if_index = sw_if_index;
args.is_remove = 0;
clib_memcpy (&args.a, a, sizeof (*a));
- vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
- (u8 *) &args, sizeof (args));
+ vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
+ (u8 *) & args, sizeof (args));
return 0;
}
vnet_arp_set_ip4_over_ethernet_internal (vnet_main_t * vnm,
u32 sw_if_index,
u32 fib_index,
- void * a_arg,
- int is_static)
+ void *a_arg, int is_static)
{
ethernet_arp_ip4_key_t k;
- ethernet_arp_ip4_entry_t * e = 0;
- ethernet_arp_main_t * am = ðernet_arp_main;
- ethernet_arp_ip4_over_ethernet_address_t * a = a_arg;
- vlib_main_t * vm = vlib_get_main();
- ip4_main_t * im = &ip4_main;
- ip_lookup_main_t * lm = &im->lookup_main;
- int make_new_arp_cache_entry=1;
- uword * p;
+ ethernet_arp_ip4_entry_t *e = 0;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
+ vlib_main_t *vm = vlib_get_main ();
+ ip4_main_t *im = &ip4_main;
+ ip_lookup_main_t *lm = &im->lookup_main;
+ int make_new_arp_cache_entry = 1;
+ uword *p;
ip4_add_del_route_args_t args;
- ip_adjacency_t adj, * existing_adj;
- pending_resolution_t * pr, * mc;
-
+ ip_adjacency_t adj, *existing_adj;
+ pending_resolution_t *pr, *mc;
+
u32 next_index;
u32 adj_index;
- fib_index = (fib_index != (u32)~0)
+ fib_index = (fib_index != (u32) ~ 0)
? fib_index : im->fib_index_by_sw_if_index[sw_if_index];
k.sw_if_index = sw_if_index;
e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
/* Refuse to over-write static arp. */
- if (!is_static &&
- (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC))
+ if (!is_static && (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC))
return -2;
make_new_arp_cache_entry = 0;
}
/* Note: always install the route. It might have been deleted */
- memset(&adj, 0, sizeof(adj));
+ memset (&adj, 0, sizeof (adj));
adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE;
- adj.n_adj = 1; /* otherwise signature compare fails */
+ adj.n_adj = 1; /* otherwise signature compare fails */
- vnet_rewrite_for_sw_interface
- (vnm,
- VNET_L3_PACKET_TYPE_IP4,
- sw_if_index,
- ip4_rewrite_node.index,
- a->ethernet, /* destination address */
- &adj.rewrite_header,
- sizeof (adj.rewrite_data));
+ vnet_rewrite_for_sw_interface (vnm, VNET_L3_PACKET_TYPE_IP4, sw_if_index, ip4_rewrite_node.index, a->ethernet, /* destination address */
+ &adj.rewrite_header,
+ sizeof (adj.rewrite_data));
/* result of this lookup should be next-hop adjacency */
adj_index = ip4_fib_lookup_with_table (im, fib_index, &a->ip4, 0);
- existing_adj = ip_get_adjacency(lm, adj_index);
+ existing_adj = ip_get_adjacency (lm, adj_index);
if (existing_adj->lookup_next_index == IP_LOOKUP_NEXT_ARP &&
existing_adj->arp.next_hop.ip4.as_u32 == a->ip4.as_u32)
{
- u32 * ai;
- u32 * adjs = vec_dup(e->adjacencies);
+ u32 *ai;
+ u32 *adjs = vec_dup (e->adjacencies);
/* Update all adj assigned to this arp entry */
- vec_foreach(ai, adjs)
- {
- int i;
- ip_adjacency_t * uadj = ip_get_adjacency(lm, *ai);
- for (i = 0; i < uadj->n_adj; i++)
- if (uadj[i].lookup_next_index == IP_LOOKUP_NEXT_ARP &&
- uadj[i].arp.next_hop.ip4.as_u32 == a->ip4.as_u32)
- ip_update_adjacency (lm, *ai + i, &adj);
- }
- vec_free(adjs);
+ vec_foreach (ai, adjs)
+ {
+ int i;
+ ip_adjacency_t *uadj = ip_get_adjacency (lm, *ai);
+ for (i = 0; i < uadj->n_adj; i++)
+ if (uadj[i].lookup_next_index == IP_LOOKUP_NEXT_ARP &&
+ uadj[i].arp.next_hop.ip4.as_u32 == a->ip4.as_u32)
+ ip_update_adjacency (lm, *ai + i, &adj);
+ }
+ vec_free (adjs);
}
else
{
* exactly the same info, its technically a new adjacency with
* new counters, but to user it appears as counters reset.
*/
- if (vnet_ip_adjacency_share_compare (&adj, existing_adj) == 0) {
- /* create new adj */
- args.table_index_or_table_id = fib_index;
- args.flags = IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_ADD | IP4_ROUTE_FLAG_NEIGHBOR;
- args.dst_address = a->ip4;
- args.dst_address_length = 32;
- args.adj_index = ~0;
- args.add_adj = &adj;
- args.n_add_adj = 1;
- ip4_add_del_route (im, &args);
- }
+ if (vnet_ip_adjacency_share_compare (&adj, existing_adj) == 0)
+ {
+ /* create new adj */
+ args.table_index_or_table_id = fib_index;
+ args.flags =
+ IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_ADD |
+ IP4_ROUTE_FLAG_NEIGHBOR;
+ args.dst_address = a->ip4;
+ args.dst_address_length = 32;
+ args.adj_index = ~0;
+ args.add_adj = &adj;
+ args.n_add_adj = 1;
+ ip4_add_del_route (im, &args);
+ }
}
if (make_new_arp_cache_entry)
{
pool_get (am->ip4_entry_pool, e);
- mhash_set (&am->ip4_entry_by_key, &k,
- e - am->ip4_entry_pool,
- /* old value */ 0);
+ mhash_set (&am->ip4_entry_by_key, &k, e - am->ip4_entry_pool,
+ /* old value */ 0);
e->key = k;
}
/* Update time stamp and ethernet address. */
- clib_memcpy (e->ethernet_address, a->ethernet, sizeof (e->ethernet_address));
+ clib_memcpy (e->ethernet_address, a->ethernet,
+ sizeof (e->ethernet_address));
e->cpu_time_last_updated = clib_cpu_time_now ();
if (is_static)
e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC;
{
next_index = p[0];
- while (next_index != (u32)~0)
- {
- pr = pool_elt_at_index (am->pending_resolutions, next_index);
- vlib_process_signal_event (vm, pr->node_index,
- pr->type_opaque,
- pr->data);
- next_index = pr->next_index;
- pool_put (am->pending_resolutions, pr);
- }
-
+ while (next_index != (u32) ~ 0)
+ {
+ pr = pool_elt_at_index (am->pending_resolutions, next_index);
+ vlib_process_signal_event (vm, pr->node_index,
+ pr->type_opaque, pr->data);
+ next_index = pr->next_index;
+ pool_put (am->pending_resolutions, pr);
+ }
+
hash_unset (am->pending_resolutions_by_address, a->ip4.as_u32);
}
{
next_index = p[0];
- while (next_index != (u32)~0)
- {
- int (*fp)(u32, u8 *, u32, u32);
- int rv = 1;
- mc = pool_elt_at_index (am->mac_changes, next_index);
- fp = mc->data_callback;
-
- /* Call the user's data callback, return 1 to suppress dup events */
- if (fp)
- rv = (*fp)(mc->data, a->ethernet, sw_if_index, 0);
-
- /*
- * Signal the resolver process, as long as the user
- * says they want to be notified
- */
- if (rv == 0)
- vlib_process_signal_event (vm, mc->node_index,
- mc->type_opaque,
- mc->data);
- next_index = mc->next_index;
- }
+ while (next_index != (u32) ~ 0)
+ {
+ int (*fp) (u32, u8 *, u32, u32);
+ int rv = 1;
+ mc = pool_elt_at_index (am->mac_changes, next_index);
+ fp = mc->data_callback;
+
+ /* Call the user's data callback, return 1 to suppress dup events */
+ if (fp)
+ rv = (*fp) (mc->data, a->ethernet, sw_if_index, 0);
+
+ /*
+ * Signal the resolver process, as long as the user
+ * says they want to be notified
+ */
+ if (rv == 0)
+ vlib_process_signal_event (vm, mc->node_index,
+ mc->type_opaque, mc->data);
+ next_index = mc->next_index;
+ }
}
return 0;
}
-void vnet_register_ip4_arp_resolution_event (vnet_main_t * vnm,
- void * address_arg,
- uword node_index,
- uword type_opaque,
- uword data)
+void
+vnet_register_ip4_arp_resolution_event (vnet_main_t * vnm,
+ void *address_arg,
+ uword node_index,
+ uword type_opaque, uword data)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- ip4_address_t * address = address_arg;
- uword * p;
- pending_resolution_t * pr;
-
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ip4_address_t *address = address_arg;
+ uword *p;
+ pending_resolution_t *pr;
+
pool_get (am->pending_resolutions, pr);
pr->next_index = ~0;
pr->next_index = p[0];
hash_unset (am->pending_resolutions_by_address, address->as_u32);
}
-
- hash_set (am->pending_resolutions_by_address, address->as_u32,
- pr - am->pending_resolutions);
+
+ hash_set (am->pending_resolutions_by_address, address->as_u32,
+ pr - am->pending_resolutions);
}
-int vnet_add_del_ip4_arp_change_event (vnet_main_t * vnm,
- void * data_callback,
- u32 pid,
- void * address_arg,
- uword node_index,
- uword type_opaque,
- uword data, int is_add)
+int
+vnet_add_del_ip4_arp_change_event (vnet_main_t * vnm,
+ void *data_callback,
+ u32 pid,
+ void *address_arg,
+ uword node_index,
+ uword type_opaque, uword data, int is_add)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- ip4_address_t * address = address_arg;
- uword * p;
- pending_resolution_t * mc;
- void (*fp)(u32, u8 *) = data_callback;
-
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ip4_address_t *address = address_arg;
+ uword *p;
+ pending_resolution_t *mc;
+ void (*fp) (u32, u8 *) = data_callback;
+
if (is_add)
{
pool_get (am->mac_changes, mc);
mc->data = data;
mc->data_callback = data_callback;
mc->pid = pid;
-
+
p = hash_get (am->mac_changes_by_address, address->as_u32);
if (p)
- {
- /* Insert new resolution at the head of the list */
- mc->next_index = p[0];
- hash_unset (am->mac_changes_by_address, address->as_u32);
- }
-
- hash_set (am->mac_changes_by_address, address->as_u32,
- mc - am->mac_changes);
+ {
+ /* Insert new resolution at the head of the list */
+ mc->next_index = p[0];
+ hash_unset (am->mac_changes_by_address, address->as_u32);
+ }
+
+ hash_set (am->mac_changes_by_address, address->as_u32,
+ mc - am->mac_changes);
return 0;
}
else
{
u32 index;
- pending_resolution_t * mc_last = 0;
+ pending_resolution_t *mc_last = 0;
p = hash_get (am->mac_changes_by_address, address->as_u32);
if (p == 0)
- return VNET_API_ERROR_NO_SUCH_ENTRY;
+ return VNET_API_ERROR_NO_SUCH_ENTRY;
index = p[0];
- while (index != (u32)~0)
- {
- mc = pool_elt_at_index (am->mac_changes, index);
- if (mc->node_index == node_index &&
- mc->type_opaque == type_opaque &&
- mc->pid == pid)
- {
- /* Clients may need to clean up pool entries, too */
- if (fp)
- (*fp)(mc->data, 0 /* no new mac addrs */);
- if (index == p[0])
- {
- hash_unset (am->mac_changes_by_address, address->as_u32);
- if (mc->next_index != ~0)
- hash_set (am->mac_changes_by_address, address->as_u32,
- mc->next_index);
- pool_put (am->mac_changes, mc);
- return 0;
- }
- else
- {
- ASSERT(mc_last);
- mc_last->next_index = mc->next_index;
- pool_put (am->mac_changes, mc);
- return 0;
- }
- }
- mc_last = mc;
- index = mc->next_index;
- }
-
+ while (index != (u32) ~ 0)
+ {
+ mc = pool_elt_at_index (am->mac_changes, index);
+ if (mc->node_index == node_index &&
+ mc->type_opaque == type_opaque && mc->pid == pid)
+ {
+ /* Clients may need to clean up pool entries, too */
+ if (fp)
+ (*fp) (mc->data, 0 /* no new mac addrs */ );
+ if (index == p[0])
+ {
+ hash_unset (am->mac_changes_by_address, address->as_u32);
+ if (mc->next_index != ~0)
+ hash_set (am->mac_changes_by_address, address->as_u32,
+ mc->next_index);
+ pool_put (am->mac_changes, mc);
+ return 0;
+ }
+ else
+ {
+ ASSERT (mc_last);
+ mc_last->next_index = mc->next_index;
+ pool_put (am->mac_changes, mc);
+ return 0;
+ }
+ }
+ mc_last = mc;
+ index = mc->next_index;
+ }
+
return VNET_API_ERROR_NO_SUCH_ENTRY;
}
}
/* Either we drop the packet or we send a reply to the sender. */
-typedef enum {
+typedef enum
+{
ARP_INPUT_NEXT_DROP,
ARP_INPUT_NEXT_REPLY_TX,
ARP_INPUT_N_NEXT,
_ (missing_interface_address, "ARP missing interface address") \
_ (gratuitous_arp, "ARP probe or announcement dropped") \
-typedef enum {
+typedef enum
+{
#define _(sym,string) ETHERNET_ARP_ERROR_##sym,
foreach_ethernet_arp_error
#undef _
- ETHERNET_ARP_N_ERROR,
+ ETHERNET_ARP_N_ERROR,
} ethernet_arp_input_error_t;
/* get first interface address */
ip4_address_t *
ip4_interface_first_address (ip4_main_t * im, u32 sw_if_index,
- ip_interface_address_t ** result_ia)
+ ip_interface_address_t ** result_ia)
{
- ip_lookup_main_t * lm = &im->lookup_main;
- ip_interface_address_t * ia = 0;
- ip4_address_t * result = 0;
+ ip_lookup_main_t *lm = &im->lookup_main;
+ ip_interface_address_t *ia = 0;
+ ip4_address_t *result = 0;
- foreach_ip_interface_address (lm, ia, sw_if_index,
- 1 /* honor unnumbered */,
+ /* *INDENT-OFF* */
+ foreach_ip_interface_address (lm, ia, sw_if_index,
+ 1 /* honor unnumbered */ ,
({
- ip4_address_t * a = ip_interface_address_get_address (lm, ia);
- result = a;
- break;
+ ip4_address_t * a =
+ ip_interface_address_get_address (lm, ia);
+ result = a; break;
}));
+ /* *INDENT-ON* */
+
if (result_ia)
*result_ia = result ? ia : 0;
return result;
}
-static void unset_random_arp_entry (void)
+static void
+unset_random_arp_entry (void)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- ethernet_arp_ip4_entry_t * e;
- vnet_main_t * vnm = vnet_get_main();
- ethernet_arp_ip4_over_ethernet_address_t delme;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ethernet_arp_ip4_entry_t *e;
+ vnet_main_t *vnm = vnet_get_main ();
+ ethernet_arp_ip4_over_ethernet_address_t delme;
u32 index;
index = pool_next_index (am->ip4_entry_pool, am->arp_delete_rotor);
return;
e = pool_elt_at_index (am->ip4_entry_pool, index);
-
+
clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
delme.ip4.as_u32 = e->key.ip4_address.as_u32;
-
+
vnet_arp_unset_ip4_over_ethernet (vnm, e->key.sw_if_index,
- e->key.fib_index, &delme);
+ e->key.fib_index, &delme);
}
-
-static void arp_unnumbered (vlib_buffer_t * p0,
- u32 pi0,
- ethernet_header_t * eth0,
- ip_interface_address_t * ifa0)
+
+static void
+arp_unnumbered (vlib_buffer_t * p0,
+ u32 pi0,
+ ethernet_header_t * eth0, ip_interface_address_t * ifa0)
{
- vlib_main_t * vm = vlib_get_main();
- vnet_main_t * vnm = vnet_get_main();
- vnet_interface_main_t * vim = &vnm->interface_main;
- vnet_sw_interface_t * si;
- vnet_hw_interface_t * hi;
+ vlib_main_t *vm = vlib_get_main ();
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_interface_main_t *vim = &vnm->interface_main;
+ vnet_sw_interface_t *si;
+ vnet_hw_interface_t *hi;
u32 unnum_src_sw_if_index;
- u32 * broadcast_swifs = 0;
- u32 * buffers = 0;
+ u32 *broadcast_swifs = 0;
+ u32 *buffers = 0;
u32 n_alloc = 0;
- vlib_buffer_t * b0;
+ vlib_buffer_t *b0;
int i;
u8 dst_mac_address[6];
i16 header_size;
- ethernet_arp_header_t * arp0;
+ ethernet_arp_header_t *arp0;
/* Save the dst mac address */
- clib_memcpy(dst_mac_address, eth0->dst_address, sizeof (dst_mac_address));
+ clib_memcpy (dst_mac_address, eth0->dst_address, sizeof (dst_mac_address));
/* Figure out which sw_if_index supplied the address */
unnum_src_sw_if_index = ifa0->sw_if_index;
/* Track down all users of the unnumbered source */
- pool_foreach (si, vim->sw_interfaces,
+ /* *INDENT-OFF* */
+ pool_foreach (si, vim->sw_interfaces,
({
if (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED &&
- (si->unnumbered_sw_if_index == unnum_src_sw_if_index))
+ (si->unnumbered_sw_if_index == unnum_src_sw_if_index))
{
- vec_add1 (broadcast_swifs, si->sw_if_index);
+ vec_add1 (broadcast_swifs, si->sw_if_index);
}
}));
-
+ /* *INDENT-ON* */
- ASSERT (vec_len(broadcast_swifs));
+ ASSERT (vec_len (broadcast_swifs));
/* Allocate buffering if we need it */
- if (vec_len(broadcast_swifs) > 1)
+ if (vec_len (broadcast_swifs) > 1)
{
- vec_validate (buffers, vec_len(broadcast_swifs)-2);
- n_alloc = vlib_buffer_alloc (vm, buffers, vec_len(buffers));
+ vec_validate (buffers, vec_len (broadcast_swifs) - 2);
+ n_alloc = vlib_buffer_alloc (vm, buffers, vec_len (buffers));
_vec_len (buffers) = n_alloc;
for (i = 0; i < n_alloc; i++)
- {
- b0 = vlib_get_buffer (vm, buffers[i]);
-
- /* xerox (partially built) ARP pkt */
- clib_memcpy (b0->data, p0->data, p0->current_length + p0->current_data);
- b0->current_data = p0->current_data;
- b0->current_length = p0->current_length;
- vnet_buffer(b0)->sw_if_index[VLIB_RX] =
- vnet_buffer(p0)->sw_if_index[VLIB_RX];
- }
+ {
+ b0 = vlib_get_buffer (vm, buffers[i]);
+
+ /* xerox (partially built) ARP pkt */
+ clib_memcpy (b0->data, p0->data,
+ p0->current_length + p0->current_data);
+ b0->current_data = p0->current_data;
+ b0->current_length = p0->current_length;
+ vnet_buffer (b0)->sw_if_index[VLIB_RX] =
+ vnet_buffer (p0)->sw_if_index[VLIB_RX];
+ }
}
vec_insert (buffers, 1, 0);
buffers[0] = pi0;
-
- for (i = 0; i < vec_len(buffers); i++)
+
+ for (i = 0; i < vec_len (buffers); i++)
{
- b0 = vlib_get_buffer(vm, buffers[i]);
+ b0 = vlib_get_buffer (vm, buffers[i]);
arp0 = vlib_buffer_get_current (b0);
hi = vnet_get_sup_hw_interface (vnm, broadcast_swifs[i]);
si = vnet_get_sw_interface (vnm, broadcast_swifs[i]);
/* For decoration, most likely */
- vnet_buffer(b0)->sw_if_index[VLIB_TX] = hi->sw_if_index;
+ vnet_buffer (b0)->sw_if_index[VLIB_TX] = hi->sw_if_index;
/* Fix ARP pkt src address */
clib_memcpy (arp0->ip4_over_ethernet[0].ethernet, hi->hw_address, 6);
/* Build L2 encaps for this swif */
header_size = sizeof (ethernet_header_t);
- if (si->sub.eth.flags.one_tag)
- header_size += 4;
+ if (si->sub.eth.flags.one_tag)
+ header_size += 4;
else if (si->sub.eth.flags.two_tags)
- header_size += 8;
-
+ header_size += 8;
+
vlib_buffer_advance (b0, -header_size);
eth0 = vlib_buffer_get_current (b0);
- if (si->sub.eth.flags.one_tag) {
- ethernet_vlan_header_t * outer = (void *) (eth0 + 1);
-
- eth0->type = si->sub.eth.flags.dot1ad ?
- clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
- clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
- outer->priority_cfi_and_id =
- clib_host_to_net_u16 (si->sub.eth.outer_vlan_id);
- outer->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
-
- } else if (si->sub.eth.flags.two_tags) {
- ethernet_vlan_header_t * outer = (void *) (eth0 + 1);
- ethernet_vlan_header_t * inner = (void *) (outer + 1);
-
- eth0->type = si->sub.eth.flags.dot1ad ?
- clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
- clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
- outer->priority_cfi_and_id =
- clib_host_to_net_u16 (si->sub.eth.outer_vlan_id);
- outer->type = clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
- inner->priority_cfi_and_id =
- clib_host_to_net_u16 (si->sub.eth.inner_vlan_id);
- inner->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
-
- } else {
- eth0->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
- }
-
+ if (si->sub.eth.flags.one_tag)
+ {
+ ethernet_vlan_header_t *outer = (void *) (eth0 + 1);
+
+ eth0->type = si->sub.eth.flags.dot1ad ?
+ clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
+ clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
+ outer->priority_cfi_and_id =
+ clib_host_to_net_u16 (si->sub.eth.outer_vlan_id);
+ outer->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
+
+ }
+ else if (si->sub.eth.flags.two_tags)
+ {
+ ethernet_vlan_header_t *outer = (void *) (eth0 + 1);
+ ethernet_vlan_header_t *inner = (void *) (outer + 1);
+
+ eth0->type = si->sub.eth.flags.dot1ad ?
+ clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
+ clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
+ outer->priority_cfi_and_id =
+ clib_host_to_net_u16 (si->sub.eth.outer_vlan_id);
+ outer->type = clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
+ inner->priority_cfi_and_id =
+ clib_host_to_net_u16 (si->sub.eth.inner_vlan_id);
+ inner->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
+
+ }
+ else
+ {
+ eth0->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
+ }
+
/* Restore the original dst address, set src address */
- clib_memcpy (eth0->dst_address, dst_mac_address, sizeof (eth0->dst_address));
- clib_memcpy (eth0->src_address, hi->hw_address, sizeof (eth0->src_address));
-
+ clib_memcpy (eth0->dst_address, dst_mac_address,
+ sizeof (eth0->dst_address));
+ clib_memcpy (eth0->src_address, hi->hw_address,
+ sizeof (eth0->src_address));
+
/* Transmit replicas */
if (i > 0)
- {
- vlib_frame_t * f = vlib_get_frame_to_node (vm, hi->output_node_index);
- u32 * to_next = vlib_frame_vector_args (f);
- to_next[0] = buffers[i];
- f->n_vectors = 1;
- vlib_put_frame_to_node (vm, hi->output_node_index, f);
- }
+ {
+ vlib_frame_t *f =
+ vlib_get_frame_to_node (vm, hi->output_node_index);
+ u32 *to_next = vlib_frame_vector_args (f);
+ to_next[0] = buffers[i];
+ f->n_vectors = 1;
+ vlib_put_frame_to_node (vm, hi->output_node_index, f);
+ }
}
/* The regular path outputs the original pkt.. */
}
static uword
-arp_input (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+arp_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- vnet_main_t * vnm = vnet_get_main();
- ip4_main_t * im4 = &ip4_main;
- u32 n_left_from, next_index, * from, * to_next;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ vnet_main_t *vnm = vnet_get_main ();
+ ip4_main_t *im4 = &ip4_main;
+ u32 n_left_from, next_index, *from, *to_next;
u32 n_replies_sent = 0, n_proxy_arp_replies_sent = 0;
from = vlib_frame_vector_args (frame);
{
u32 n_left_to_next;
- vlib_get_next_frame (vm, node, next_index,
- to_next, n_left_to_next);
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
while (n_left_from > 0 && n_left_to_next > 0)
{
- vlib_buffer_t * p0;
- vnet_hw_interface_t * hw_if0;
- ethernet_arp_header_t * arp0;
- ethernet_header_t * eth0;
- ip_interface_address_t * ifa0;
- ip_adjacency_t * adj0;
- ip4_address_t * if_addr0;
- ip4_address_t proxy_src;
+ vlib_buffer_t *p0;
+ vnet_hw_interface_t *hw_if0;
+ ethernet_arp_header_t *arp0;
+ ethernet_header_t *eth0;
+ ip_interface_address_t *ifa0;
+ ip_adjacency_t *adj0;
+ ip4_address_t *if_addr0;
+ ip4_address_t proxy_src;
u32 pi0, error0, next0, sw_if_index0;
u8 is_request0, src_is_local0, dst_is_local0, is_unnum0;
- ethernet_proxy_arp_t * pa;
+ ethernet_proxy_arp_t *pa;
pi0 = from[0];
to_next[0] = pi0;
p0 = vlib_get_buffer (vm, pi0);
arp0 = vlib_buffer_get_current (p0);
- is_request0 = arp0->opcode
- == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request);
+ is_request0 = arp0->opcode
+ == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request);
error0 = ETHERNET_ARP_ERROR_replies_sent;
- error0 = (arp0->l2_type != clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
- ? ETHERNET_ARP_ERROR_l2_type_not_ethernet
- : error0);
- error0 = (arp0->l3_type != clib_net_to_host_u16 (ETHERNET_TYPE_IP4)
- ? ETHERNET_ARP_ERROR_l3_type_not_ip4
- : error0);
+ error0 =
+ (arp0->l2_type !=
+ clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet) ?
+ ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
+ error0 =
+ (arp0->l3_type !=
+ clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
+ ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
goto drop1;
/* Check that IP address is local and matches incoming interface. */
- if_addr0 = ip4_interface_address_matching_destination (im4,
- &arp0->ip4_over_ethernet[1].ip4,
- sw_if_index0,
- &ifa0);
- if (! if_addr0)
+ if_addr0 =
+ ip4_interface_address_matching_destination (im4,
+ &arp0->
+ ip4_over_ethernet[1].
+ ip4, sw_if_index0,
+ &ifa0);
+ if (!if_addr0)
{
error0 = ETHERNET_ARP_ERROR_l3_dst_address_not_local;
goto drop1;
}
- /* Honor unnumbered interface, if any */
- is_unnum0 = sw_if_index0 != ifa0->sw_if_index;
+ /* Honor unnumbered interface, if any */
+ is_unnum0 = sw_if_index0 != ifa0->sw_if_index;
/* Source must also be local to subnet of matching interface address. */
- if (! ip4_destination_matches_interface (im4, &arp0->ip4_over_ethernet[0].ip4, ifa0))
+ if (!ip4_destination_matches_interface
+ (im4, &arp0->ip4_over_ethernet[0].ip4, ifa0))
{
error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
goto drop1;
}
/* Reject requests/replies with our local interface address. */
- src_is_local0 = if_addr0->as_u32 == arp0->ip4_over_ethernet[0].ip4.as_u32;
+ src_is_local0 =
+ if_addr0->as_u32 == arp0->ip4_over_ethernet[0].ip4.as_u32;
if (src_is_local0)
{
error0 = ETHERNET_ARP_ERROR_l3_src_address_is_local;
goto drop1;
}
- dst_is_local0 = if_addr0->as_u32 == arp0->ip4_over_ethernet[1].ip4.as_u32;
+ dst_is_local0 =
+ if_addr0->as_u32 == arp0->ip4_over_ethernet[1].ip4.as_u32;
/* Fill in ethernet header. */
eth0 = ethernet_buffer_get_header (p0);
- /* Trash ARP packets whose ARP-level source addresses do not
- match their L2-frame-level source addresses */
- if (memcmp (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
- sizeof (eth0->src_address)))
- {
- error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
- goto drop2;
- }
+ /* Trash ARP packets whose ARP-level source addresses do not
+ match their L2-frame-level source addresses */
+ if (memcmp (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
+ sizeof (eth0->src_address)))
+ {
+ error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
+ goto drop2;
+ }
/* Learn or update sender's mapping only for requests or unicasts
that don't match local interface address. */
- if (ethernet_address_cast (eth0->dst_address) == ETHERNET_ADDRESS_UNICAST
- || is_request0)
- {
- if (am->limit_arp_cache_size &&
- pool_elts (am->ip4_entry_pool) >= am->limit_arp_cache_size)
- unset_random_arp_entry();
-
- vnet_arp_set_ip4_over_ethernet (vnm, sw_if_index0,
- (u32)~0 /* default fib */,
- &arp0->ip4_over_ethernet[0],
- 0 /* is_static */);
+ if (ethernet_address_cast (eth0->dst_address) ==
+ ETHERNET_ADDRESS_UNICAST || is_request0)
+ {
+ if (am->limit_arp_cache_size &&
+ pool_elts (am->ip4_entry_pool) >= am->limit_arp_cache_size)
+ unset_random_arp_entry ();
+
+ vnet_arp_set_ip4_over_ethernet (vnm, sw_if_index0,
+ (u32) ~ 0 /* default fib */ ,
+ &arp0->ip4_over_ethernet[0],
+ 0 /* is_static */ );
error0 = ETHERNET_ARP_ERROR_l3_src_address_learned;
- }
+ }
/* Only send a reply for requests sent which match a local interface. */
- if (! (is_request0 && dst_is_local0))
+ if (!(is_request0 && dst_is_local0))
{
- error0 = (arp0->opcode == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply)
- ? ETHERNET_ARP_ERROR_replies_received : error0);
+ error0 =
+ (arp0->opcode ==
+ clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply) ?
+ ETHERNET_ARP_ERROR_replies_received : error0);
goto drop1;
}
/* Send a reply. */
- send_reply:
+ send_reply:
vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
- clib_memcpy (arp0->ip4_over_ethernet[0].ethernet, hw_if0->hw_address, 6);
- clib_mem_unaligned (&arp0->ip4_over_ethernet[0].ip4.data_u32, u32) = if_addr0->data_u32;
+ clib_memcpy (arp0->ip4_over_ethernet[0].ethernet,
+ hw_if0->hw_address, 6);
+ clib_mem_unaligned (&arp0->ip4_over_ethernet[0].ip4.data_u32, u32) =
+ if_addr0->data_u32;
/* Hardware must be ethernet-like. */
ASSERT (vec_len (hw_if0->hw_address) == 6);
clib_memcpy (eth0->src_address, hw_if0->hw_address, 6);
/* Figure out how much to rewind current data from adjacency. */
- if (ifa0)
- {
- adj0 = ip_get_adjacency (&ip4_main.lookup_main,
- ifa0->neighbor_probe_adj_index);
- if (adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP)
- {
- error0 = ETHERNET_ARP_ERROR_missing_interface_address;
- goto drop2;
- }
- if (is_unnum0)
- arp_unnumbered (p0, pi0, eth0, ifa0);
- else
- vlib_buffer_advance (p0, -adj0->rewrite_header.data_bytes);
- }
-
- vlib_validate_buffer_enqueue_x1 (vm, node, next_index,to_next,
- n_left_to_next,pi0,next0);
+ if (ifa0)
+ {
+ adj0 = ip_get_adjacency (&ip4_main.lookup_main,
+ ifa0->neighbor_probe_adj_index);
+ if (adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP)
+ {
+ error0 = ETHERNET_ARP_ERROR_missing_interface_address;
+ goto drop2;
+ }
+ if (is_unnum0)
+ arp_unnumbered (p0, pi0, eth0, ifa0);
+ else
+ vlib_buffer_advance (p0, -adj0->rewrite_header.data_bytes);
+ }
+
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+ n_left_to_next, pi0, next0);
n_replies_sent += 1;
continue;
drop1:
- if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
- (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
- arp0->ip4_over_ethernet[1].ip4.as_u32))
- {
- error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
- goto drop2;
- }
- /* See if proxy arp is configured for the address */
- if (is_request0)
- {
- vnet_sw_interface_t * si;
- u32 this_addr = clib_net_to_host_u32
- (arp0->ip4_over_ethernet[1].ip4.as_u32);
- u32 fib_index0;
-
- si = vnet_get_sw_interface (vnm, sw_if_index0);
-
- if (!(si->flags & VNET_SW_INTERFACE_FLAG_PROXY_ARP))
- goto drop2;
-
- fib_index0 = vec_elt (im4->fib_index_by_sw_if_index,
- sw_if_index0);
-
- vec_foreach (pa, am->proxy_arps)
- {
- u32 lo_addr = clib_net_to_host_u32 (pa->lo_addr);
- u32 hi_addr = clib_net_to_host_u32 (pa->hi_addr);
-
- /* an ARP request hit in the proxy-arp table? */
- if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
- (fib_index0 == pa->fib_index))
- {
- eth0 = ethernet_buffer_get_header (p0);
- proxy_src.as_u32 =
- arp0->ip4_over_ethernet[1].ip4.data_u32;
-
- /*
- * Rewind buffer, direct code above not to
- * think too hard about it.
- * $$$ is the answer ever anything other than
- * vlib_buffer_reset(..)?
- */
- ifa0 = 0;
- if_addr0 = &proxy_src;
- vlib_buffer_reset (p0);
- n_proxy_arp_replies_sent++;
- goto send_reply;
- }
- }
- }
-
- drop2:
+ if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
+ (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
+ arp0->ip4_over_ethernet[1].ip4.as_u32))
+ {
+ error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
+ goto drop2;
+ }
+ /* See if proxy arp is configured for the address */
+ if (is_request0)
+ {
+ vnet_sw_interface_t *si;
+ u32 this_addr = clib_net_to_host_u32
+ (arp0->ip4_over_ethernet[1].ip4.as_u32);
+ u32 fib_index0;
+
+ si = vnet_get_sw_interface (vnm, sw_if_index0);
+
+ if (!(si->flags & VNET_SW_INTERFACE_FLAG_PROXY_ARP))
+ goto drop2;
+
+ fib_index0 = vec_elt (im4->fib_index_by_sw_if_index,
+ sw_if_index0);
+
+ vec_foreach (pa, am->proxy_arps)
+ {
+ u32 lo_addr = clib_net_to_host_u32 (pa->lo_addr);
+ u32 hi_addr = clib_net_to_host_u32 (pa->hi_addr);
+
+ /* an ARP request hit in the proxy-arp table? */
+ if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
+ (fib_index0 == pa->fib_index))
+ {
+ eth0 = ethernet_buffer_get_header (p0);
+ proxy_src.as_u32 =
+ arp0->ip4_over_ethernet[1].ip4.data_u32;
+
+ /*
+ * Rewind buffer, direct code above not to
+ * think too hard about it.
+ * $$$ is the answer ever anything other than
+ * vlib_buffer_reset(..)?
+ */
+ ifa0 = 0;
+ if_addr0 = &proxy_src;
+ vlib_buffer_reset (p0);
+ n_proxy_arp_replies_sent++;
+ goto send_reply;
+ }
+ }
+ }
+
+ drop2:
next0 = ARP_INPUT_NEXT_DROP;
p0->error = node->errors[error0];
- vlib_validate_buffer_enqueue_x1 (vm, node, next_index,to_next,
- n_left_to_next,pi0,next0);
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+ n_left_to_next, pi0, next0);
}
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
vlib_error_count (vm, node->node_index,
- ETHERNET_ARP_ERROR_replies_sent,
- n_replies_sent - n_proxy_arp_replies_sent);
-
+ ETHERNET_ARP_ERROR_replies_sent,
+ n_replies_sent - n_proxy_arp_replies_sent);
+
vlib_error_count (vm, node->node_index,
- ETHERNET_ARP_ERROR_proxy_arp_replies_sent,
- n_proxy_arp_replies_sent);
+ ETHERNET_ARP_ERROR_proxy_arp_replies_sent,
+ n_proxy_arp_replies_sent);
return frame->n_vectors;
}
-static char * ethernet_arp_error_strings[] = {
+static char *ethernet_arp_error_strings[] = {
#define _(sym,string) string,
foreach_ethernet_arp_error
#undef _
};
-VLIB_REGISTER_NODE (arp_input_node,static) = {
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (arp_input_node, static) =
+{
.function = arp_input,
.name = "arp-input",
.vector_size = sizeof (u32),
-
.n_errors = ETHERNET_ARP_N_ERROR,
.error_strings = ethernet_arp_error_strings,
-
.n_next_nodes = ARP_INPUT_N_NEXT,
.next_nodes = {
[ARP_INPUT_NEXT_DROP] = "error-drop",
[ARP_INPUT_NEXT_REPLY_TX] = "interface-output",
},
-
.format_buffer = format_ethernet_arp_header,
.format_trace = format_ethernet_arp_input_trace,
};
+/* *INDENT-ON* */
static int
ip4_arp_entry_sort (void *a1, void *a2)
{
- ethernet_arp_ip4_entry_t * e1 = a1;
- ethernet_arp_ip4_entry_t * e2 = a2;
+ ethernet_arp_ip4_entry_t *e1 = a1;
+ ethernet_arp_ip4_entry_t *e2 = a2;
int cmp;
- vnet_main_t * vnm = vnet_get_main();
+ vnet_main_t *vnm = vnet_get_main ();
- cmp = vnet_sw_interface_compare
+ cmp = vnet_sw_interface_compare
(vnm, e1->key.sw_if_index, e2->key.sw_if_index);
- if (! cmp)
+ if (!cmp)
cmp = ip4_address_compare (&e1->key.ip4_address, &e2->key.ip4_address);
return cmp;
}
static clib_error_t *
show_ip4_arp (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- vnet_main_t * vnm = vnet_get_main();
- ethernet_arp_main_t * am = ðernet_arp_main;
- ethernet_arp_ip4_entry_t * e, * es;
- ethernet_proxy_arp_t * pa;
- clib_error_t * error = 0;
+ vnet_main_t *vnm = vnet_get_main ();
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ethernet_arp_ip4_entry_t *e, *es;
+ ethernet_proxy_arp_t *pa;
+ clib_error_t *error = 0;
u32 sw_if_index;
/* Filter entries by interface if given. */
(void) unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index);
es = 0;
- pool_foreach (e, am->ip4_entry_pool, ({ vec_add1 (es, e[0]); }));
- if ( es )
+ /* *INDENT-OFF* */
+ pool_foreach (e, am->ip4_entry_pool,
+ ({
+ vec_add1 (es, e[0]);
+ }));
+ /* *INDENT-ON* */
+
+ if (es)
{
vec_sort_with_function (es, ip4_arp_entry_sort);
vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, 0);
- vec_foreach (e, es) {
- if (sw_if_index != ~0 && e->key.sw_if_index != sw_if_index)
- continue;
- vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, e);
+ vec_foreach (e, es)
+ {
+ if (sw_if_index != ~0 && e->key.sw_if_index != sw_if_index)
+ continue;
+ vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, e);
}
vec_free (es);
}
if (vec_len (am->proxy_arps))
{
vlib_cli_output (vm, "Proxy arps enabled for:");
- vec_foreach(pa, am->proxy_arps)
- {
- vlib_cli_output (vm, "Fib_index %d %U - %U ",
- pa->fib_index,
- format_ip4_address, &pa->lo_addr,
- format_ip4_address, &pa->hi_addr);
- }
+ vec_foreach (pa, am->proxy_arps)
+ {
+ vlib_cli_output (vm, "Fib_index %d %U - %U ",
+ pa->fib_index,
+ format_ip4_address, &pa->lo_addr,
+ format_ip4_address, &pa->hi_addr);
+ }
}
-
+
return error;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_ip4_arp_command, static) = {
.path = "show ip arp",
.function = show_ip4_arp,
.short_help = "Show ARP table",
};
+/* *INDENT-ON* */
-typedef struct {
+typedef struct
+{
pg_edit_t l2_type, l3_type;
pg_edit_t n_l2_address_bytes, n_l3_address_bytes;
pg_edit_t opcode;
- struct {
+ struct
+ {
pg_edit_t ethernet;
pg_edit_t ip4;
} ip4_over_ethernet[2];
{
/* Initialize fields that are not bit fields in the IP header. */
#define _(f) pg_edit_init (&p->f, ethernet_arp_header_t, f);
- _ (l2_type);
- _ (l3_type);
- _ (n_l2_address_bytes);
- _ (n_l3_address_bytes);
- _ (opcode);
- _ (ip4_over_ethernet[0].ethernet);
- _ (ip4_over_ethernet[0].ip4);
- _ (ip4_over_ethernet[1].ethernet);
- _ (ip4_over_ethernet[1].ip4);
+ _(l2_type);
+ _(l3_type);
+ _(n_l2_address_bytes);
+ _(n_l3_address_bytes);
+ _(opcode);
+ _(ip4_over_ethernet[0].ethernet);
+ _(ip4_over_ethernet[0].ip4);
+ _(ip4_over_ethernet[1].ethernet);
+ _(ip4_over_ethernet[1].ip4);
#undef _
}
uword
unformat_pg_arp_header (unformat_input_t * input, va_list * args)
{
- pg_stream_t * s = va_arg (*args, pg_stream_t *);
- pg_ethernet_arp_header_t * p;
+ pg_stream_t *s = va_arg (*args, pg_stream_t *);
+ pg_ethernet_arp_header_t *p;
u32 group_index;
-
+
p = pg_create_edit_group (s, sizeof (p[0]), sizeof (ethernet_arp_header_t),
&group_index);
pg_ethernet_arp_header_init (p);
pg_edit_set_fixed (&p->n_l2_address_bytes, 6);
pg_edit_set_fixed (&p->n_l3_address_bytes, 4);
- if (! unformat (input, "%U: %U/%U -> %U/%U",
- unformat_pg_edit,
- unformat_ethernet_arp_opcode_net_byte_order, &p->opcode,
- unformat_pg_edit,
- unformat_ethernet_address, &p->ip4_over_ethernet[0].ethernet,
- unformat_pg_edit,
- unformat_ip4_address, &p->ip4_over_ethernet[0].ip4,
- unformat_pg_edit,
- unformat_ethernet_address, &p->ip4_over_ethernet[1].ethernet,
- unformat_pg_edit,
- unformat_ip4_address, &p->ip4_over_ethernet[1].ip4))
+ if (!unformat (input, "%U: %U/%U -> %U/%U",
+ unformat_pg_edit,
+ unformat_ethernet_arp_opcode_net_byte_order, &p->opcode,
+ unformat_pg_edit,
+ unformat_ethernet_address, &p->ip4_over_ethernet[0].ethernet,
+ unformat_pg_edit,
+ unformat_ip4_address, &p->ip4_over_ethernet[0].ip4,
+ unformat_pg_edit,
+ unformat_ethernet_address, &p->ip4_over_ethernet[1].ethernet,
+ unformat_pg_edit,
+ unformat_ip4_address, &p->ip4_over_ethernet[1].ip4))
{
/* Free up any edits we may have added. */
pg_free_edit_group (s);
return 1;
}
-clib_error_t *ip4_set_arp_limit (u32 arp_limit)
+clib_error_t *
+ip4_set_arp_limit (u32 arp_limit)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
+ ethernet_arp_main_t *am = ðernet_arp_main;
am->limit_arp_cache_size = arp_limit;
return 0;
}
static void
-arp_ip4_entry_del_adj(ethernet_arp_ip4_entry_t *e, u32 adj_index)
+arp_ip4_entry_del_adj (ethernet_arp_ip4_entry_t * e, u32 adj_index)
{
int done = 0;
int i;
while (!done)
{
- vec_foreach_index(i, e->adjacencies)
- if (vec_elt(e->adjacencies, i) == adj_index)
- {
- vec_del1(e->adjacencies, i);
- continue;
- }
+ vec_foreach_index (i, e->adjacencies)
+ if (vec_elt (e->adjacencies, i) == adj_index)
+ {
+ vec_del1 (e->adjacencies, i);
+ continue;
+ }
done = 1;
}
}
static void
-arp_ip4_entry_add_adj(ethernet_arp_ip4_entry_t *e, u32 adj_index)
+arp_ip4_entry_add_adj (ethernet_arp_ip4_entry_t * e, u32 adj_index)
{
int i;
- vec_foreach_index(i, e->adjacencies)
- if (vec_elt(e->adjacencies, i) == adj_index)
- return;
- vec_add1(e->adjacencies, adj_index);
+ vec_foreach_index (i, e->adjacencies)
+ if (vec_elt (e->adjacencies, i) == adj_index)
+ return;
+ vec_add1 (e->adjacencies, adj_index);
}
static void
-arp_add_del_adj_cb (struct ip_lookup_main_t * lm,
- u32 adj_index,
- ip_adjacency_t * adj,
- u32 is_del)
+arp_add_del_adj_cb (struct ip_lookup_main_t *lm,
+ u32 adj_index, ip_adjacency_t * adj, u32 is_del)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- ip4_main_t * im = &ip4_main;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ip4_main_t *im = &ip4_main;
ethernet_arp_ip4_key_t k;
- ethernet_arp_ip4_entry_t * e = 0;
- uword * p;
+ ethernet_arp_ip4_entry_t *e = 0;
+ uword *p;
u32 ai;
- for(ai = adj->heap_handle; ai < adj->heap_handle + adj->n_adj ; ai++)
+ for (ai = adj->heap_handle; ai < adj->heap_handle + adj->n_adj; ai++)
{
adj = ip_get_adjacency (lm, ai);
- if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP && adj->arp.next_hop.ip4.as_u32)
+ if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP
+ && adj->arp.next_hop.ip4.as_u32)
{
k.sw_if_index = adj->rewrite_header.sw_if_index;
k.ip4_address.as_u32 = adj->arp.next_hop.ip4.as_u32;
- k.fib_index = im->fib_index_by_sw_if_index[adj->rewrite_header.sw_if_index];
+ k.fib_index =
+ im->fib_index_by_sw_if_index[adj->rewrite_header.sw_if_index];
p = mhash_get (&am->ip4_entry_by_key, &k);
if (p)
e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
if (is_del)
{
if (!e)
- clib_warning("Adjacency contains unknown ARP next hop %U (del)",
- format_ip46_address, &adj->arp.next_hop, IP46_TYPE_IP4);
+ clib_warning ("Adjacency contains unknown ARP next hop %U (del)",
+ format_ip46_address, &adj->arp.next_hop,
+ IP46_TYPE_IP4);
else
- arp_ip4_entry_del_adj(e, adj->heap_handle);
+ arp_ip4_entry_del_adj (e, adj->heap_handle);
}
- else /* add */
+ else /* add */
{
if (!e)
- clib_warning("Adjacency contains unknown ARP next hop %U (add)",
- format_ip46_address, &adj->arp.next_hop, IP46_TYPE_IP4);
+ clib_warning ("Adjacency contains unknown ARP next hop %U (add)",
+ format_ip46_address, &adj->arp.next_hop,
+ IP46_TYPE_IP4);
else
- arp_ip4_entry_add_adj(e, adj->heap_handle);
+ arp_ip4_entry_add_adj (e, adj->heap_handle);
}
}
}
-static clib_error_t * ethernet_arp_init (vlib_main_t * vm)
+static clib_error_t *
+ethernet_arp_init (vlib_main_t * vm)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- pg_node_t * pn;
- clib_error_t * error;
- ip4_main_t * im = &ip4_main;
- ip_lookup_main_t * lm = &im->lookup_main;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ pg_node_t *pn;
+ clib_error_t *error;
+ ip4_main_t *im = &ip4_main;
+ ip_lookup_main_t *lm = &im->lookup_main;
if ((error = vlib_call_init_function (vm, ethernet_init)))
return error;
/* don't trace ARP error packets */
{
- vlib_node_runtime_t *rt =
+ vlib_node_runtime_t *rt =
vlib_node_get_runtime (vm, arp_input_node.index);
#define _(a,b) \
#undef _
}
- ip_register_add_del_adjacency_callback(lm, arp_add_del_adj_cb);
+ ip_register_add_del_adjacency_callback (lm, arp_add_del_adj_cb);
return 0;
}
VLIB_INIT_FUNCTION (ethernet_arp_init);
-int
+int
vnet_arp_unset_ip4_over_ethernet (vnet_main_t * vnm,
- u32 sw_if_index, u32 fib_index,
- void * a_arg)
+ u32 sw_if_index, u32 fib_index, void *a_arg)
{
- ethernet_arp_ip4_over_ethernet_address_t * a = a_arg;
+ ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
args.sw_if_index = sw_if_index;
args.is_remove = 1;
clib_memcpy (&args.a, a, sizeof (*a));
- vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
- (u8 *) &args, sizeof (args));
+ vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
+ (u8 *) & args, sizeof (args));
return 0;
}
-static inline int
+static inline int
vnet_arp_unset_ip4_over_ethernet_internal (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 fib_index,
- void * a_arg)
+ u32 sw_if_index,
+ u32 fib_index, void *a_arg)
{
- ethernet_arp_ip4_entry_t * e;
- ethernet_arp_main_t * am = ðernet_arp_main;
- ethernet_arp_ip4_over_ethernet_address_t * a = a_arg;
+ ethernet_arp_ip4_entry_t *e;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
ethernet_arp_ip4_key_t k;
- uword * p;
+ uword *p;
ip4_add_del_route_args_t args;
- ip4_main_t * im = &ip4_main;
- ip_lookup_main_t * lm = &im->lookup_main;
+ ip4_main_t *im = &ip4_main;
+ ip_lookup_main_t *lm = &im->lookup_main;
u32 adj_index;
- ip_adjacency_t * adj;
+ ip_adjacency_t *adj;
k.sw_if_index = sw_if_index;
k.ip4_address = a->ip4;
k.fib_index = fib_index;
p = mhash_get (&am->ip4_entry_by_key, &k);
- if (! p)
+ if (!p)
return -1;
- memset(&args, 0, sizeof(args));
+ memset (&args, 0, sizeof (args));
/*
* Make sure that the route actually exists before we try to delete it,
* See also ip4_del_interface_routes (...)
* -> ip4_delete_matching_routes (...).
*/
-
- adj_index = ip4_fib_lookup_with_table
- (im, fib_index, &a->ip4, 1 /* disable default route */);
+
+ adj_index = ip4_fib_lookup_with_table
+ (im, fib_index, &a->ip4, 1 /* disable default route */ );
/* Miss adj? Forget it... */
- if (adj_index != lm->miss_adj_index) {
+ if (adj_index != lm->miss_adj_index)
+ {
adj = ip_get_adjacency (lm, adj_index);
/*
* Stupid control-plane trick:
* then remove the arp cache entry (yuck). When that happens,
* the adj we find here will be the interface subnet ARP adj.
*/
- if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE) {
- args.table_index_or_table_id = fib_index;
- args.flags = IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_DEL
- | IP4_ROUTE_FLAG_NEIGHBOR;
- args.dst_address = a->ip4;
- args.dst_address_length = 32;
- ip4_add_del_route (im, &args);
- ip4_maybe_remap_adjacencies (im, fib_index, args.flags);
- }
- }
+ if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE)
+ {
+ args.table_index_or_table_id = fib_index;
+ args.flags = IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_DEL
+ | IP4_ROUTE_FLAG_NEIGHBOR;
+ args.dst_address = a->ip4;
+ args.dst_address_length = 32;
+ ip4_add_del_route (im, &args);
+ ip4_maybe_remap_adjacencies (im, fib_index, args.flags);
+ }
+ }
e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
mhash_unset (&am->ip4_entry_by_key, &e->key, 0);
return 0;
}
-static void
-increment_ip4_and_mac_address (ethernet_arp_ip4_over_ethernet_address_t *a)
+static void
+increment_ip4_and_mac_address (ethernet_arp_ip4_over_ethernet_address_t * a)
{
u8 old;
int i;
- for (i = 3; i >= 0; i--)
+ for (i = 3; i >= 0; i--)
{
old = a->ip4.as_u8[i];
a->ip4.as_u8[i] += 1;
if (old < a->ip4.as_u8[i])
- break;
+ break;
}
for (i = 5; i >= 0; i--)
old = a->ethernet[i];
a->ethernet[i] += 1;
if (old < a->ethernet[i])
- break;
+ break;
}
}
-int vnet_proxy_arp_add_del (ip4_address_t *lo_addr,
- ip4_address_t *hi_addr,
- u32 fib_index, int is_del)
+int
+vnet_proxy_arp_add_del (ip4_address_t * lo_addr,
+ ip4_address_t * hi_addr, u32 fib_index, int is_del)
{
ethernet_arp_main_t *am = ðernet_arp_main;
ethernet_proxy_arp_t *pa;
u32 found_at_index = ~0;
vec_foreach (pa, am->proxy_arps)
- {
- if (pa->lo_addr == lo_addr->as_u32
- && pa->hi_addr == hi_addr->as_u32
- && pa->fib_index == fib_index)
- {
- found_at_index = pa - am->proxy_arps;
- break;
- }
- }
+ {
+ if (pa->lo_addr == lo_addr->as_u32
+ && pa->hi_addr == hi_addr->as_u32 && pa->fib_index == fib_index)
+ {
+ found_at_index = pa - am->proxy_arps;
+ break;
+ }
+ }
if (found_at_index != ~0)
{
/* Delete, otherwise it's already in the table */
if (is_del)
- vec_delete (am->proxy_arps, 1, found_at_index);
+ vec_delete (am->proxy_arps, 1, found_at_index);
return 0;
}
/* delete, no such entry */
* Remove any proxy arp entries asdociated with the
* specificed fib.
*/
-int vnet_proxy_arp_fib_reset (u32 fib_id)
+int
+vnet_proxy_arp_fib_reset (u32 fib_id)
{
- ip4_main_t * im = &ip4_main;
+ ip4_main_t *im = &ip4_main;
ethernet_arp_main_t *am = ðernet_arp_main;
ethernet_proxy_arp_t *pa;
- u32 * entries_to_delete = 0;
+ u32 *entries_to_delete = 0;
u32 fib_index;
- uword * p;
+ uword *p;
int i;
p = hash_get (im->fib_index_by_table_id, fib_id);
- if (! p)
- return VNET_API_ERROR_NO_SUCH_ENTRY;
+ if (!p)
+ return VNET_API_ERROR_NO_SUCH_ENTRY;
fib_index = p[0];
vec_foreach (pa, am->proxy_arps)
- {
- if (pa->fib_index == fib_index)
- {
- vec_add1 (entries_to_delete, pa - am->proxy_arps);
- }
- }
+ {
+ if (pa->fib_index == fib_index)
+ {
+ vec_add1 (entries_to_delete, pa - am->proxy_arps);
+ }
+ }
- for (i = 0; i < vec_len(entries_to_delete); i++)
+ for (i = 0; i < vec_len (entries_to_delete); i++)
{
- vec_delete (am->proxy_arps, 1, entries_to_delete[i]);
- }
+ vec_delete (am->proxy_arps, 1, entries_to_delete[i]);
+ }
vec_free (entries_to_delete);
- return 0;
+ return 0;
}
u32
-vnet_arp_glean_add(u32 fib_index, void * next_hop_arg)
+vnet_arp_glean_add (u32 fib_index, void *next_hop_arg)
{
- ethernet_arp_main_t * am = ðernet_arp_main;
- ip4_main_t * im = &ip4_main;
- ip_lookup_main_t * lm = &im->lookup_main;
- ip4_address_t * next_hop = next_hop_arg;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ ip4_main_t *im = &ip4_main;
+ ip_lookup_main_t *lm = &im->lookup_main;
+ ip4_address_t *next_hop = next_hop_arg;
ip_adjacency_t add_adj, *adj;
ip4_add_del_route_args_t args;
- ethernet_arp_ip4_entry_t * e;
+ ethernet_arp_ip4_entry_t *e;
ethernet_arp_ip4_key_t k;
u32 adj_index;
- adj_index = ip4_fib_lookup_with_table(im, fib_index, next_hop, 0);
- adj = ip_get_adjacency(lm, adj_index);
+ adj_index = ip4_fib_lookup_with_table (im, fib_index, next_hop, 0);
+ adj = ip_get_adjacency (lm, adj_index);
if (!adj || adj->lookup_next_index != IP_LOOKUP_NEXT_ARP)
return ~0;
return adj_index;
pool_get (am->ip4_entry_pool, e);
- mhash_set (&am->ip4_entry_by_key, &k, e - am->ip4_entry_pool, /* old value */ 0);
+ mhash_set (&am->ip4_entry_by_key, &k, e - am->ip4_entry_pool,
+ /* old value */ 0);
e->key = k;
e->cpu_time_last_updated = clib_cpu_time_now ();
e->flags = ETHERNET_ARP_IP4_ENTRY_FLAG_GLEAN;
- memset(&args, 0, sizeof(args));
- clib_memcpy(&add_adj, adj, sizeof(add_adj));
- ip46_address_set_ip4(&add_adj.arp.next_hop, next_hop); /* install neighbor /32 route */
+ memset (&args, 0, sizeof (args));
+ clib_memcpy (&add_adj, adj, sizeof (add_adj));
+ ip46_address_set_ip4 (&add_adj.arp.next_hop, next_hop); /* install neighbor /32 route */
args.table_index_or_table_id = fib_index;
- args.flags = IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_ADD| IP4_ROUTE_FLAG_NEIGHBOR;
+ args.flags =
+ IP4_ROUTE_FLAG_FIB_INDEX | IP4_ROUTE_FLAG_ADD | IP4_ROUTE_FLAG_NEIGHBOR;
args.dst_address.as_u32 = next_hop->as_u32;
args.dst_address_length = 32;
args.adj_index = ~0;
static clib_error_t *
ip_arp_add_del_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- vnet_main_t * vnm = vnet_get_main();
+ vnet_main_t *vnm = vnet_get_main ();
u32 sw_if_index;
ethernet_arp_ip4_over_ethernet_address_t lo_addr, hi_addr, addr;
int addr_valid = 0;
int is_static = 0;
int is_proxy = 0;
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
/* set ip arp TenGigE1/1/0/1 1.2.3.4 aa:bb:... or aabb.ccdd... */
if (unformat (input, "%U %U %U",
- unformat_vnet_sw_interface, vnm, &sw_if_index,
- unformat_ip4_address, &addr.ip4,
- unformat_ethernet_address, &addr.ethernet))
- addr_valid = 1;
+ unformat_vnet_sw_interface, vnm, &sw_if_index,
+ unformat_ip4_address, &addr.ip4,
+ unformat_ethernet_address, &addr.ethernet))
+ addr_valid = 1;
else if (unformat (input, "delete") || unformat (input, "del"))
- is_del = 1;
+ is_del = 1;
else if (unformat (input, "static"))
- is_static = 1;
+ is_static = 1;
else if (unformat (input, "count %d", &count))
- ;
+ ;
else if (unformat (input, "fib-id %d", &fib_id))
- {
- ip4_main_t * im = &ip4_main;
- uword * p = hash_get (im->fib_index_by_table_id, fib_id);
- if (! p)
- return clib_error_return (0, "fib ID %d doesn't exist\n",
- fib_id);
- fib_index = p[0];
- }
-
- else if (unformat (input, "proxy %U - %U",
- unformat_ip4_address, &lo_addr.ip4,
- unformat_ip4_address, &hi_addr.ip4))
- is_proxy = 1;
+ {
+ ip4_main_t *im = &ip4_main;
+ uword *p = hash_get (im->fib_index_by_table_id, fib_id);
+ if (!p)
+ return clib_error_return (0, "fib ID %d doesn't exist\n", fib_id);
+ fib_index = p[0];
+ }
+
+ else if (unformat (input, "proxy %U - %U",
+ unformat_ip4_address, &lo_addr.ip4,
+ unformat_ip4_address, &hi_addr.ip4))
+ is_proxy = 1;
else
- break;
+ break;
}
-
+
if (is_proxy)
{
- (void) vnet_proxy_arp_add_del (&lo_addr.ip4, &hi_addr.ip4,
- fib_index, is_del);
+ (void) vnet_proxy_arp_add_del (&lo_addr.ip4, &hi_addr.ip4,
+ fib_index, is_del);
return 0;
}
- if (addr_valid)
+ if (addr_valid)
{
int i;
- for (i = 0; i < count; i++)
- {
- if (is_del == 0)
- {
- uword event_type, * event_data = 0;
-
- /* Park the debug CLI until the arp entry is installed */
- vnet_register_ip4_arp_resolution_event
- (vnm, &addr.ip4, vlib_current_process(vm),
- 1 /* type */, 0 /* data */);
-
- vnet_arp_set_ip4_over_ethernet
- (vnm, sw_if_index, fib_index, &addr, is_static);
-
- vlib_process_wait_for_event (vm);
- event_type = vlib_process_get_events (vm, &event_data);
- vec_reset_length(event_data);
- if (event_type != 1)
- clib_warning ("event type %d unexpected", event_type);
- }
- else
- vnet_arp_unset_ip4_over_ethernet
- (vnm, sw_if_index, fib_index, &addr);
-
- increment_ip4_and_mac_address (&addr);
- }
+ for (i = 0; i < count; i++)
+ {
+ if (is_del == 0)
+ {
+ uword event_type, *event_data = 0;
+
+ /* Park the debug CLI until the arp entry is installed */
+ vnet_register_ip4_arp_resolution_event
+ (vnm, &addr.ip4, vlib_current_process (vm),
+ 1 /* type */ , 0 /* data */ );
+
+ vnet_arp_set_ip4_over_ethernet
+ (vnm, sw_if_index, fib_index, &addr, is_static);
+
+ vlib_process_wait_for_event (vm);
+ event_type = vlib_process_get_events (vm, &event_data);
+ vec_reset_length (event_data);
+ if (event_type != 1)
+ clib_warning ("event type %d unexpected", event_type);
+ }
+ else
+ vnet_arp_unset_ip4_over_ethernet
+ (vnm, sw_if_index, fib_index, &addr);
+
+ increment_ip4_and_mac_address (&addr);
+ }
}
else
{
return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
+ format_unformat_error, input);
}
-
+
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (ip_arp_add_del_command, static) = {
- .path = "set ip arp",
- .short_help = "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
- .function = ip_arp_add_del_command_fn,
+ .path = "set ip arp",
+ .short_help =
+ "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
+ .function = ip_arp_add_del_command_fn,
};
+/* *INDENT-ON* */
static clib_error_t *
set_int_proxy_arp_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
{
- vnet_main_t * vnm = vnet_get_main();
+ vnet_main_t *vnm = vnet_get_main ();
u32 sw_if_index;
- vnet_sw_interface_t * si;
+ vnet_sw_interface_t *si;
int enable = 0;
int intfc_set = 0;
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (input, "%U", unformat_vnet_sw_interface,
- vnm, &sw_if_index))
- intfc_set = 1;
+ if (unformat (input, "%U", unformat_vnet_sw_interface,
+ vnm, &sw_if_index))
+ intfc_set = 1;
else if (unformat (input, "enable") || unformat (input, "on"))
- enable = 1;
+ enable = 1;
else if (unformat (input, "disable") || unformat (input, "off"))
- enable = 0;
+ enable = 0;
else
- break;
+ break;
}
if (intfc_set == 0)
return clib_error_return (0, "unknown input '%U'",
- format_unformat_error, input);
+ format_unformat_error, input);
si = vnet_get_sw_interface (vnm, sw_if_index);
- ASSERT(si);
+ ASSERT (si);
if (enable)
si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP;
- else
+ else
si->flags &= ~VNET_SW_INTERFACE_FLAG_PROXY_ARP;
-
+
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (set_int_proxy_enable_command, static) = {
- .path = "set interface proxy-arp",
- .short_help = "set interface proxy-arp <intfc> [enable|disable]",
- .function = set_int_proxy_arp_command_fn,
+ .path = "set interface proxy-arp",
+ .short_help =
+ "set interface proxy-arp <intfc> [enable|disable]",
+ .function = set_int_proxy_arp_command_fn,
};
+/* *INDENT-ON* */
/*
* ARP Termination in a L2 Bridge Domain based on an
* IP4 to MAC hash table mac_by_ip4 for each BD.
*/
-typedef enum {
+typedef enum
+{
ARP_TERM_NEXT_L2_OUTPUT,
ARP_TERM_NEXT_DROP,
ARP_TERM_N_NEXT,
static uword
arp_term_l2bd (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- l2input_main_t * l2im = &l2input_main;
- u32 n_left_from, next_index, * from, * to_next;
+ l2input_main_t *l2im = &l2input_main;
+ u32 n_left_from, next_index, *from, *to_next;
u32 n_replies_sent = 0;
u16 last_bd_index = ~0;
- l2_bridge_domain_t * last_bd_config = 0;
- l2_input_config_t * cfg0;
+ l2_bridge_domain_t *last_bd_config = 0;
+ l2_input_config_t *cfg0;
from = vlib_frame_vector_args (frame);
n_left_from = frame->n_vectors;
{
u32 n_left_to_next;
- vlib_get_next_frame (vm, node, next_index,
- to_next, n_left_to_next);
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
while (n_left_from > 0 && n_left_to_next > 0)
{
- vlib_buffer_t * p0;
- ethernet_header_t * eth0;
- ethernet_arp_header_t * arp0;
- u8 * l3h0;
+ vlib_buffer_t *p0;
+ ethernet_header_t *eth0;
+ ethernet_arp_header_t *arp0;
+ u8 *l3h0;
u32 pi0, error0, next0, sw_if_index0;
u16 ethertype0;
u16 bd_index0;
u32 ip0;
- u8 * macp0;
+ u8 *macp0;
pi0 = from[0];
to_next[0] = pi0;
p0 = vlib_get_buffer (vm, pi0);
eth0 = vlib_buffer_get_current (p0);
- l3h0 = (u8 *)eth0 + vnet_buffer(p0)->l2.l2_len;
- ethertype0 = clib_net_to_host_u16(*(u16 *)(l3h0 - 2));
+ l3h0 = (u8 *) eth0 + vnet_buffer (p0)->l2.l2_len;
+ ethertype0 = clib_net_to_host_u16 (*(u16 *) (l3h0 - 2));
arp0 = (ethernet_arp_header_t *) l3h0;
if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
(p0->flags & VLIB_BUFFER_IS_TRACED)))
{
- u8 *t0 = vlib_add_trace (
- vm, node, p0, sizeof(ethernet_arp_input_trace_t));
- clib_memcpy (t0, l3h0, sizeof(ethernet_arp_input_trace_t));
+ u8 *t0 = vlib_add_trace (vm, node, p0,
+ sizeof (ethernet_arp_input_trace_t));
+ clib_memcpy (t0, l3h0, sizeof (ethernet_arp_input_trace_t));
}
- if (PREDICT_FALSE (
- (ethertype0 != ETHERNET_TYPE_ARP) ||
- (arp0->opcode != clib_host_to_net_u16(ETHERNET_ARP_OPCODE_request))))
+ if (PREDICT_FALSE ((ethertype0 != ETHERNET_TYPE_ARP) ||
+ (arp0->opcode !=
+ clib_host_to_net_u16
+ (ETHERNET_ARP_OPCODE_request))))
goto next_l2_feature;
error0 = ETHERNET_ARP_ERROR_replies_sent;
- error0 = (arp0->l2_type != clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
- ? ETHERNET_ARP_ERROR_l2_type_not_ethernet
- : error0);
- error0 = (arp0->l3_type != clib_net_to_host_u16 (ETHERNET_TYPE_IP4)
- ? ETHERNET_ARP_ERROR_l3_type_not_ip4
- : error0);
+ error0 =
+ (arp0->l2_type !=
+ clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet) ?
+ ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
+ error0 =
+ (arp0->l3_type !=
+ clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
+ ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
if (error0)
goto drop;
- // Trash ARP packets whose ARP-level source addresses do not
- // match their L2-frame-level source addresses */
- if (PREDICT_FALSE (
- memcmp (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
- sizeof (eth0->src_address))))
- {
- error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
- goto drop;
- }
+ // Trash ARP packets whose ARP-level source addresses do not
+ // match their L2-frame-level source addresses */
+ if (PREDICT_FALSE
+ (memcmp
+ (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
+ sizeof (eth0->src_address))))
+ {
+ error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
+ goto drop;
+ }
// Check if anyone want ARP request events for L2 BDs
{
- pending_resolution_t * mc;
- ethernet_arp_main_t * am = ðernet_arp_main;
- uword *p = hash_get (am->mac_changes_by_address, 0);
- if (p && (vnet_buffer(p0)->l2.shg == 0))
- { // Only SHG 0 interface which is more likely local
- u32 next_index = p[0];
- while (next_index != (u32)~0)
- {
- int (*fp)(u32, u8 *, u32, u32);
- int rv = 1;
- mc = pool_elt_at_index (am->mac_changes, next_index);
- fp = mc->data_callback;
- // Call the callback, return 1 to suppress dup events */
- if (fp) rv = (*fp)(mc->data,
- arp0->ip4_over_ethernet[0].ethernet,
- sw_if_index0,
- arp0->ip4_over_ethernet[0].ip4.as_u32);
- // Signal the resolver process
- if (rv == 0)
- vlib_process_signal_event (vm, mc->node_index,
- mc->type_opaque,
- mc->data);
- next_index = mc->next_index;
- }
- }
+ pending_resolution_t *mc;
+ ethernet_arp_main_t *am = ðernet_arp_main;
+ uword *p = hash_get (am->mac_changes_by_address, 0);
+ if (p && (vnet_buffer (p0)->l2.shg == 0))
+ { // Only SHG 0 interface which is more likely local
+ u32 next_index = p[0];
+ while (next_index != (u32) ~ 0)
+ {
+ int (*fp) (u32, u8 *, u32, u32);
+ int rv = 1;
+ mc = pool_elt_at_index (am->mac_changes, next_index);
+ fp = mc->data_callback;
+ // Call the callback, return 1 to suppress dup events */
+ if (fp)
+ rv = (*fp) (mc->data,
+ arp0->ip4_over_ethernet[0].ethernet,
+ sw_if_index0,
+ arp0->ip4_over_ethernet[0].ip4.as_u32);
+ // Signal the resolver process
+ if (rv == 0)
+ vlib_process_signal_event (vm, mc->node_index,
+ mc->type_opaque, mc->data);
+ next_index = mc->next_index;
+ }
+ }
}
// lookup BD mac_by_ip4 hash table for MAC entry
ip0 = arp0->ip4_over_ethernet[1].ip4.as_u32;
- bd_index0 = vnet_buffer(p0)->l2.bd_index;
- if (PREDICT_FALSE (
- (bd_index0 != last_bd_index) || (last_bd_index == (u16) ~0)))
+ bd_index0 = vnet_buffer (p0)->l2.bd_index;
+ if (PREDICT_FALSE ((bd_index0 != last_bd_index)
+ || (last_bd_index == (u16) ~ 0)))
{
last_bd_index = bd_index0;
- last_bd_config = vec_elt_at_index(l2im->bd_configs, bd_index0);
+ last_bd_config = vec_elt_at_index (l2im->bd_configs, bd_index0);
}
macp0 = (u8 *) hash_get (last_bd_config->mac_by_ip4, ip0);
- if (PREDICT_FALSE(!macp0))
- goto next_l2_feature; // MAC not found
+ if (PREDICT_FALSE (!macp0))
+ goto next_l2_feature; // MAC not found
- // MAC found, send ARP reply -
+ // MAC found, send ARP reply -
// Convert ARP request packet to ARP reply
arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
// For BVI, need to use l2-fwd node to send ARP reply as
// l2-output node cannot output packet to BVI properly
- cfg0 = vec_elt_at_index(l2im->configs, sw_if_index0);
+ cfg0 = vec_elt_at_index (l2im->configs, sw_if_index0);
if (PREDICT_FALSE (cfg0->bvi))
{
- vnet_buffer(p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
+ vnet_buffer (p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
vnet_buffer (p0)->sw_if_index[VLIB_RX] = 0;
goto next_l2_feature;
}
// required, however, can just clear the SHG in packet as follows:
// vnet_buffer(p0)->l2.shg = 0;
- vlib_validate_buffer_enqueue_x1 (vm, node, next_index,to_next,
- n_left_to_next,pi0,next0);
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+ n_left_to_next, pi0, next0);
continue;
next_l2_feature:
{
u32 feature_bitmap0 =
- vnet_buffer(p0)->l2.feature_bitmap & ~L2INPUT_FEAT_ARP_TERM;
- vnet_buffer(p0)->l2.feature_bitmap = feature_bitmap0;
- next0 = feat_bitmap_get_next_node_index(arp_term_next_node_index,
- feature_bitmap0);
- vlib_validate_buffer_enqueue_x1 (vm, node, next_index,to_next,
- n_left_to_next,pi0,next0);
+ vnet_buffer (p0)->l2.feature_bitmap & ~L2INPUT_FEAT_ARP_TERM;
+ vnet_buffer (p0)->l2.feature_bitmap = feature_bitmap0;
+ next0 = feat_bitmap_get_next_node_index (arp_term_next_node_index,
+ feature_bitmap0);
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+ n_left_to_next, pi0, next0);
continue;
}
drop:
- if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
- (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
- arp0->ip4_over_ethernet[1].ip4.as_u32))
- {
- error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
- }
+ if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
+ (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
+ arp0->ip4_over_ethernet[1].ip4.as_u32))
+ {
+ error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
+ }
next0 = ARP_TERM_NEXT_DROP;
p0->error = node->errors[error0];
- vlib_validate_buffer_enqueue_x1 (vm, node, next_index,to_next,
- n_left_to_next,pi0,next0);
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+ n_left_to_next, pi0, next0);
}
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
vlib_error_count (vm, node->node_index,
- ETHERNET_ARP_ERROR_replies_sent,
- n_replies_sent);
+ ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
return frame->n_vectors;
}
-VLIB_REGISTER_NODE (arp_term_l2bd_node,static) = {
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (arp_term_l2bd_node, static) = {
.function = arp_term_l2bd,
.name = "arp-term-l2bd",
.vector_size = sizeof (u32),
-
.n_errors = ETHERNET_ARP_N_ERROR,
.error_strings = ethernet_arp_error_strings,
-
.n_next_nodes = ARP_TERM_N_NEXT,
.next_nodes = {
[ARP_TERM_NEXT_L2_OUTPUT] = "l2-output",
[ARP_TERM_NEXT_DROP] = "error-drop",
},
-
.format_buffer = format_ethernet_arp_header,
.format_trace = format_ethernet_arp_input_trace,
};
+/* *INDENT-ON* */
-clib_error_t *arp_term_init (vlib_main_t *vm)
-{ // Initialize the feature next-node indexes
- feat_bitmap_init_next_nodes(vm,
- arp_term_l2bd_node.index,
- L2INPUT_N_FEAT,
- l2input_get_feat_names(),
- arp_term_next_node_index);
+clib_error_t *
+arp_term_init (vlib_main_t * vm)
+{ // Initialize the feature next-node indexes
+ feat_bitmap_init_next_nodes (vm,
+ arp_term_l2bd_node.index,
+ L2INPUT_N_FEAT,
+ l2input_get_feat_names (),
+ arp_term_next_node_index);
return 0;
}
VLIB_INIT_FUNCTION (arp_term_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
_ (exp1) \
_ (exp2)
-typedef enum {
+typedef enum
+{
#define _(n,f) ETHERNET_ARP_HARDWARE_TYPE_##f = (n),
foreach_ethernet_arp_hardware_type
#undef _
} ethernet_arp_hardware_type_t;
-typedef enum {
+typedef enum
+{
#define _(f) ETHERNET_ARP_OPCODE_##f,
foreach_ethernet_arp_opcode
#undef _
- ETHERNET_ARP_N_OPCODE,
+ ETHERNET_ARP_N_OPCODE,
} ethernet_arp_opcode_t;
-typedef enum {
+typedef enum
+{
IP4_ARP_NEXT_DROP,
IP4_ARP_N_NEXT,
} ip4_arp_next_t;
-typedef enum {
+typedef enum
+{
IP4_ARP_ERROR_DROP,
IP4_ARP_ERROR_REQUEST_SENT,
IP4_ARP_ERROR_NON_ARP_ADJ,
IP4_ARP_ERROR_NO_SOURCE_ADDRESS,
} ip4_arp_error_t;
+/* *INDENT-OFF* */
typedef CLIB_PACKED (struct {
u8 ethernet[6];
ip4_address_t ip4;
}) ethernet_arp_ip4_over_ethernet_address_t;
+/* *INDENT-ON* */
-typedef struct {
+typedef struct
+{
u16 l2_type;
u16 l3_type;
u8 n_l2_address_bytes;
u8 n_l3_address_bytes;
u16 opcode;
- union {
+ union
+ {
ethernet_arp_ip4_over_ethernet_address_t ip4_over_ethernet[2];
/* Others... */
} ethernet_arp_header_t;
#endif /* included_ethernet_arp_packet_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
always_inline u64
ethernet_mac_address_u64 (u8 * a)
-{ return (((u64) a[0] << (u64) (5*8))
- | ((u64) a[1] << (u64) (4*8))
- | ((u64) a[2] << (u64) (3*8))
- | ((u64) a[3] << (u64) (2*8))
- | ((u64) a[4] << (u64) (1*8))
- | ((u64) a[5] << (u64) (0*8))); }
-
-static inline int ethernet_mac_address_is_multicast_u64 (u64 a)
{
- return (a & (1ULL<<(5*8))) != 0;
+ return (((u64) a[0] << (u64) (5 * 8))
+ | ((u64) a[1] << (u64) (4 * 8))
+ | ((u64) a[2] << (u64) (3 * 8))
+ | ((u64) a[3] << (u64) (2 * 8))
+ | ((u64) a[4] << (u64) (1 * 8)) | ((u64) a[5] << (u64) (0 * 8)));
+}
+
+static inline int
+ethernet_mac_address_is_multicast_u64 (u64 a)
+{
+ return (a & (1ULL << (5 * 8))) != 0;
}
/* Max. sized ethernet/vlan header for parsing. */
-typedef struct {
+typedef struct
+{
ethernet_header_t ethernet;
/* Allow up to 2 stacked vlan headers. */
struct vnet_hw_interface_t;
/* Ethernet flag change callback. */
typedef u32 (ethernet_flag_change_function_t)
-(vnet_main_t * vnm, struct vnet_hw_interface_t * hi, u32 flags);
+ (vnet_main_t * vnm, struct vnet_hw_interface_t * hi, u32 flags);
#define ETHERNET_MIN_PACKET_BYTES 64
#define ETHERNET_MAX_PACKET_BYTES 9216
/* Ethernet interface instance. */
-typedef struct ethernet_interface {
+typedef struct ethernet_interface
+{
/* Accept all packets (promiscuous mode). */
#define ETHERNET_INTERFACE_FLAG_ACCEPT_ALL (1 << 0)
((flags) & ETHERNET_INTERFACE_FLAG_MTU)
/* Callback, e.g. to turn on/off promiscuous mode */
- ethernet_flag_change_function_t * flag_change;
+ ethernet_flag_change_function_t *flag_change;
u32 driver_instance;
extern vnet_hw_interface_class_t ethernet_hw_interface_class;
-typedef struct {
+typedef struct
+{
/* Name (a c string). */
- char * name;
+ char *name;
/* Ethernet type in host byte order. */
ethernet_type_t type;
u32 next_index;
} ethernet_type_info_t;
-typedef enum {
+typedef enum
+{
#define ethernet_error(n,c,s) ETHERNET_ERROR_##n,
#include <vnet/ethernet/error.def>
#undef ethernet_error
// Structs used when parsing packet to find sw_if_index
-typedef struct {
+typedef struct
+{
u32 sw_if_index;
- u32 flags;
+ u32 flags;
// config entry is-valid flag
// exact match flags (valid if packet has 0/1/2/3 tags)
// L2 vs L3 forwarding mode
} subint_config_t;
always_inline u32
-eth_create_valid_subint_match_flags (u32 num_tags) {
+eth_create_valid_subint_match_flags (u32 num_tags)
+{
return SUBINT_CONFIG_VALID | (1 << num_tags);
}
-typedef struct {
+typedef struct
+{
subint_config_t untagged_subint;
subint_config_t default_subint;
- u16 dot1q_vlans; // pool id for vlan table
- u16 dot1ad_vlans; // pool id for vlan table
+ u16 dot1q_vlans; // pool id for vlan table
+ u16 dot1ad_vlans; // pool id for vlan table
} main_intf_t;
-typedef struct {
+typedef struct
+{
subint_config_t single_tag_subint;
subint_config_t inner_any_subint;
- u32 qinqs; // pool id for qinq table
+ u32 qinqs; // pool id for qinq table
} vlan_intf_t;
-typedef struct {
+typedef struct
+{
vlan_intf_t vlans[ETHERNET_N_VLAN];
} vlan_table_t;
-typedef struct {
+typedef struct
+{
subint_config_t subint;
} qinq_intf_t;
-typedef struct {
+typedef struct
+{
qinq_intf_t vlans[ETHERNET_N_VLAN];
} qinq_table_t;
// Structure mapping to a next index based on ethertype.
// Common ethertypes are stored explicitly, others are
// stored in a sparse table.
-typedef struct {
+typedef struct
+{
/* Sparse vector mapping ethernet type in network byte order
to next index. */
- u16 * input_next_by_type;
- u32 * sparse_index_by_input_next_index;
+ u16 *input_next_by_type;
+ u32 *sparse_index_by_input_next_index;
/* cached next indexes for common ethertypes */
u32 input_next_ip4;
} next_by_ethertype_t;
-typedef struct {
- vlib_main_t * vlib_main;
+typedef struct
+{
+ vlib_main_t *vlib_main;
/* next node index for the L3 input node of each ethertype */
next_by_ethertype_t l3_next;
u32 redirect_l3_next;
/* Pool of ethernet interface instances. */
- ethernet_interface_t * interfaces;
+ ethernet_interface_t *interfaces;
- ethernet_type_info_t * type_infos;
+ ethernet_type_info_t *type_infos;
/* Hash tables mapping name/type to type info index. */
- uword * type_info_by_name, * type_info_by_type;
+ uword *type_info_by_name, *type_info_by_type;
// The root of the vlan parsing tables. A vector with one element
// for each main interface, indexed by hw_if_index.
- main_intf_t * main_intfs;
+ main_intf_t *main_intfs;
// Pool of vlan tables
- vlan_table_t * vlan_pool;
+ vlan_table_t *vlan_pool;
// Pool of qinq tables;
- qinq_table_t * qinq_pool;
+ qinq_table_t *qinq_pool;
/* Set to one to use AB.CD.EF instead of A:B:C:D:E:F as ethernet format. */
int format_ethernet_address_16bit;
always_inline ethernet_type_info_t *
ethernet_get_type_info (ethernet_main_t * em, ethernet_type_t type)
{
- uword * p = hash_get (em->type_info_by_type, type);
+ uword *p = hash_get (em->type_info_by_type, type);
return p ? vec_elt_at_index (em->type_infos, p[0]) : 0;
}
-ethernet_interface_t *
-ethernet_get_interface (ethernet_main_t * em, u32 hw_if_index);
+ethernet_interface_t *ethernet_get_interface (ethernet_main_t * em,
+ u32 hw_if_index);
-clib_error_t *
-ethernet_register_interface (vnet_main_t * vnm,
- u32 dev_class_index,
- u32 dev_instance,
- u8 * address,
- u32 * hw_if_index_return,
- ethernet_flag_change_function_t flag_change);
+clib_error_t *ethernet_register_interface (vnet_main_t * vnm,
+ u32 dev_class_index,
+ u32 dev_instance,
+ u8 * address,
+ u32 * hw_if_index_return,
+ ethernet_flag_change_function_t
+ flag_change);
void ethernet_delete_interface (vnet_main_t * vnm, u32 hw_if_index);
/* Register given node index to take input for given ethernet type. */
void
ethernet_register_input_type (vlib_main_t * vm,
- ethernet_type_t type,
- u32 node_index);
+ ethernet_type_t type, u32 node_index);
/* Register given node index to take input for packet from L2 interfaces. */
-void
-ethernet_register_l2_input (vlib_main_t * vm,
- u32 node_index);
+void ethernet_register_l2_input (vlib_main_t * vm, u32 node_index);
/* Register given node index to take redirected L3 traffic, and enable L3 redirect */
-void
-ethernet_register_l3_redirect (vlib_main_t * vm,
- u32 node_index);
+void ethernet_register_l3_redirect (vlib_main_t * vm, u32 node_index);
/* Formats ethernet address X:X:X:X:X:X */
-u8 * format_ethernet_address (u8 * s, va_list * args);
-u8 * format_ethernet_type (u8 * s, va_list * args);
-u8 * format_ethernet_vlan_tci (u8 * s, va_list * va);
-u8 * format_ethernet_header (u8 * s, va_list * args);
-u8 * format_ethernet_header_with_length (u8 * s, va_list * args);
+u8 *format_ethernet_address (u8 * s, va_list * args);
+u8 *format_ethernet_type (u8 * s, va_list * args);
+u8 *format_ethernet_vlan_tci (u8 * s, va_list * va);
+u8 *format_ethernet_header (u8 * s, va_list * args);
+u8 *format_ethernet_header_with_length (u8 * s, va_list * args);
/* Parse ethernet address in either X:X:X:X:X:X unix or X.X.X cisco format. */
-uword
-unformat_ethernet_address (unformat_input_t * input, va_list * args);
+uword unformat_ethernet_address (unformat_input_t * input, va_list * args);
/* Parse ethernet type as 0xXXXX or type name from ethernet/types.def.
In either host or network byte order. */
va_list * args);
/* Parse ethernet header. */
-uword
-unformat_ethernet_header (unformat_input_t * input, va_list * args);
+uword unformat_ethernet_header (unformat_input_t * input, va_list * args);
/* Parse ethernet interface name; return hw_if_index. */
uword unformat_ethernet_interface (unformat_input_t * input, va_list * args);
always_inline void
ethernet_setup_node (vlib_main_t * vm, u32 node_index)
{
- vlib_node_t * n = vlib_get_node (vm, node_index);
- pg_node_t * pn = pg_get_node (node_index);
+ vlib_node_t *n = vlib_get_node (vm, node_index);
+ pg_node_t *pn = pg_get_node (node_index);
n->format_buffer = format_ethernet_header_with_length;
n->unformat_buffer = unformat_ethernet_header;
ethernet_buffer_get_header (vlib_buffer_t * b)
{
return (void *)
- (b->data
- + vnet_buffer (b)->ethernet.start_of_ethernet_header);
+ (b->data + vnet_buffer (b)->ethernet.start_of_ethernet_header);
}
/** Returns the number of VLAN headers in the current Ethernet frame in the
sizeof(ethernet_header_t) \
)
-ethernet_main_t * ethernet_get_main (vlib_main_t * vm);
+ethernet_main_t *ethernet_get_main (vlib_main_t * vm);
u32 ethernet_set_flags (vnet_main_t * vnm, u32 hw_if_index, u32 flags);
-void ethernet_sw_interface_set_l2_mode (vnet_main_t * vnm, u32 sw_if_index, u32 l2);
-void ethernet_sw_interface_set_l2_mode_noport (vnet_main_t * vnm, u32 sw_if_index, u32 l2);
-void ethernet_set_rx_redirect (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 enable);
+void ethernet_sw_interface_set_l2_mode (vnet_main_t * vnm, u32 sw_if_index,
+ u32 l2);
+void ethernet_sw_interface_set_l2_mode_noport (vnet_main_t * vnm,
+ u32 sw_if_index, u32 l2);
+void ethernet_set_rx_redirect (vnet_main_t * vnm, vnet_hw_interface_t * hi,
+ u32 enable);
int
vnet_arp_set_ip4_over_ethernet (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 fib_index,
- void *a_arg,
- int is_static);
+ u32 sw_if_index,
+ u32 fib_index, void *a_arg, int is_static);
int
vnet_arp_unset_ip4_over_ethernet (vnet_main_t * vnm,
- u32 sw_if_index, u32 fib_index,
- void * a_arg);
+ u32 sw_if_index, u32 fib_index,
+ void *a_arg);
int vnet_proxy_arp_fib_reset (u32 fib_id);
-clib_error_t * next_by_ethertype_init (next_by_ethertype_t * l3_next);
-clib_error_t * next_by_ethertype_register (next_by_ethertype_t * l3_next,
- u32 ethertype,
- u32 next_index);
+clib_error_t *next_by_ethertype_init (next_by_ethertype_t * l3_next);
+clib_error_t *next_by_ethertype_register (next_by_ethertype_t * l3_next,
+ u32 ethertype, u32 next_index);
-int vnet_create_loopback_interface (u32 * sw_if_indexp, u8 *mac_address);
+int vnet_create_loopback_interface (u32 * sw_if_indexp, u8 * mac_address);
int vnet_delete_loopback_interface (u32 sw_if_index);
// Perform ethernet subinterface classification table lookups given
// the ports's sw_if_index and fields extracted from the ethernet header.
// The resulting tables are used by identify_subint().
always_inline void
-eth_vlan_table_lookups (ethernet_main_t *em,
- vnet_main_t * vnm,
- u32 port_sw_if_index0,
- u16 first_ethertype,
- u16 outer_id,
- u16 inner_id,
- vnet_hw_interface_t ** hi,
- main_intf_t **main_intf,
- vlan_intf_t **vlan_intf,
- qinq_intf_t **qinq_intf)
+eth_vlan_table_lookups (ethernet_main_t * em,
+ vnet_main_t * vnm,
+ u32 port_sw_if_index0,
+ u16 first_ethertype,
+ u16 outer_id,
+ u16 inner_id,
+ vnet_hw_interface_t ** hi,
+ main_intf_t ** main_intf,
+ vlan_intf_t ** vlan_intf, qinq_intf_t ** qinq_intf)
{
vlan_table_t *vlan_table;
qinq_table_t *qinq_table;
// many tags on the packet. This makes the lookups and comparisons
// easier (and less branchy).
vlan_table_id = (first_ethertype == ETHERNET_TYPE_DOT1AD) ?
- (*main_intf)->dot1ad_vlans :
- (*main_intf)->dot1q_vlans;
+ (*main_intf)->dot1ad_vlans : (*main_intf)->dot1q_vlans;
vlan_table = vec_elt_at_index (em->vlan_pool, vlan_table_id);
*vlan_intf = &vlan_table->vlans[outer_id];
// Returns 1 if a matching subinterface was found, otherwise returns 0.
always_inline u32
eth_identify_subint (vnet_hw_interface_t * hi,
- vlib_buffer_t * b0,
- u32 match_flags,
- main_intf_t * main_intf,
- vlan_intf_t * vlan_intf,
- qinq_intf_t * qinq_intf,
- u32 * new_sw_if_index,
- u8 * error0,
- u32 * is_l2)
+ vlib_buffer_t * b0,
+ u32 match_flags,
+ main_intf_t * main_intf,
+ vlan_intf_t * vlan_intf,
+ qinq_intf_t * qinq_intf,
+ u32 * new_sw_if_index, u8 * error0, u32 * is_l2)
{
- subint_config_t * subint;
+ subint_config_t *subint;
// Each comparison is checking both the valid flag and the number of tags
// (incorporating exact-match/non-exact-match).
// check for specific double tag
subint = &qinq_intf->subint;
- if ((subint->flags & match_flags) == match_flags) goto matched;
+ if ((subint->flags & match_flags) == match_flags)
+ goto matched;
// check for specific outer and 'any' inner
subint = &vlan_intf->inner_any_subint;
- if ((subint->flags & match_flags) == match_flags) goto matched;
+ if ((subint->flags & match_flags) == match_flags)
+ goto matched;
// check for specific single tag
subint = &vlan_intf->single_tag_subint;
- if ((subint->flags & match_flags) == match_flags) goto matched;
+ if ((subint->flags & match_flags) == match_flags)
+ goto matched;
// check for untagged interface
subint = &main_intf->untagged_subint;
- if ((subint->flags & match_flags) == match_flags) goto matched;
+ if ((subint->flags & match_flags) == match_flags)
+ goto matched;
// check for default interface
subint = &main_intf->default_subint;
- if ((subint->flags & match_flags) == match_flags) goto matched;
+ if ((subint->flags & match_flags) == match_flags)
+ goto matched;
// No matching subinterface
*new_sw_if_index = ~0;
*error0 = ETHERNET_ERROR_UNKNOWN_VLAN;
*is_l2 = 0;
return 0;
-
- matched:
+
+matched:
*new_sw_if_index = subint->sw_if_index;
*is_l2 = subint->flags & SUBINT_CONFIG_L2;
return 1;
// Compare two ethernet macs. Return 1 if they are the same, 0 if different
always_inline u32
-eth_mac_equal (u8 * mac1, u8 * mac2) {
- return (*((u32 *)(mac1+0)) == *((u32 *)(mac2+0)) &&
- *((u32 *)(mac1+2)) == *((u32 *)(mac2+2)));
+eth_mac_equal (u8 * mac1, u8 * mac2)
+{
+ return (*((u32 *) (mac1 + 0)) == *((u32 *) (mac2 + 0)) &&
+ *((u32 *) (mac1 + 2)) == *((u32 *) (mac2 + 2)));
}
-always_inline ethernet_main_t *
+always_inline ethernet_main_t *
vnet_get_ethernet_main (void)
{
return ðernet_main;
}
-void vnet_register_ip4_arp_resolution_event (vnet_main_t * vnm,
- void * address_arg,
- uword node_index,
- uword type_opaque,
- uword data);
+void vnet_register_ip4_arp_resolution_event (vnet_main_t * vnm,
+ void *address_arg,
+ uword node_index,
+ uword type_opaque, uword data);
-int vnet_add_del_ip4_arp_change_event (vnet_main_t * vnm,
- void * data_callback,
- u32 pid,
- void * address_arg,
- uword node_index,
- uword type_opaque,
- uword data, int is_add);
+int vnet_add_del_ip4_arp_change_event (vnet_main_t * vnm,
+ void *data_callback,
+ u32 pid,
+ void *address_arg,
+ uword node_index,
+ uword type_opaque,
+ uword data, int is_add);
-u32 vnet_arp_glean_add(u32 fib_index, void * next_hop_arg);
+u32 vnet_arp_glean_add (u32 fib_index, void *next_hop_arg);
extern vlib_node_registration_t ethernet_input_node;
#endif /* included_ethernet_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
#include <vlib/vlib.h>
#include <vnet/ethernet/ethernet.h>
-u8 * format_ethernet_address (u8 * s, va_list * args)
+u8 *
+format_ethernet_address (u8 * s, va_list * args)
{
- ethernet_main_t * em = ðernet_main;
- u8 * a = va_arg (*args, u8 *);
+ ethernet_main_t *em = ðernet_main;
+ u8 *a = va_arg (*args, u8 *);
if (em->format_ethernet_address_16bit)
return format (s, "%02x%02x.%02x%02x.%02x%02x",
a[0], a[1], a[2], a[3], a[4], a[5]);
}
-u8 * format_ethernet_type (u8 * s, va_list * args)
+u8 *
+format_ethernet_type (u8 * s, va_list * args)
{
ethernet_type_t type = va_arg (*args, u32);
- ethernet_main_t * em = ðernet_main;
- ethernet_type_info_t * t = ethernet_get_type_info (em, type);
+ ethernet_main_t *em = ðernet_main;
+ ethernet_type_info_t *t = ethernet_get_type_info (em, type);
if (t)
s = format (s, "%s", t->name);
return s;
}
-u8 * format_ethernet_vlan_tci (u8 * s, va_list * va)
+u8 *
+format_ethernet_vlan_tci (u8 * s, va_list * va)
{
- u32 vlan_tci = va_arg (*va, u32);
+ u32 vlan_tci = va_arg (*va, u32);
- u32 vid = (vlan_tci & 0xfff);
- u32 cfi = (vlan_tci >> 12) & 1;
- u32 pri = (vlan_tci >> 13);
+ u32 vid = (vlan_tci & 0xfff);
+ u32 cfi = (vlan_tci >> 12) & 1;
+ u32 pri = (vlan_tci >> 13);
- s = format (s, "%d", vid);
- if (pri != 0)
- s = format (s, " priority %d", pri);
- if (cfi != 0)
- s = format (s, " cfi");
+ s = format (s, "%d", vid);
+ if (pri != 0)
+ s = format (s, " priority %d", pri);
+ if (cfi != 0)
+ s = format (s, " cfi");
- return s;
+ return s;
}
-u8 * format_ethernet_header_with_length (u8 * s, va_list * args)
+u8 *
+format_ethernet_header_with_length (u8 * s, va_list * args)
{
- ethernet_max_header_t * m = va_arg (*args, ethernet_max_header_t *);
+ ethernet_max_header_t *m = va_arg (*args, ethernet_max_header_t *);
u32 max_header_bytes = va_arg (*args, u32);
- ethernet_main_t * em = ðernet_main;
- ethernet_header_t * e = &m->ethernet;
- ethernet_vlan_header_t * v;
+ ethernet_main_t *em = ðernet_main;
+ ethernet_header_t *e = &m->ethernet;
+ ethernet_vlan_header_t *v;
ethernet_type_t type = clib_net_to_host_u16 (e->type);
- ethernet_type_t vlan_type[ARRAY_LEN(m->vlan)];
+ ethernet_type_t vlan_type[ARRAY_LEN (m->vlan)];
u32 n_vlan = 0, i, header_bytes;
uword indent;
{
u32 v = clib_net_to_host_u16 (m->vlan[i].priority_cfi_and_id);
if (*vlan_type == ETHERNET_TYPE_VLAN)
- s = format (s, " 802.1q vlan %U", format_ethernet_vlan_tci, v);
+ s = format (s, " 802.1q vlan %U", format_ethernet_vlan_tci, v);
else
- s = format (s, " 802.1ad vlan %U", format_ethernet_vlan_tci, v);
+ s = format (s, " 802.1ad vlan %U", format_ethernet_vlan_tci, v);
}
if (max_header_bytes != 0 && header_bytes < max_header_bytes)
{
- ethernet_type_info_t * ti;
- vlib_node_t * node = 0;
+ ethernet_type_info_t *ti;
+ vlib_node_t *node = 0;
ti = ethernet_get_type_info (em, type);
if (ti && ti->node_index != ~0)
- node = vlib_get_node (em->vlib_main, ti->node_index);
+ node = vlib_get_node (em->vlib_main, ti->node_index);
if (node && node->format_buffer)
s = format (s, "\n%U%U",
format_white_space, indent,
return s;
}
-u8 * format_ethernet_header (u8 * s, va_list * args)
+u8 *
+format_ethernet_header (u8 * s, va_list * args)
{
- ethernet_max_header_t * m = va_arg (*args, ethernet_max_header_t *);
+ ethernet_max_header_t *m = va_arg (*args, ethernet_max_header_t *);
return format (s, "%U", format_ethernet_header_with_length, m, 0);
}
static uword
unformat_ethernet_address_unix (unformat_input_t * input, va_list * args)
{
- u8 * result = va_arg (*args, u8 *);
+ u8 *result = va_arg (*args, u8 *);
u32 i, a[6];
- if (! unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
- &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
+ if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
+ &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
return 0;
/* Check range. */
static uword
unformat_ethernet_address_cisco (unformat_input_t * input, va_list * args)
{
- u8 * result = va_arg (*args, u8 *);
+ u8 *result = va_arg (*args, u8 *);
u32 i, a[3];
- if (! unformat (input, "%_%x.%x.%x%_", &a[0], &a[1], &a[2]))
+ if (!unformat (input, "%_%x.%x.%x%_", &a[0], &a[1], &a[2]))
return 0;
/* Check range. */
uword
unformat_ethernet_address (unformat_input_t * input, va_list * args)
{
- u8 * result = va_arg (*args, u8 *);
+ u8 *result = va_arg (*args, u8 *);
return (unformat_user (input, unformat_ethernet_address_unix, result)
|| unformat_user (input, unformat_ethernet_address_cisco, result));
}
unformat_ethernet_type_host_byte_order (unformat_input_t * input,
va_list * args)
{
- u16 * result = va_arg (*args, u16 *);
- ethernet_main_t * em = ðernet_main;
+ u16 *result = va_arg (*args, u16 *);
+ ethernet_main_t *em = ðernet_main;
int type, i;
/* Numeric type. */
- if (unformat (input, "0x%x", &type)
- || unformat (input, "%d", &type))
+ if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
{
if (type >= (1 << 16))
return 0;
if (unformat_user (input, unformat_vlib_number_by_name,
em->type_info_by_name, &i))
{
- ethernet_type_info_t * ti = vec_elt_at_index (em->type_infos, i);
+ ethernet_type_info_t *ti = vec_elt_at_index (em->type_infos, i);
*result = ti->type;
return 1;
}
unformat_ethernet_type_net_byte_order (unformat_input_t * input,
va_list * args)
{
- u16 * result = va_arg (*args, u16 *);
- if (! unformat_user (input, unformat_ethernet_type_host_byte_order, result))
+ u16 *result = va_arg (*args, u16 *);
+ if (!unformat_user (input, unformat_ethernet_type_host_byte_order, result))
return 0;
- *result = clib_host_to_net_u16 ((u16) *result);
+ *result = clib_host_to_net_u16 ((u16) * result);
return 1;
}
uword
unformat_ethernet_header (unformat_input_t * input, va_list * args)
{
- u8 ** result = va_arg (*args, u8 **);
- ethernet_max_header_t _m, * m = &_m;
- ethernet_header_t * e = &m->ethernet;
+ u8 **result = va_arg (*args, u8 **);
+ ethernet_max_header_t _m, *m = &_m;
+ ethernet_header_t *e = &m->ethernet;
u16 type;
u32 n_vlan;
- if (! unformat (input, "%U: %U -> %U",
- unformat_ethernet_type_host_byte_order, &type,
- unformat_ethernet_address, &e->src_address,
- unformat_ethernet_address, &e->dst_address))
+ if (!unformat (input, "%U: %U -> %U",
+ unformat_ethernet_type_host_byte_order, &type,
+ unformat_ethernet_address, &e->src_address,
+ unformat_ethernet_address, &e->dst_address))
return 0;
n_vlan = 0;
{
u32 id, priority;
- if (! unformat_user (input, unformat_vlib_number, &id)
+ if (!unformat_user (input, unformat_vlib_number, &id)
|| id >= ETHERNET_N_VLAN)
return 0;
/* Add header to result. */
{
- void * p;
+ void *p;
u32 n_bytes = sizeof (e[0]) + n_vlan * sizeof (m->vlan[0]);
vec_add2 (*result, p, n_bytes);
clib_memcpy (p, m, n_bytes);
}
-
+
return 1;
}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
/* Global main structure. */
ethernet_main_t ethernet_main;
-static void add_type (ethernet_main_t * em,
- ethernet_type_t type,
- char * type_name)
+static void
+add_type (ethernet_main_t * em, ethernet_type_t type, char *type_name)
{
- ethernet_type_info_t * ti;
+ ethernet_type_info_t *ti;
u32 i;
vec_add2 (em->type_infos, ti, 1);
hash_set_mem (em->type_info_by_name, ti->name, i);
}
-static clib_error_t * ethernet_init (vlib_main_t * vm)
+static clib_error_t *
+ethernet_init (vlib_main_t * vm)
{
- ethernet_main_t * em = ðernet_main;
- clib_error_t * error;
+ ethernet_main_t *em = ðernet_main;
+ clib_error_t *error;
/*
* Set up the L2 path now, or we'll wipe out the L2 ARP
* registration set up by ethernet_arp_init.
*/
- if ((error = vlib_call_init_function(vm, l2_init)))
+ if ((error = vlib_call_init_function (vm, l2_init)))
return error;
em->vlib_main = vm;
VLIB_INIT_FUNCTION (ethernet_init);
-ethernet_main_t * ethernet_get_main (vlib_main_t * vm)
+ethernet_main_t *
+ethernet_get_main (vlib_main_t * vm)
{
vlib_call_init_function (vm, ethernet_init);
return ðernet_main;
}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
#include <vnet/ethernet/ethernet.h>
#include <vnet/l2/l2_input.h>
-static uword ethernet_set_rewrite (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 l3_type,
- void * dst_address,
- void * rewrite,
- uword max_rewrite_bytes)
+static uword
+ethernet_set_rewrite (vnet_main_t * vnm,
+ u32 sw_if_index,
+ u32 l3_type,
+ void *dst_address,
+ void *rewrite, uword max_rewrite_bytes)
{
- vnet_sw_interface_t * sub_sw = vnet_get_sw_interface (vnm, sw_if_index);
- vnet_sw_interface_t * sup_sw = vnet_get_sup_sw_interface (vnm, sw_if_index);
- vnet_hw_interface_t * hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
- ethernet_main_t * em = ðernet_main;
- ethernet_interface_t * ei;
- ethernet_header_t * h = rewrite;
+ vnet_sw_interface_t *sub_sw = vnet_get_sw_interface (vnm, sw_if_index);
+ vnet_sw_interface_t *sup_sw = vnet_get_sup_sw_interface (vnm, sw_if_index);
+ vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
+ ethernet_main_t *em = ðernet_main;
+ ethernet_interface_t *ei;
+ ethernet_header_t *h = rewrite;
ethernet_type_t type;
uword n_bytes = sizeof (h[0]);
- if (sub_sw != sup_sw) {
- if (sub_sw->sub.eth.flags.one_tag) {
- n_bytes += sizeof (ethernet_vlan_header_t);
- } else if (sub_sw->sub.eth.flags.two_tags) {
- n_bytes += 2 * (sizeof (ethernet_vlan_header_t));
- }
- // Check for encaps that are not supported for L3 interfaces
- if (!(sub_sw->sub.eth.flags.exact_match) ||
- (sub_sw->sub.eth.flags.default_sub) ||
- (sub_sw->sub.eth.flags.outer_vlan_id_any) ||
- (sub_sw->sub.eth.flags.inner_vlan_id_any)) {
- return 0;
+ if (sub_sw != sup_sw)
+ {
+ if (sub_sw->sub.eth.flags.one_tag)
+ {
+ n_bytes += sizeof (ethernet_vlan_header_t);
+ }
+ else if (sub_sw->sub.eth.flags.two_tags)
+ {
+ n_bytes += 2 * (sizeof (ethernet_vlan_header_t));
+ }
+ // Check for encaps that are not supported for L3 interfaces
+ if (!(sub_sw->sub.eth.flags.exact_match) ||
+ (sub_sw->sub.eth.flags.default_sub) ||
+ (sub_sw->sub.eth.flags.outer_vlan_id_any) ||
+ (sub_sw->sub.eth.flags.inner_vlan_id_any))
+ {
+ return 0;
+ }
}
- }
if (n_bytes > max_rewrite_bytes)
return 0;
- switch (l3_type) {
+ switch (l3_type)
+ {
#define _(a,b) case VNET_L3_PACKET_TYPE_##a: type = ETHERNET_TYPE_##b; break
- _ (IP4, IP4);
- _ (IP6, IP6);
- _ (MPLS_UNICAST, MPLS_UNICAST);
- _ (MPLS_MULTICAST, MPLS_MULTICAST);
- _ (ARP, ARP);
+ _(IP4, IP4);
+ _(IP6, IP6);
+ _(MPLS_UNICAST, MPLS_UNICAST);
+ _(MPLS_MULTICAST, MPLS_MULTICAST);
+ _(ARP, ARP);
#undef _
- default:
- return 0;
- }
+ default:
+ return 0;
+ }
ei = pool_elt_at_index (em->interfaces, hw->hw_instance);
clib_memcpy (h->src_address, ei->address, sizeof (h->src_address));
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 */
-
- if (sub_sw->sub.eth.flags.one_tag) {
- ethernet_vlan_header_t * outer = (void *) (h + 1);
-
- h->type = sub_sw->sub.eth.flags.dot1ad ?
- clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
- clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
- outer->priority_cfi_and_id = clib_host_to_net_u16 (sub_sw->sub.eth.outer_vlan_id);
- outer->type = clib_host_to_net_u16 (type);
-
- } else if (sub_sw->sub.eth.flags.two_tags) {
- ethernet_vlan_header_t * outer = (void *) (h + 1);
- ethernet_vlan_header_t * inner = (void *) (outer + 1);
-
- h->type = sub_sw->sub.eth.flags.dot1ad ?
- clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
- clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
- outer->priority_cfi_and_id = clib_host_to_net_u16 (sub_sw->sub.eth.outer_vlan_id);
- outer->type = clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
- inner->priority_cfi_and_id = clib_host_to_net_u16 (sub_sw->sub.eth.inner_vlan_id);
- inner->type = clib_host_to_net_u16 (type);
-
- } else {
- h->type = clib_host_to_net_u16 (type);
- }
+ memset (h->dst_address, ~0, sizeof (h->dst_address)); /* broadcast */
+
+ if (sub_sw->sub.eth.flags.one_tag)
+ {
+ ethernet_vlan_header_t *outer = (void *) (h + 1);
+
+ h->type = sub_sw->sub.eth.flags.dot1ad ?
+ clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
+ clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
+ outer->priority_cfi_and_id =
+ clib_host_to_net_u16 (sub_sw->sub.eth.outer_vlan_id);
+ outer->type = clib_host_to_net_u16 (type);
+
+ }
+ else if (sub_sw->sub.eth.flags.two_tags)
+ {
+ ethernet_vlan_header_t *outer = (void *) (h + 1);
+ ethernet_vlan_header_t *inner = (void *) (outer + 1);
+
+ h->type = sub_sw->sub.eth.flags.dot1ad ?
+ clib_host_to_net_u16 (ETHERNET_TYPE_DOT1AD) :
+ clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
+ outer->priority_cfi_and_id =
+ clib_host_to_net_u16 (sub_sw->sub.eth.outer_vlan_id);
+ outer->type = clib_host_to_net_u16 (ETHERNET_TYPE_VLAN);
+ inner->priority_cfi_and_id =
+ clib_host_to_net_u16 (sub_sw->sub.eth.inner_vlan_id);
+ inner->type = clib_host_to_net_u16 (type);
+
+ }
+ else
+ {
+ h->type = clib_host_to_net_u16 (type);
+ }
return n_bytes;
}
+/* *INDENT-OFF* */
VNET_HW_INTERFACE_CLASS (ethernet_hw_interface_class) = {
.name = "Ethernet",
.format_address = format_ethernet_address,
.unformat_header = unformat_ethernet_header,
.set_rewrite = ethernet_set_rewrite,
};
+/* *INDENT-ON* */
-uword unformat_ethernet_interface (unformat_input_t * input, va_list * args)
+uword
+unformat_ethernet_interface (unformat_input_t * input, va_list * args)
{
- vnet_main_t * vnm = va_arg (*args, vnet_main_t *);
- u32 * result = va_arg (*args, u32 *);
+ vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
+ u32 *result = va_arg (*args, u32 *);
u32 hw_if_index;
- ethernet_main_t * em = ðernet_main;
- ethernet_interface_t * eif;
+ ethernet_main_t *em = ðernet_main;
+ ethernet_interface_t *eif;
- if (! unformat_user (input, unformat_vnet_hw_interface, vnm, &hw_if_index))
+ if (!unformat_user (input, unformat_vnet_hw_interface, vnm, &hw_if_index))
return 0;
eif = ethernet_get_interface (em, hw_if_index);
if (eif)
{
- *result = hw_if_index;
+ *result = hw_if_index;
return 1;
}
return 0;
u32 dev_class_index,
u32 dev_instance,
u8 * address,
- u32 * hw_if_index_return,
- ethernet_flag_change_function_t flag_change)
+ u32 * hw_if_index_return,
+ ethernet_flag_change_function_t flag_change)
{
- ethernet_main_t * em = ðernet_main;
- ethernet_interface_t * ei;
- vnet_hw_interface_t * hi;
- clib_error_t * error = 0;
+ ethernet_main_t *em = ðernet_main;
+ ethernet_interface_t *ei;
+ vnet_hw_interface_t *hi;
+ clib_error_t *error = 0;
u32 hw_if_index;
pool_get (em->interfaces, ei);
hw_if_index = vnet_register_interface
(vnm,
dev_class_index, dev_instance,
- ethernet_hw_interface_class.index,
- ei - em->interfaces);
+ ethernet_hw_interface_class.index, ei - em->interfaces);
*hw_if_index_return = hw_if_index;
hi = vnet_get_hw_interface (vnm, hw_if_index);
ethernet_setup_node (vnm->vlib_main, hi->output_node_index);
- hi->min_packet_bytes = hi->min_supported_packet_bytes = ETHERNET_MIN_PACKET_BYTES;
- hi->max_packet_bytes = hi->max_supported_packet_bytes = ETHERNET_MAX_PACKET_BYTES;
+ hi->min_packet_bytes = hi->min_supported_packet_bytes =
+ ETHERNET_MIN_PACKET_BYTES;
+ hi->max_packet_bytes = hi->max_supported_packet_bytes =
+ ETHERNET_MAX_PACKET_BYTES;
hi->per_packet_overhead_bytes =
/* preamble */ 8 + /* inter frame gap */ 12;
}
return error;
}
-
+
void
ethernet_delete_interface (vnet_main_t * vnm, u32 hw_if_index)
{
- ethernet_main_t * em = ðernet_main;
- ethernet_interface_t * ei;
- vnet_hw_interface_t * hi;
- main_intf_t * main_intf;
- vlan_table_t * vlan_table;
- u32 idx;
+ ethernet_main_t *em = ðernet_main;
+ ethernet_interface_t *ei;
+ vnet_hw_interface_t *hi;
+ main_intf_t *main_intf;
+ vlan_table_t *vlan_table;
+ u32 idx;
hi = vnet_get_hw_interface (vnm, hw_if_index);
ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
/* Delete vlan mapping table for dot1q and dot1ad. */
main_intf = vec_elt_at_index (em->main_intfs, hi->hw_if_index);
- if (main_intf->dot1q_vlans) {
- vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1q_vlans);
- for (idx=0; idx<ETHERNET_N_VLAN; idx++ ) {
- if (vlan_table->vlans[idx].qinqs) {
- pool_put_index(em->qinq_pool, vlan_table->vlans[idx].qinqs);
- }
+ if (main_intf->dot1q_vlans)
+ {
+ vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1q_vlans);
+ for (idx = 0; idx < ETHERNET_N_VLAN; idx++)
+ {
+ if (vlan_table->vlans[idx].qinqs)
+ {
+ pool_put_index (em->qinq_pool, vlan_table->vlans[idx].qinqs);
+ }
+ }
+ pool_put_index (em->vlan_pool, main_intf->dot1q_vlans);
}
- pool_put_index(em->vlan_pool, main_intf->dot1q_vlans);
- }
- if (main_intf->dot1ad_vlans) {
- vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1ad_vlans);
- for (idx=0; idx<ETHERNET_N_VLAN; idx++ ) {
- if (vlan_table->vlans[idx].qinqs) {
- pool_put_index(em->qinq_pool, vlan_table->vlans[idx].qinqs);
- }
+ if (main_intf->dot1ad_vlans)
+ {
+ vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1ad_vlans);
+ for (idx = 0; idx < ETHERNET_N_VLAN; idx++)
+ {
+ if (vlan_table->vlans[idx].qinqs)
+ {
+ pool_put_index (em->qinq_pool, vlan_table->vlans[idx].qinqs);
+ }
+ }
+ pool_put_index (em->vlan_pool, main_intf->dot1ad_vlans);
}
- pool_put_index(em->vlan_pool, main_intf->dot1ad_vlans);
- }
-
+
vnet_delete_hw_interface (vnm, hw_if_index);
pool_put (em->interfaces, ei);
}
-u32
+u32
ethernet_set_flags (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
{
- ethernet_main_t * em = ðernet_main;
- vnet_hw_interface_t * hi;
- ethernet_interface_t * ei;
-
+ ethernet_main_t *em = ðernet_main;
+ vnet_hw_interface_t *hi;
+ ethernet_interface_t *ei;
+
hi = vnet_get_hw_interface (vnm, hw_if_index);
ASSERT (hi->hw_class_index == ethernet_hw_interface_class.index);
ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
if (ei->flag_change)
return ei->flag_change (vnm, hi, flags);
- return (u32)~0;
+ return (u32) ~ 0;
}
/* Echo packets back to ethernet/l2-input. */
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
- u32 n_left_from, n_left_to_next, n_copy, * from, * to_next;
+ u32 n_left_from, n_left_to_next, n_copy, *from, *to_next;
u32 next_index = VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT;
u32 i, next_node_index, bvi_flag, sw_if_index;
u32 n_pkts = 0, n_bytes = 0;
u32 cpu_index = vm->cpu_index;
- vnet_main_t * vnm = vnet_get_main();
- vnet_interface_main_t * im = &vnm->interface_main;
- vlib_node_main_t * nm = &vm->node_main;
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_interface_main_t *im = &vnm->interface_main;
+ vlib_node_main_t *nm = &vm->node_main;
vlib_node_t *loop_node;
- vlib_buffer_t * b;
+ vlib_buffer_t *b;
// check tx node index, it is ethernet-input on loopback create
// but can be changed to l2-input if loopback is configured as
// BVI of a BD (Bridge Domain).
loop_node = vec_elt (nm->nodes, node->node_index);
next_node_index = loop_node->next_nodes[next_index];
- bvi_flag = (next_node_index == l2input_node.index)? 1 : 0;
+ bvi_flag = (next_node_index == l2input_node.index) ? 1 : 0;
n_left_from = frame->n_vectors;
from = vlib_frame_args (frame);
n_left_from -= n_copy;
i = 0;
b = vlib_get_buffer (vm, from[i]);
- sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
+ sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
while (1)
{
// Set up RX and TX indices as if received from a real driver
// unless loopback is used as a BVI. For BVI case, leave TX index
// and update l2_len in packet as required for l2 forwarding path
vnet_buffer (b)->sw_if_index[VLIB_RX] = sw_if_index;
- if (bvi_flag) vnet_update_l2_len(b);
- else vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32) ~0;
+ if (bvi_flag)
+ vnet_update_l2_len (b);
+ else
+ vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32) ~ 0;
i++;
n_pkts++;
n_bytes += vlib_buffer_length_in_chain (vm, b);
- if (i < n_copy) b = vlib_get_buffer (vm, from[i]);
- else break;
+ if (i < n_copy)
+ b = vlib_get_buffer (vm, from[i]);
+ else
+ break;
}
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
/* increment TX interface stat */
- vlib_increment_combined_counter (
- im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX,
- cpu_index, sw_if_index, n_pkts, n_bytes);
+ vlib_increment_combined_counter (im->combined_sw_if_counters +
+ VNET_INTERFACE_COUNTER_TX, cpu_index,
+ sw_if_index, n_pkts, n_bytes);
}
return n_left_from;
}
-static u8 * format_simulated_ethernet_name (u8 * s, va_list * args)
+static u8 *
+format_simulated_ethernet_name (u8 * s, va_list * args)
{
u32 dev_instance = va_arg (*args, u32);
return format (s, "loop%d", dev_instance);
}
static clib_error_t *
-simulated_ethernet_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
+simulated_ethernet_admin_up_down (vnet_main_t * vnm, u32 hw_if_index,
+ u32 flags)
{
u32 hw_flags = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
- VNET_HW_INTERFACE_FLAG_LINK_UP : 0;
+ VNET_HW_INTERFACE_FLAG_LINK_UP : 0;
vnet_hw_interface_set_flags (vnm, hw_if_index, hw_flags);
return 0;
}
+/* *INDENT-OFF* */
VNET_DEVICE_CLASS (ethernet_simulated_device_class) = {
.name = "Loopback",
.format_device_name = format_simulated_ethernet_name,
.admin_up_down_function = simulated_ethernet_admin_up_down,
.no_flatten_output_chains = 1,
};
+/* *INDENT-ON* */
-int vnet_create_loopback_interface (u32 * sw_if_indexp, u8 *mac_address)
+int
+vnet_create_loopback_interface (u32 * sw_if_indexp, u8 * mac_address)
{
- vnet_main_t * vnm = vnet_get_main();
- vlib_main_t * vm = vlib_get_main();
- clib_error_t * error;
+ vnet_main_t *vnm = vnet_get_main ();
+ vlib_main_t *vm = vlib_get_main ();
+ clib_error_t *error;
static u32 instance;
u8 address[6];
u32 hw_if_index;
- vnet_hw_interface_t * hw_if;
+ vnet_hw_interface_t *hw_if;
u32 slot;
int rv = 0;
- ASSERT(sw_if_indexp);
+ ASSERT (sw_if_indexp);
- *sw_if_indexp = (u32)~0;
+ *sw_if_indexp = (u32) ~ 0;
memset (address, 0, sizeof (address));
error = ethernet_register_interface
(vnm,
- ethernet_simulated_device_class.index,
- instance++,
- address,
- &hw_if_index,
+ ethernet_simulated_device_class.index, instance++, address, &hw_if_index,
/* flag change */ 0);
if (error)
{
rv = VNET_API_ERROR_INVALID_REGISTRATION;
- clib_error_report(error);
+ clib_error_report (error);
return rv;
}
hw_if = vnet_get_hw_interface (vnm, hw_if_index);
slot = vlib_node_add_named_next_with_slot
(vm, hw_if->tx_node_index,
- "ethernet-input",
- VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT);
+ "ethernet-input", VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT);
ASSERT (slot == VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT);
{
- vnet_sw_interface_t * si = vnet_get_hw_sw_interface (vnm, hw_if_index);
+ vnet_sw_interface_t *si = vnet_get_hw_sw_interface (vnm, hw_if_index);
*sw_if_indexp = si->sw_if_index;
}
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "mac %U", unformat_ethernet_address, mac_address))
- ;
+ ;
else
- break;
+ break;
}
rv = vnet_create_loopback_interface (&sw_if_index, mac_address);
if (rv)
return clib_error_return (0, "vnet_create_loopback_interface failed");
- vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), sw_if_index);
+ vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main (),
+ sw_if_index);
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (create_simulated_ethernet_interface_command, static) = {
.path = "loopback create-interface",
.short_help = "Create Loopback ethernet interface [mac <mac-addr>]",
.function = create_simulated_ethernet_interfaces,
};
+/* *INDENT-ON* */
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (create_loopback_interface_command, static) = {
.path = "create loopback interface",
.short_help = "create loopback interface [mac <mac-addr>]",
.function = create_simulated_ethernet_interfaces,
};
+/* *INDENT-ON* */
ethernet_interface_t *
ethernet_get_interface (ethernet_main_t * em, u32 hw_if_index)
{
- vnet_hw_interface_t * i = vnet_get_hw_interface (vnet_get_main(), hw_if_index);
- return (i->hw_class_index == ethernet_hw_interface_class.index
- ? pool_elt_at_index (em->interfaces, i->hw_instance)
- : 0);
+ vnet_hw_interface_t *i =
+ vnet_get_hw_interface (vnet_get_main (), hw_if_index);
+ return (i->hw_class_index ==
+ ethernet_hw_interface_class.
+ index ? pool_elt_at_index (em->interfaces, i->hw_instance) : 0);
}
-int vnet_delete_loopback_interface (u32 sw_if_index)
+int
+vnet_delete_loopback_interface (u32 sw_if_index)
{
- vnet_main_t * vnm = vnet_get_main();
- vnet_sw_interface_t * si;
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_sw_interface_t *si;
- if (pool_is_free_index (vnm->interface_main.sw_interfaces,
- sw_if_index))
+ if (pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index))
return VNET_API_ERROR_INVALID_SW_IF_INDEX;
si = vnet_get_sw_interface (vnm, sw_if_index);
{
int rv;
u32 sw_if_index = ~0;
- vnet_main_t * vnm = vnet_get_main();
+ vnet_main_t *vnm = vnet_get_main ();
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "intfc %U",
- unformat_vnet_sw_interface, vnm, &sw_if_index))
- ;
+ unformat_vnet_sw_interface, vnm, &sw_if_index))
+ ;
else
- break;
+ break;
}
if (sw_if_index == ~0)
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (delete_simulated_ethernet_interface_command, static) = {
.path = "loopback delete-interface",
.short_help = "Delete Loopback ethernet interface intfc <interface>",
.function = delete_simulated_ethernet_interfaces,
};
+/* *INDENT-ON* */
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (delete_loopback_interface_command, static) = {
.path = "delete loopback interface",
.short_help = "delete loopback interface intfc <interface>",
.function = delete_simulated_ethernet_interfaces,
};
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
#include <vnet/devices/pci/ixge.h>
#include <vnet/devices/pci/ixgev.h>
-typedef struct {
+typedef struct
+{
u32 cached_next_index;
u32 cached_sw_if_index;
/* Hash table to map sw_if_index to next node index */
- uword * next_node_index_by_sw_if_index;
+ uword *next_node_index_by_sw_if_index;
/* convenience */
- vlib_main_t * vlib_main;
- vnet_main_t * vnet_main;
+ vlib_main_t *vlib_main;
+ vnet_main_t *vnet_main;
} mac_swap_main_t;
-typedef struct {
+typedef struct
+{
u8 src[6];
u8 dst[6];
u32 sw_if_index;
} swap_trace_t;
/* packet trace format function */
-static u8 * format_swap_trace (u8 * s, va_list * args)
+static u8 *
+format_swap_trace (u8 * s, va_list * args)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
- swap_trace_t * t = va_arg (*args, swap_trace_t *);
-
+ swap_trace_t *t = va_arg (*args, swap_trace_t *);
+
s = format (s, "SWAP: dst now %U src now %U sw_if_index %d next_index %d",
- format_ethernet_address, t->dst,
- format_ethernet_address, t->src,
- t->sw_if_index,
- t->next_index);
+ format_ethernet_address, t->dst,
+ format_ethernet_address, t->src, t->sw_if_index, t->next_index);
return s;
}
#define foreach_mac_swap_error \
_(SWAPS, "mac addresses swapped")
-typedef enum {
+typedef enum
+{
#define _(sym,str) MAC_SWAP_ERROR_##sym,
foreach_mac_swap_error
#undef _
- MAC_SWAP_N_ERROR,
+ MAC_SWAP_N_ERROR,
} mac_swap_error_t;
-static char * mac_swap_error_strings[] = {
+static char *mac_swap_error_strings[] = {
#define _(sym,string) string,
foreach_mac_swap_error
#undef _
*
*/
-typedef enum {
+typedef enum
+{
MAC_SWAP_NEXT_DROP,
MAC_SWAP_N_NEXT,
} mac_swap_next_t;
static uword
mac_swap_node_fn (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- u32 n_left_from, * from, * to_next;
+ u32 n_left_from, *from, *to_next;
mac_swap_next_t next_index;
- mac_swap_main_t * msm = &mac_swap_main;
+ mac_swap_main_t *msm = &mac_swap_main;
vlib_node_t *n = vlib_get_node (vm, mac_swap_node.index);
u32 node_counter_base_index = n->error_heap_index;
- vlib_error_main_t * em = &vm->error_main;
+ vlib_error_main_t *em = &vm->error_main;
from = vlib_frame_vector_args (frame);
n_left_from = frame->n_vectors;
{
u32 n_left_to_next;
- vlib_get_next_frame (vm, node, next_index,
- to_next, n_left_to_next);
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
while (n_left_from >= 4 && n_left_to_next >= 2)
{
- u32 bi0, bi1;
- vlib_buffer_t * b0, * b1;
- u32 next0, next1;
- u32 sw_if_index0, sw_if_index1;
- uword * p0, * p1;
- u64 tmp0a, tmp0b;
- u64 tmp1a, tmp1b;
- ethernet_header_t * h0, *h1;
-
-
+ u32 bi0, bi1;
+ vlib_buffer_t *b0, *b1;
+ u32 next0, next1;
+ u32 sw_if_index0, sw_if_index1;
+ uword *p0, *p1;
+ u64 tmp0a, tmp0b;
+ u64 tmp1a, tmp1b;
+ ethernet_header_t *h0, *h1;
+
+
/* Prefetch next iteration. */
{
- vlib_buffer_t * p2, * p3;
-
+ vlib_buffer_t *p2, *p3;
+
p2 = vlib_get_buffer (vm, from[2]);
p3 = vlib_get_buffer (vm, from[3]);
-
+
vlib_prefetch_buffer_header (p2, LOAD);
vlib_prefetch_buffer_header (p3, LOAD);
b0 = vlib_get_buffer (vm, bi0);
b1 = vlib_get_buffer (vm, bi1);
- sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
- next0 = msm->cached_next_index;
- sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX];
- next1 = msm->cached_next_index;
-
- if (PREDICT_FALSE (msm->cached_sw_if_index != sw_if_index0))
- {
- p0 = hash_get (msm->next_node_index_by_sw_if_index, sw_if_index0);
- if (p0 == 0)
- {
- vnet_hw_interface_t *hw0;
-
- hw0 = vnet_get_sup_hw_interface (msm->vnet_main,
- sw_if_index0);
-
- next0 = vlib_node_add_next (msm->vlib_main,
- mac_swap_node.index,
- hw0->output_node_index);
- hash_set (msm->next_node_index_by_sw_if_index,
- sw_if_index0, next0);
- }
- else
- next0 = p0[0];
- msm->cached_sw_if_index = sw_if_index0;
- msm->cached_next_index = next0;
- next1 = next0;
- }
- if (PREDICT_FALSE (msm->cached_sw_if_index != sw_if_index1))
- {
- p1 = hash_get (msm->next_node_index_by_sw_if_index, sw_if_index1);
- if (p1 == 0)
- {
- vnet_hw_interface_t *hw1;
-
- hw1 = vnet_get_sup_hw_interface (msm->vnet_main,
- sw_if_index1);
-
- next1 = vlib_node_add_next (msm->vlib_main,
- mac_swap_node.index,
- hw1->output_node_index);
- hash_set (msm->next_node_index_by_sw_if_index,
- sw_if_index1, next1);
- }
- else
- next1 = p1[0];
- msm->cached_sw_if_index = sw_if_index1;
- msm->cached_next_index = next1;
- }
-
- em->counters[node_counter_base_index + MAC_SWAP_ERROR_SWAPS] += 2;
-
- /* reset buffer so we always point at the MAC hdr */
- vlib_buffer_reset (b0);
- vlib_buffer_reset (b1);
- h0 = vlib_buffer_get_current (b0);
- h1 = vlib_buffer_get_current (b1);
-
- /* Swap 2 x src and dst mac addresses using 8-byte load/stores */
- tmp0a = clib_net_to_host_u64(((u64 *)(h0->dst_address))[0]);
- tmp1a = clib_net_to_host_u64(((u64 *)(h1->dst_address))[0]);
- tmp0b = clib_net_to_host_u64(((u64 *)(h0->src_address))[0]);
- tmp1b = clib_net_to_host_u64(((u64 *)(h1->src_address))[0]);
- ((u64 *)(h0->dst_address))[0] = clib_host_to_net_u64(tmp0b);
- ((u64 *)(h1->dst_address))[0] = clib_host_to_net_u64(tmp1b);
- /* Move the ethertype from "b" to "a" */
- tmp0a &= ~(0xFFFF);
- tmp1a &= ~(0xFFFF);
- tmp0a |= tmp0b & 0xFFFF;
- ((u64 *)(h0->src_address))[0] = clib_host_to_net_u64(tmp0a);
- tmp1a |= tmp1b & 0xFFFF;
- ((u64 *)(h1->src_address))[0] = clib_host_to_net_u64(tmp1a);
-
- if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)))
- {
- if (b0->flags & VLIB_BUFFER_IS_TRACED)
- {
- swap_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
- clib_memcpy (t->src, h0->src_address, 6);
- clib_memcpy (t->dst, h0->dst_address, 6);
- t->sw_if_index = sw_if_index0;
- t->next_index = next0;
- }
- if (b1->flags & VLIB_BUFFER_IS_TRACED)
- {
- swap_trace_t *t = vlib_add_trace (vm, node, b1, sizeof (*t));
- clib_memcpy (t->src, h1->src_address, 6);
- clib_memcpy (t->dst, h1->dst_address, 6);
- t->sw_if_index = sw_if_index1;
- t->next_index = next1;
- }
- }
-
- vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
- to_next, n_left_to_next,
- bi0, bi1, next0, next1);
- }
-
+ sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ next0 = msm->cached_next_index;
+ sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
+ next1 = msm->cached_next_index;
+
+ if (PREDICT_FALSE (msm->cached_sw_if_index != sw_if_index0))
+ {
+ p0 =
+ hash_get (msm->next_node_index_by_sw_if_index, sw_if_index0);
+ if (p0 == 0)
+ {
+ vnet_hw_interface_t *hw0;
+
+ hw0 = vnet_get_sup_hw_interface (msm->vnet_main,
+ sw_if_index0);
+
+ next0 = vlib_node_add_next (msm->vlib_main,
+ mac_swap_node.index,
+ hw0->output_node_index);
+ hash_set (msm->next_node_index_by_sw_if_index,
+ sw_if_index0, next0);
+ }
+ else
+ next0 = p0[0];
+ msm->cached_sw_if_index = sw_if_index0;
+ msm->cached_next_index = next0;
+ next1 = next0;
+ }
+ if (PREDICT_FALSE (msm->cached_sw_if_index != sw_if_index1))
+ {
+ p1 =
+ hash_get (msm->next_node_index_by_sw_if_index, sw_if_index1);
+ if (p1 == 0)
+ {
+ vnet_hw_interface_t *hw1;
+
+ hw1 = vnet_get_sup_hw_interface (msm->vnet_main,
+ sw_if_index1);
+
+ next1 = vlib_node_add_next (msm->vlib_main,
+ mac_swap_node.index,
+ hw1->output_node_index);
+ hash_set (msm->next_node_index_by_sw_if_index,
+ sw_if_index1, next1);
+ }
+ else
+ next1 = p1[0];
+ msm->cached_sw_if_index = sw_if_index1;
+ msm->cached_next_index = next1;
+ }
+
+ em->counters[node_counter_base_index + MAC_SWAP_ERROR_SWAPS] += 2;
+
+ /* reset buffer so we always point at the MAC hdr */
+ vlib_buffer_reset (b0);
+ vlib_buffer_reset (b1);
+ h0 = vlib_buffer_get_current (b0);
+ h1 = vlib_buffer_get_current (b1);
+
+ /* Swap 2 x src and dst mac addresses using 8-byte load/stores */
+ tmp0a = clib_net_to_host_u64 (((u64 *) (h0->dst_address))[0]);
+ tmp1a = clib_net_to_host_u64 (((u64 *) (h1->dst_address))[0]);
+ tmp0b = clib_net_to_host_u64 (((u64 *) (h0->src_address))[0]);
+ tmp1b = clib_net_to_host_u64 (((u64 *) (h1->src_address))[0]);
+ ((u64 *) (h0->dst_address))[0] = clib_host_to_net_u64 (tmp0b);
+ ((u64 *) (h1->dst_address))[0] = clib_host_to_net_u64 (tmp1b);
+ /* Move the ethertype from "b" to "a" */
+ tmp0a &= ~(0xFFFF);
+ tmp1a &= ~(0xFFFF);
+ tmp0a |= tmp0b & 0xFFFF;
+ ((u64 *) (h0->src_address))[0] = clib_host_to_net_u64 (tmp0a);
+ tmp1a |= tmp1b & 0xFFFF;
+ ((u64 *) (h1->src_address))[0] = clib_host_to_net_u64 (tmp1a);
+
+ if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
+ {
+ if (b0->flags & VLIB_BUFFER_IS_TRACED)
+ {
+ swap_trace_t *t =
+ vlib_add_trace (vm, node, b0, sizeof (*t));
+ clib_memcpy (t->src, h0->src_address, 6);
+ clib_memcpy (t->dst, h0->dst_address, 6);
+ t->sw_if_index = sw_if_index0;
+ t->next_index = next0;
+ }
+ if (b1->flags & VLIB_BUFFER_IS_TRACED)
+ {
+ swap_trace_t *t =
+ vlib_add_trace (vm, node, b1, sizeof (*t));
+ clib_memcpy (t->src, h1->src_address, 6);
+ clib_memcpy (t->dst, h1->dst_address, 6);
+ t->sw_if_index = sw_if_index1;
+ t->next_index = next1;
+ }
+ }
+
+ vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
+ to_next, n_left_to_next,
+ bi0, bi1, next0, next1);
+ }
+
while (n_left_from > 0 && n_left_to_next > 0)
{
- u32 bi0;
- vlib_buffer_t * b0;
- u32 next0;
- u32 sw_if_index0;
- uword * p0;
- u64 tmp0a, tmp0b;
- ethernet_header_t * h0;
+ u32 bi0;
+ vlib_buffer_t *b0;
+ u32 next0;
+ u32 sw_if_index0;
+ uword *p0;
+ u64 tmp0a, tmp0b;
+ ethernet_header_t *h0;
bi0 = from[0];
to_next[0] = bi0;
b0 = vlib_get_buffer (vm, bi0);
- sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
- next0 = msm->cached_next_index;
-
- if (PREDICT_FALSE (msm->cached_sw_if_index != sw_if_index0))
- {
- p0 = hash_get (msm->next_node_index_by_sw_if_index, sw_if_index0);
- if (p0 == 0)
- {
- vnet_hw_interface_t *hw0;
-
- hw0 = vnet_get_sup_hw_interface (msm->vnet_main,
- sw_if_index0);
-
- next0 = vlib_node_add_next (msm->vlib_main,
- mac_swap_node.index,
- hw0->output_node_index);
- hash_set (msm->next_node_index_by_sw_if_index,
- sw_if_index0, next0);
- }
- else
- next0 = p0[0];
- msm->cached_sw_if_index = sw_if_index0;
- msm->cached_next_index = next0;
- }
-
- em->counters[node_counter_base_index + MAC_SWAP_ERROR_SWAPS] += 1;
-
- /* reset buffer so we always point at the MAC hdr */
- vlib_buffer_reset (b0);
- h0 = vlib_buffer_get_current (b0);
-
- /* Exchange src and dst, preserve the ethertype */
- tmp0a = clib_net_to_host_u64(((u64 *)(h0->dst_address))[0]);
- tmp0b = clib_net_to_host_u64(((u64 *)(h0->src_address))[0]);
- ((u64 *)(h0->dst_address))[0] = clib_host_to_net_u64(tmp0b);
- tmp0a &= ~(0xFFFF);
- tmp0a |= tmp0b & 0xFFFF;
- ((u64 *)(h0->src_address))[0] = clib_host_to_net_u64(tmp0a);
-
- /* ship it */
- if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
- && (b0->flags & VLIB_BUFFER_IS_TRACED))) {
- swap_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
- clib_memcpy (t->src, h0->src_address, 6);
- clib_memcpy (t->dst, h0->dst_address, 6);
- t->sw_if_index = sw_if_index0;
- t->next_index = next0;
- }
-
+ sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ next0 = msm->cached_next_index;
+
+ if (PREDICT_FALSE (msm->cached_sw_if_index != sw_if_index0))
+ {
+ p0 =
+ hash_get (msm->next_node_index_by_sw_if_index, sw_if_index0);
+ if (p0 == 0)
+ {
+ vnet_hw_interface_t *hw0;
+
+ hw0 = vnet_get_sup_hw_interface (msm->vnet_main,
+ sw_if_index0);
+
+ next0 = vlib_node_add_next (msm->vlib_main,
+ mac_swap_node.index,
+ hw0->output_node_index);
+ hash_set (msm->next_node_index_by_sw_if_index,
+ sw_if_index0, next0);
+ }
+ else
+ next0 = p0[0];
+ msm->cached_sw_if_index = sw_if_index0;
+ msm->cached_next_index = next0;
+ }
+
+ em->counters[node_counter_base_index + MAC_SWAP_ERROR_SWAPS] += 1;
+
+ /* reset buffer so we always point at the MAC hdr */
+ vlib_buffer_reset (b0);
+ h0 = vlib_buffer_get_current (b0);
+
+ /* Exchange src and dst, preserve the ethertype */
+ tmp0a = clib_net_to_host_u64 (((u64 *) (h0->dst_address))[0]);
+ tmp0b = clib_net_to_host_u64 (((u64 *) (h0->src_address))[0]);
+ ((u64 *) (h0->dst_address))[0] = clib_host_to_net_u64 (tmp0b);
+ tmp0a &= ~(0xFFFF);
+ tmp0a |= tmp0b & 0xFFFF;
+ ((u64 *) (h0->src_address))[0] = clib_host_to_net_u64 (tmp0a);
+
+ /* ship it */
+ if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+ && (b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ swap_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ clib_memcpy (t->src, h0->src_address, 6);
+ clib_memcpy (t->dst, h0->dst_address, 6);
+ t->sw_if_index = sw_if_index0;
+ t->next_index = next0;
+ }
+
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
to_next, n_left_to_next,
bi0, next0);
return frame->n_vectors;
}
+/* *INDENT-OFF* */
VLIB_REGISTER_NODE (mac_swap_node,static) = {
.function = mac_swap_node_fn,
.name = "mac-swap",
[MAC_SWAP_NEXT_DROP] = "error-drop",
},
};
+/* *INDENT-ON* */
-clib_error_t *mac_swap_init (vlib_main_t *vm)
+clib_error_t *
+mac_swap_init (vlib_main_t * vm)
{
- mac_swap_main_t * msm = &mac_swap_main;
-
+ mac_swap_main_t *msm = &mac_swap_main;
+
msm->next_node_index_by_sw_if_index = hash_create (0, sizeof (uword));
- msm->cached_next_index = (u32)~0;
- msm->cached_sw_if_index = (u32)~0;
+ msm->cached_next_index = (u32) ~ 0;
+ msm->cached_sw_if_index = (u32) ~ 0;
msm->vlib_main = vm;
- msm->vnet_main = vnet_get_main();
+ msm->vnet_main = vnet_get_main ();
/* Driver RX nodes send pkts here... */
#define _(a) ixge_set_next_node (IXGE_RX_NEXT_##a##_INPUT, "mac-swap");
foreach_hw_driver_next
#undef _
#define _(a) ixgev_set_next_node (IXGEV_RX_NEXT_##a##_INPUT, "mac-swap");
- foreach_hw_driver_next
+ foreach_hw_driver_next
#undef _
#define _(a) ige_set_next_node (IGE_RX_NEXT_##a##_INPUT, "mac-swap");
- foreach_hw_driver_next
+ foreach_hw_driver_next
#undef _
-
- return 0;
+ return 0;
}
VLIB_INIT_FUNCTION (mac_swap_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
#define foreach_ethernet_input_next \
_ (PUNT, "error-punt") \
_ (DROP, "error-drop") \
- _ (LLC, "llc-input")
+ _ (LLC, "llc-input")
-typedef enum {
+typedef enum
+{
#define _(s,n) ETHERNET_INPUT_NEXT_##s,
foreach_ethernet_input_next
#undef _
- ETHERNET_INPUT_N_NEXT,
+ ETHERNET_INPUT_N_NEXT,
} ethernet_input_next_t;
-typedef struct {
+typedef struct
+{
u8 packet_data[32];
} ethernet_input_trace_t;
-static u8 * format_ethernet_input_trace (u8 * s, va_list * va)
+static u8 *
+format_ethernet_input_trace (u8 * s, va_list * va)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
- ethernet_input_trace_t * t = va_arg (*va, ethernet_input_trace_t *);
+ ethernet_input_trace_t *t = va_arg (*va, ethernet_input_trace_t *);
s = format (s, "%U", format_ethernet_header, t->packet_data);
vlib_node_registration_t ethernet_input_node;
-typedef enum {
+typedef enum
+{
ETHERNET_INPUT_VARIANT_ETHERNET,
ETHERNET_INPUT_VARIANT_ETHERNET_TYPE,
ETHERNET_INPUT_VARIANT_NOT_L2,
// Parse the ethernet header to extract vlan tags and innermost ethertype
static_always_inline void
parse_header (ethernet_input_variant_t variant,
- vlib_buffer_t * b0,
- u16 * type,
- u16 * orig_type,
- u16 * outer_id,
- u16 * inner_id,
- u32 * match_flags) {
+ vlib_buffer_t * b0,
+ u16 * type,
+ u16 * orig_type,
+ u16 * outer_id, u16 * inner_id, u32 * match_flags)
+{
u8 vlan_count;
- if (variant == ETHERNET_INPUT_VARIANT_ETHERNET
- || variant == ETHERNET_INPUT_VARIANT_NOT_L2) {
- ethernet_header_t * e0;
+ if (variant == ETHERNET_INPUT_VARIANT_ETHERNET
+ || variant == ETHERNET_INPUT_VARIANT_NOT_L2)
+ {
+ ethernet_header_t *e0;
- e0 = (void *) (b0->data + b0->current_data);
+ e0 = (void *) (b0->data + b0->current_data);
- vnet_buffer (b0)->ethernet.start_of_ethernet_header = b0->current_data;
+ vnet_buffer (b0)->ethernet.start_of_ethernet_header = b0->current_data;
- vlib_buffer_advance (b0, sizeof (e0[0]));
+ vlib_buffer_advance (b0, sizeof (e0[0]));
- *type = clib_net_to_host_u16(e0->type);
- } else if (variant == ETHERNET_INPUT_VARIANT_ETHERNET_TYPE) {
- // here when prior node was LLC/SNAP processing
- u16 * e0;
+ *type = clib_net_to_host_u16 (e0->type);
+ }
+ else if (variant == ETHERNET_INPUT_VARIANT_ETHERNET_TYPE)
+ {
+ // here when prior node was LLC/SNAP processing
+ u16 *e0;
- e0 = (void *) (b0->data + b0->current_data);
+ e0 = (void *) (b0->data + b0->current_data);
- vlib_buffer_advance (b0, sizeof (e0[0]));
+ vlib_buffer_advance (b0, sizeof (e0[0]));
- *type = clib_net_to_host_u16(e0[0]);
- }
+ *type = clib_net_to_host_u16 (e0[0]);
+ }
// save for distinguishing between dot1q and dot1ad later
*orig_type = *type;
(*type == ETHERNET_TYPE_DOT1AD) ||
(*type == ETHERNET_TYPE_VLAN_9100) ||
(*type == ETHERNET_TYPE_VLAN_9200))
- {
- ethernet_vlan_header_t * h0;
- u16 tag;
-
- *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_1_TAG;
+ {
+ ethernet_vlan_header_t *h0;
+ u16 tag;
- h0 = (void *) (b0->data + b0->current_data);
+ *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_1_TAG;
- tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
+ h0 = (void *) (b0->data + b0->current_data);
- *outer_id = tag & 0xfff;
+ tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
- *type = clib_net_to_host_u16(h0->type);
+ *outer_id = tag & 0xfff;
- vlib_buffer_advance (b0, sizeof (h0[0]));
- vlan_count = 1;
+ *type = clib_net_to_host_u16 (h0->type);
- if (*type == ETHERNET_TYPE_VLAN) {
- // Double tagged packet
- *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_2_TAG;
+ vlib_buffer_advance (b0, sizeof (h0[0]));
+ vlan_count = 1;
- h0 = (void *) (b0->data + b0->current_data);
+ if (*type == ETHERNET_TYPE_VLAN)
+ {
+ // Double tagged packet
+ *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_2_TAG;
- tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
+ h0 = (void *) (b0->data + b0->current_data);
- *inner_id = tag & 0xfff;
+ tag = clib_net_to_host_u16 (h0->priority_cfi_and_id);
- *type = clib_net_to_host_u16(h0->type);
+ *inner_id = tag & 0xfff;
- vlib_buffer_advance (b0, sizeof (h0[0]));
- vlan_count = 2;
+ *type = clib_net_to_host_u16 (h0->type);
+
+ vlib_buffer_advance (b0, sizeof (h0[0]));
+ vlan_count = 2;
- if (*type == ETHERNET_TYPE_VLAN) {
- // More than double tagged packet
- *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_3_TAG;
- vlan_count = 3; // "unknown" number, aka, 3-or-more
- }
+ if (*type == ETHERNET_TYPE_VLAN)
+ {
+ // More than double tagged packet
+ *match_flags = SUBINT_CONFIG_VALID | SUBINT_CONFIG_MATCH_3_TAG;
+ vlan_count = 3; // "unknown" number, aka, 3-or-more
+ }
+ }
}
- }
- ethernet_buffer_set_vlan_count(b0, vlan_count);
+ ethernet_buffer_set_vlan_count (b0, vlan_count);
}
// Determine the subinterface for this packet, given the result of the
// matches first.
static_always_inline void
identify_subint (vnet_hw_interface_t * hi,
- vlib_buffer_t * b0,
- u32 match_flags,
- main_intf_t * main_intf,
- vlan_intf_t * vlan_intf,
- qinq_intf_t * qinq_intf,
- u32 * new_sw_if_index,
- u8 * error0,
- u32 * is_l2)
+ vlib_buffer_t * b0,
+ u32 match_flags,
+ main_intf_t * main_intf,
+ vlan_intf_t * vlan_intf,
+ qinq_intf_t * qinq_intf,
+ u32 * new_sw_if_index, u8 * error0, u32 * is_l2)
{
u32 matched;
- matched = eth_identify_subint (hi, b0, match_flags,
- main_intf, vlan_intf, qinq_intf,
- new_sw_if_index, error0, is_l2);
+ matched = eth_identify_subint (hi, b0, match_flags,
+ main_intf, vlan_intf, qinq_intf,
+ new_sw_if_index, error0, is_l2);
- if (matched) {
+ if (matched)
+ {
- // Perform L3 my-mac filter
- // A unicast packet arriving on an L3 interface must have a dmac matching the interface mac.
- // This is required for promiscuous mode, else we will forward packets we aren't supposed to.
- if (!(*is_l2)) {
- ethernet_header_t * e0;
- e0 = (void *) (b0->data + vnet_buffer (b0)->ethernet.start_of_ethernet_header);
+ // Perform L3 my-mac filter
+ // A unicast packet arriving on an L3 interface must have a dmac matching the interface mac.
+ // This is required for promiscuous mode, else we will forward packets we aren't supposed to.
+ if (!(*is_l2))
+ {
+ ethernet_header_t *e0;
+ e0 =
+ (void *) (b0->data +
+ vnet_buffer (b0)->ethernet.start_of_ethernet_header);
+
+ if (!(ethernet_address_cast (e0->dst_address)))
+ {
+ if (!eth_mac_equal ((u8 *) e0, hi->hw_address))
+ {
+ *error0 = ETHERNET_ERROR_L3_MAC_MISMATCH;
+ }
+ }
+ }
- if (!(ethernet_address_cast(e0->dst_address))) {
- if (!eth_mac_equal((u8 *)e0, hi->hw_address)) {
- *error0 = ETHERNET_ERROR_L3_MAC_MISMATCH;
- }
- }
+ // Check for down subinterface
+ *error0 = (*new_sw_if_index) != ~0 ? (*error0) : ETHERNET_ERROR_DOWN;
}
-
- // Check for down subinterface
- *error0 = (*new_sw_if_index) != ~0 ? (*error0) : ETHERNET_ERROR_DOWN;
- }
}
static_always_inline void
determine_next_node (ethernet_main_t * em,
- ethernet_input_variant_t variant,
- u32 is_l20,
- u32 type0,
- vlib_buffer_t * b0,
- u8 * error0,
- u8 * next0)
+ ethernet_input_variant_t variant,
+ u32 is_l20,
+ u32 type0, vlib_buffer_t * b0, u8 * error0, u8 * next0)
{
- if (PREDICT_FALSE (*error0 != ETHERNET_ERROR_NONE)) {
- // some error occurred
- *next0 = ETHERNET_INPUT_NEXT_DROP;
- } else if (is_l20) {
- *next0 = em->l2_next;
- // record the L2 len and reset the buffer so the L2 header is preserved
- vnet_buffer(b0)->l2.l2_len = b0->current_data;
- vlib_buffer_advance(b0, - ethernet_buffer_header_size(b0));
-
- // check for common IP/MPLS ethertypes
- } else if (type0 == ETHERNET_TYPE_IP4) {
- *next0 = em->l3_next.input_next_ip4;
- } else if (type0 == ETHERNET_TYPE_IP6) {
- *next0 = em->l3_next.input_next_ip6;
- } else if (type0 == ETHERNET_TYPE_MPLS_UNICAST) {
- *next0 = em->l3_next.input_next_mpls;
-
- } else if (em->redirect_l3) {
- // L3 Redirect is on, the cached common next nodes will be
- // pointing to the redirect node, catch the uncommon types here
- *next0 = em->redirect_l3_next;
- } else {
- // uncommon ethertype, check table
- u32 i0;
- i0 = sparse_vec_index (em->l3_next.input_next_by_type, type0);
- *next0 = vec_elt (em->l3_next.input_next_by_type, i0);
- *error0 = i0 == SPARSE_VEC_INVALID_INDEX ? ETHERNET_ERROR_UNKNOWN_TYPE : *error0;
-
- // The table is not populated with LLC values, so check that now.
- // If variant is variant_ethernet then we came from LLC processing. Don't
- // go back there; drop instead using by keeping the drop/bad table result.
- if ((type0 < 0x600) && (variant == ETHERNET_INPUT_VARIANT_ETHERNET)) {
- *next0 = ETHERNET_INPUT_NEXT_LLC;
+ if (PREDICT_FALSE (*error0 != ETHERNET_ERROR_NONE))
+ {
+ // some error occurred
+ *next0 = ETHERNET_INPUT_NEXT_DROP;
+ }
+ else if (is_l20)
+ {
+ *next0 = em->l2_next;
+ // record the L2 len and reset the buffer so the L2 header is preserved
+ vnet_buffer (b0)->l2.l2_len = b0->current_data;
+ vlib_buffer_advance (b0, -ethernet_buffer_header_size (b0));
+
+ // check for common IP/MPLS ethertypes
+ }
+ else if (type0 == ETHERNET_TYPE_IP4)
+ {
+ *next0 = em->l3_next.input_next_ip4;
+ }
+ else if (type0 == ETHERNET_TYPE_IP6)
+ {
+ *next0 = em->l3_next.input_next_ip6;
+ }
+ else if (type0 == ETHERNET_TYPE_MPLS_UNICAST)
+ {
+ *next0 = em->l3_next.input_next_mpls;
+
+ }
+ else if (em->redirect_l3)
+ {
+ // L3 Redirect is on, the cached common next nodes will be
+ // pointing to the redirect node, catch the uncommon types here
+ *next0 = em->redirect_l3_next;
+ }
+ else
+ {
+ // uncommon ethertype, check table
+ u32 i0;
+ i0 = sparse_vec_index (em->l3_next.input_next_by_type, type0);
+ *next0 = vec_elt (em->l3_next.input_next_by_type, i0);
+ *error0 =
+ i0 ==
+ SPARSE_VEC_INVALID_INDEX ? ETHERNET_ERROR_UNKNOWN_TYPE : *error0;
+
+ // The table is not populated with LLC values, so check that now.
+ // If variant is variant_ethernet then we came from LLC processing. Don't
+ // go back there; drop instead using by keeping the drop/bad table result.
+ if ((type0 < 0x600) && (variant == ETHERNET_INPUT_VARIANT_ETHERNET))
+ {
+ *next0 = ETHERNET_INPUT_NEXT_LLC;
+ }
}
- }
}
static_always_inline uword
vlib_frame_t * from_frame,
ethernet_input_variant_t variant)
{
- vnet_main_t * vnm = vnet_get_main();
- ethernet_main_t * em = ðernet_main;
- vlib_node_runtime_t * error_node;
- u32 n_left_from, next_index, * from, * to_next;
+ vnet_main_t *vnm = vnet_get_main ();
+ ethernet_main_t *em = ðernet_main;
+ vlib_node_runtime_t *error_node;
+ u32 n_left_from, next_index, *from, *to_next;
u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
- u32 cpu_index = os_get_cpu_number();
+ u32 cpu_index = os_get_cpu_number ();
if (variant != ETHERNET_INPUT_VARIANT_ETHERNET)
error_node = vlib_node_get_runtime (vm, ethernet_input_node.index);
while (n_left_from >= 4 && n_left_to_next >= 2)
{
u32 bi0, bi1;
- vlib_buffer_t * b0, * b1;
+ vlib_buffer_t *b0, *b1;
u8 next0, next1, error0, error1;
- u16 type0, orig_type0, type1, orig_type1;
- u16 outer_id0, inner_id0, outer_id1, inner_id1;
- u32 match_flags0, match_flags1;
- u32 old_sw_if_index0, new_sw_if_index0, len0, old_sw_if_index1, new_sw_if_index1, len1;
- vnet_hw_interface_t * hi0, * hi1;
- main_intf_t * main_intf0, * main_intf1;
- vlan_intf_t * vlan_intf0, * vlan_intf1;
- qinq_intf_t * qinq_intf0, * qinq_intf1;
- u32 is_l20, is_l21;
+ u16 type0, orig_type0, type1, orig_type1;
+ u16 outer_id0, inner_id0, outer_id1, inner_id1;
+ u32 match_flags0, match_flags1;
+ u32 old_sw_if_index0, new_sw_if_index0, len0, old_sw_if_index1,
+ new_sw_if_index1, len1;
+ vnet_hw_interface_t *hi0, *hi1;
+ main_intf_t *main_intf0, *main_intf1;
+ vlan_intf_t *vlan_intf0, *vlan_intf1;
+ qinq_intf_t *qinq_intf0, *qinq_intf1;
+ u32 is_l20, is_l21;
/* Prefetch next iteration. */
{
- vlib_buffer_t * b2, * b3;
+ vlib_buffer_t *b2, *b3;
b2 = vlib_get_buffer (vm, from[2]);
b3 = vlib_get_buffer (vm, from[3]);
error0 = error1 = ETHERNET_ERROR_NONE;
- parse_header (variant,
- b0,
- &type0,
- &orig_type0,
- &outer_id0,
- &inner_id0,
- &match_flags0);
-
- parse_header (variant,
- b1,
- &type1,
- &orig_type1,
- &outer_id1,
- &inner_id1,
- &match_flags1);
-
- old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
- old_sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
-
- eth_vlan_table_lookups (em,
- vnm,
- old_sw_if_index0,
- orig_type0,
- outer_id0,
- inner_id0,
- &hi0,
- &main_intf0,
- &vlan_intf0,
- &qinq_intf0);
-
- eth_vlan_table_lookups (em,
- vnm,
- old_sw_if_index1,
- orig_type1,
- outer_id1,
- inner_id1,
- &hi1,
- &main_intf1,
- &vlan_intf1,
- &qinq_intf1);
+ parse_header (variant,
+ b0,
+ &type0,
+ &orig_type0, &outer_id0, &inner_id0, &match_flags0);
+
+ parse_header (variant,
+ b1,
+ &type1,
+ &orig_type1, &outer_id1, &inner_id1, &match_flags1);
+
+ old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ old_sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
+
+ eth_vlan_table_lookups (em,
+ vnm,
+ old_sw_if_index0,
+ orig_type0,
+ outer_id0,
+ inner_id0,
+ &hi0,
+ &main_intf0, &vlan_intf0, &qinq_intf0);
+
+ eth_vlan_table_lookups (em,
+ vnm,
+ old_sw_if_index1,
+ orig_type1,
+ outer_id1,
+ inner_id1,
+ &hi1,
+ &main_intf1, &vlan_intf1, &qinq_intf1);
identify_subint (hi0,
- b0,
- match_flags0,
- main_intf0,
- vlan_intf0,
- qinq_intf0,
- &new_sw_if_index0,
- &error0,
- &is_l20);
+ b0,
+ match_flags0,
+ main_intf0,
+ vlan_intf0,
+ qinq_intf0, &new_sw_if_index0, &error0, &is_l20);
identify_subint (hi1,
- b1,
- match_flags1,
- main_intf1,
- vlan_intf1,
- qinq_intf1,
- &new_sw_if_index1,
- &error1,
- &is_l21);
-
- // Save RX sw_if_index for later nodes
- vnet_buffer (b0)->sw_if_index[VLIB_RX] = error0 != ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
- vnet_buffer (b1)->sw_if_index[VLIB_RX] = error1 != ETHERNET_ERROR_NONE ? old_sw_if_index1 : new_sw_if_index1;
-
- // Check if there is a stat to take (valid and non-main sw_if_index for pkt 0 or pkt 1)
- if (((new_sw_if_index0 != ~0) && (new_sw_if_index0 != old_sw_if_index0)) ||
- ((new_sw_if_index1 != ~0) && (new_sw_if_index1 != old_sw_if_index1))) {
-
- len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
- - vnet_buffer (b0)->ethernet.start_of_ethernet_header;
- len1 = vlib_buffer_length_in_chain (vm, b1) + b1->current_data
- - vnet_buffer (b1)->ethernet.start_of_ethernet_header;
-
- stats_n_packets += 2;
- stats_n_bytes += len0 + len1;
-
- if (PREDICT_FALSE (! (new_sw_if_index0 == stats_sw_if_index && new_sw_if_index1 == stats_sw_if_index)))
+ b1,
+ match_flags1,
+ main_intf1,
+ vlan_intf1,
+ qinq_intf1, &new_sw_if_index1, &error1, &is_l21);
+
+ // Save RX sw_if_index for later nodes
+ vnet_buffer (b0)->sw_if_index[VLIB_RX] =
+ error0 !=
+ ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
+ vnet_buffer (b1)->sw_if_index[VLIB_RX] =
+ error1 !=
+ ETHERNET_ERROR_NONE ? old_sw_if_index1 : new_sw_if_index1;
+
+ // Check if there is a stat to take (valid and non-main sw_if_index for pkt 0 or pkt 1)
+ if (((new_sw_if_index0 != ~0)
+ && (new_sw_if_index0 != old_sw_if_index0))
+ || ((new_sw_if_index1 != ~0)
+ && (new_sw_if_index1 != old_sw_if_index1)))
+ {
+
+ len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
+ - vnet_buffer (b0)->ethernet.start_of_ethernet_header;
+ len1 = vlib_buffer_length_in_chain (vm, b1) + b1->current_data
+ - vnet_buffer (b1)->ethernet.start_of_ethernet_header;
+
+ stats_n_packets += 2;
+ stats_n_bytes += len0 + len1;
+
+ if (PREDICT_FALSE
+ (!(new_sw_if_index0 == stats_sw_if_index
+ && new_sw_if_index1 == stats_sw_if_index)))
{
stats_n_packets -= 2;
stats_n_bytes -= len0 + len1;
- if (new_sw_if_index0 != old_sw_if_index0 && new_sw_if_index0 != ~0)
- vlib_increment_combined_counter
- (vnm->interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- cpu_index,
- new_sw_if_index0,
- 1,
- len0);
- if (new_sw_if_index1 != old_sw_if_index1 && new_sw_if_index1 != ~0)
- vlib_increment_combined_counter
- (vnm->interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- cpu_index,
- new_sw_if_index1,
- 1,
- len1);
+ if (new_sw_if_index0 != old_sw_if_index0
+ && new_sw_if_index0 != ~0)
+ vlib_increment_combined_counter (vnm->
+ interface_main.combined_sw_if_counters
+ +
+ VNET_INTERFACE_COUNTER_RX,
+ cpu_index,
+ new_sw_if_index0, 1,
+ len0);
+ if (new_sw_if_index1 != old_sw_if_index1
+ && new_sw_if_index1 != ~0)
+ vlib_increment_combined_counter (vnm->
+ interface_main.combined_sw_if_counters
+ +
+ VNET_INTERFACE_COUNTER_RX,
+ cpu_index,
+ new_sw_if_index1, 1,
+ len1);
if (new_sw_if_index0 == new_sw_if_index1)
{
if (stats_n_packets > 0)
{
- vlib_increment_combined_counter
- (vnm->interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- cpu_index,
- stats_sw_if_index,
- stats_n_packets,
- stats_n_bytes);
+ vlib_increment_combined_counter
+ (vnm->interface_main.combined_sw_if_counters
+ + VNET_INTERFACE_COUNTER_RX,
+ cpu_index,
+ stats_sw_if_index,
+ stats_n_packets, stats_n_bytes);
stats_n_packets = stats_n_bytes = 0;
}
stats_sw_if_index = new_sw_if_index0;
}
}
- if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
- is_l20 = is_l21 = 0;
+ if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
+ is_l20 = is_l21 = 0;
+
+ determine_next_node (em, variant, is_l20, type0, b0, &error0,
+ &next0);
+ determine_next_node (em, variant, is_l21, type1, b1, &error1,
+ &next1);
- determine_next_node(em, variant, is_l20, type0, b0, &error0, &next0);
- determine_next_node(em, variant, is_l21, type1, b1, &error1, &next1);
-
b0->error = error_node->errors[error0];
b1->error = error_node->errors[error1];
- // verify speculative enqueue
- vlib_validate_buffer_enqueue_x2(vm,node,next_index,to_next,n_left_to_next,bi0,bi1,next0,next1);
+ // verify speculative enqueue
+ vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
+ n_left_to_next, bi0, bi1, next0,
+ next1);
}
while (n_left_from > 0 && n_left_to_next > 0)
{
u32 bi0;
- vlib_buffer_t * b0;
+ vlib_buffer_t *b0;
u8 error0, next0;
- u16 type0, orig_type0;
- u16 outer_id0, inner_id0;
- u32 match_flags0;
- u32 old_sw_if_index0, new_sw_if_index0, len0;
- vnet_hw_interface_t * hi0;
- main_intf_t * main_intf0;
- vlan_intf_t * vlan_intf0;
- qinq_intf_t * qinq_intf0;
- u32 is_l20;
-
- // Prefetch next iteration
- if (n_left_from > 1) {
- vlib_buffer_t * p2;
-
- p2 = vlib_get_buffer (vm, from[1]);
- vlib_prefetch_buffer_header (p2, STORE);
- CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, LOAD);
- }
+ u16 type0, orig_type0;
+ u16 outer_id0, inner_id0;
+ u32 match_flags0;
+ u32 old_sw_if_index0, new_sw_if_index0, len0;
+ vnet_hw_interface_t *hi0;
+ main_intf_t *main_intf0;
+ vlan_intf_t *vlan_intf0;
+ qinq_intf_t *qinq_intf0;
+ u32 is_l20;
+
+ // Prefetch next iteration
+ if (n_left_from > 1)
+ {
+ vlib_buffer_t *p2;
+
+ p2 = vlib_get_buffer (vm, from[1]);
+ vlib_prefetch_buffer_header (p2, STORE);
+ CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, LOAD);
+ }
- bi0 = from[0];
+ bi0 = from[0];
to_next[0] = bi0;
from += 1;
to_next += 1;
error0 = ETHERNET_ERROR_NONE;
- parse_header (variant,
- b0,
- &type0,
- &orig_type0,
- &outer_id0,
- &inner_id0,
- &match_flags0);
-
- old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
-
- eth_vlan_table_lookups (em,
- vnm,
- old_sw_if_index0,
- orig_type0,
- outer_id0,
- inner_id0,
- &hi0,
- &main_intf0,
- &vlan_intf0,
- &qinq_intf0);
+ parse_header (variant,
+ b0,
+ &type0,
+ &orig_type0, &outer_id0, &inner_id0, &match_flags0);
+
+ old_sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+
+ eth_vlan_table_lookups (em,
+ vnm,
+ old_sw_if_index0,
+ orig_type0,
+ outer_id0,
+ inner_id0,
+ &hi0,
+ &main_intf0, &vlan_intf0, &qinq_intf0);
identify_subint (hi0,
- b0,
- match_flags0,
- main_intf0,
- vlan_intf0,
- qinq_intf0,
- &new_sw_if_index0,
- &error0,
- &is_l20);
-
- // Save RX sw_if_index for later nodes
- vnet_buffer (b0)->sw_if_index[VLIB_RX] = error0 != ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
-
- // Increment subinterface stats
- // Note that interface-level counters have already been incremented
- // prior to calling this function. Thus only subinterface counters
- // are incremented here.
- //
- // Interface level counters include packets received on the main
- // interface and all subinterfaces. Subinterface level counters
- // include only those packets received on that subinterface
+ b0,
+ match_flags0,
+ main_intf0,
+ vlan_intf0,
+ qinq_intf0, &new_sw_if_index0, &error0, &is_l20);
+
+ // Save RX sw_if_index for later nodes
+ vnet_buffer (b0)->sw_if_index[VLIB_RX] =
+ error0 !=
+ ETHERNET_ERROR_NONE ? old_sw_if_index0 : new_sw_if_index0;
+
+ // Increment subinterface stats
+ // Note that interface-level counters have already been incremented
+ // prior to calling this function. Thus only subinterface counters
+ // are incremented here.
+ //
+ // Interface level counters include packets received on the main
+ // interface and all subinterfaces. Subinterface level counters
+ // include only those packets received on that subinterface
// Increment stats if the subint is valid and it is not the main intf
- if ((new_sw_if_index0 != ~0) && (new_sw_if_index0 != old_sw_if_index0)) {
-
- len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
- - vnet_buffer (b0)->ethernet.start_of_ethernet_header;
-
- stats_n_packets += 1;
- stats_n_bytes += len0;
-
- // Batch stat increments from the same subinterface so counters
- // don't need to be incremented for every packet.
- if (PREDICT_FALSE (new_sw_if_index0 != stats_sw_if_index)) {
- stats_n_packets -= 1;
- stats_n_bytes -= len0;
-
- if (new_sw_if_index0 != ~0)
- vlib_increment_combined_counter
- (vnm->interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- cpu_index,
- new_sw_if_index0,
- 1,
- len0);
- if (stats_n_packets > 0) {
- vlib_increment_combined_counter
- (vnm->interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- cpu_index,
- stats_sw_if_index,
- stats_n_packets,
- stats_n_bytes);
- stats_n_packets = stats_n_bytes = 0;
- }
- stats_sw_if_index = new_sw_if_index0;
+ if ((new_sw_if_index0 != ~0)
+ && (new_sw_if_index0 != old_sw_if_index0))
+ {
+
+ len0 = vlib_buffer_length_in_chain (vm, b0) + b0->current_data
+ - vnet_buffer (b0)->ethernet.start_of_ethernet_header;
+
+ stats_n_packets += 1;
+ stats_n_bytes += len0;
+
+ // Batch stat increments from the same subinterface so counters
+ // don't need to be incremented for every packet.
+ if (PREDICT_FALSE (new_sw_if_index0 != stats_sw_if_index))
+ {
+ stats_n_packets -= 1;
+ stats_n_bytes -= len0;
+
+ if (new_sw_if_index0 != ~0)
+ vlib_increment_combined_counter
+ (vnm->interface_main.combined_sw_if_counters
+ + VNET_INTERFACE_COUNTER_RX,
+ cpu_index, new_sw_if_index0, 1, len0);
+ if (stats_n_packets > 0)
+ {
+ vlib_increment_combined_counter
+ (vnm->interface_main.combined_sw_if_counters
+ + VNET_INTERFACE_COUNTER_RX,
+ cpu_index,
+ stats_sw_if_index, stats_n_packets, stats_n_bytes);
+ stats_n_packets = stats_n_bytes = 0;
+ }
+ stats_sw_if_index = new_sw_if_index0;
+ }
}
- }
- if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
- is_l20 = 0;
+ if (variant == ETHERNET_INPUT_VARIANT_NOT_L2)
+ is_l20 = 0;
+
+ determine_next_node (em, variant, is_l20, type0, b0, &error0,
+ &next0);
- determine_next_node(em, variant, is_l20, type0, b0, &error0, &next0);
+ b0->error = error_node->errors[error0];
- b0->error = error_node->errors[error0];
-
- // verify speculative enqueue
+ // verify speculative enqueue
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
to_next, n_left_to_next,
bi0, next0);
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
- // Increment any remaining batched stats
- if (stats_n_packets > 0)
+ // Increment any remaining batched stats
+ if (stats_n_packets > 0)
{
- vlib_increment_combined_counter
- (vnm->interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- cpu_index,
- stats_sw_if_index,
- stats_n_packets,
- stats_n_bytes);
+ vlib_increment_combined_counter
+ (vnm->interface_main.combined_sw_if_counters
+ + VNET_INTERFACE_COUNTER_RX,
+ cpu_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
node->runtime_data[0] = stats_sw_if_index;
}
static uword
ethernet_input (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
-{ return ethernet_input_inline (vm, node, from_frame, ETHERNET_INPUT_VARIANT_ETHERNET); }
+ vlib_node_runtime_t * node, vlib_frame_t * from_frame)
+{
+ return ethernet_input_inline (vm, node, from_frame,
+ ETHERNET_INPUT_VARIANT_ETHERNET);
+}
static uword
ethernet_input_type (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
-{ return ethernet_input_inline (vm, node, from_frame, ETHERNET_INPUT_VARIANT_ETHERNET_TYPE); }
+ vlib_node_runtime_t * node, vlib_frame_t * from_frame)
+{
+ return ethernet_input_inline (vm, node, from_frame,
+ ETHERNET_INPUT_VARIANT_ETHERNET_TYPE);
+}
static uword
ethernet_input_not_l2 (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
-{ return ethernet_input_inline (vm, node, from_frame, ETHERNET_INPUT_VARIANT_NOT_L2); }
+ vlib_node_runtime_t * node, vlib_frame_t * from_frame)
+{
+ return ethernet_input_inline (vm, node, from_frame,
+ ETHERNET_INPUT_VARIANT_NOT_L2);
+}
// Return the subinterface config struct for the given sw_if_index
// On error (unsupported or not ethernet) return 0.
static subint_config_t *
ethernet_sw_interface_get_config (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 * flags,
- u32 * unsupported) {
- ethernet_main_t * em = ðernet_main;
- vnet_hw_interface_t * hi;
- vnet_sw_interface_t * si;
- main_intf_t * main_intf;
- vlan_table_t * vlan_table;
- qinq_table_t * qinq_table;
- subint_config_t * subint = 0;
-
+ u32 sw_if_index,
+ u32 * flags, u32 * unsupported)
+{
+ ethernet_main_t *em = ðernet_main;
+ vnet_hw_interface_t *hi;
+ vnet_sw_interface_t *si;
+ main_intf_t *main_intf;
+ vlan_table_t *vlan_table;
+ qinq_table_t *qinq_table;
+ subint_config_t *subint = 0;
+
hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
- if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index)) {
- *unsupported = 0;
- goto done; // non-ethernet interface
- }
+ if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index))
+ {
+ *unsupported = 0;
+ goto done; // non-ethernet interface
+ }
// ensure there's an entry for the main intf (shouldn't really be necessary)
vec_validate (em->main_intfs, hi->hw_if_index);
// Locate the subint for the given ethernet config
si = vnet_get_sw_interface (vnm, sw_if_index);
- if (si->sub.eth.flags.default_sub) {
- subint = &main_intf->default_subint;
- *flags = SUBINT_CONFIG_MATCH_0_TAG |
- SUBINT_CONFIG_MATCH_1_TAG |
- SUBINT_CONFIG_MATCH_2_TAG |
- SUBINT_CONFIG_MATCH_3_TAG;
- } else if ((si->sub.eth.flags.no_tags) ||
- (si->sub.eth.raw_flags == 0)) {
- // if no flags are set then this is a main interface
- // so treat as untagged
- subint = &main_intf->untagged_subint;
- *flags = SUBINT_CONFIG_MATCH_0_TAG;
- } else {
- // one or two tags
- // first get the vlan table
- if (si->sub.eth.flags.dot1ad) {
- if (main_intf->dot1ad_vlans == 0) {
- // Allocate a vlan table from the pool
- pool_get(em->vlan_pool, vlan_table);
- main_intf->dot1ad_vlans = vlan_table - em->vlan_pool;
- } else {
- // Get ptr to existing vlan table
- vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1ad_vlans);
- }
- } else { // dot1q
- if (main_intf->dot1q_vlans == 0) {
- // Allocate a vlan table from the pool
- pool_get(em->vlan_pool, vlan_table);
- main_intf->dot1q_vlans = vlan_table - em->vlan_pool;
- } else {
- // Get ptr to existing vlan table
- vlan_table = vec_elt_at_index (em->vlan_pool, main_intf->dot1q_vlans);
- }
+ if (si->sub.eth.flags.default_sub)
+ {
+ subint = &main_intf->default_subint;
+ *flags = SUBINT_CONFIG_MATCH_0_TAG |
+ SUBINT_CONFIG_MATCH_1_TAG |
+ SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG;
}
+ else if ((si->sub.eth.flags.no_tags) || (si->sub.eth.raw_flags == 0))
+ {
+ // if no flags are set then this is a main interface
+ // so treat as untagged
+ subint = &main_intf->untagged_subint;
+ *flags = SUBINT_CONFIG_MATCH_0_TAG;
+ }
+ else
+ {
+ // one or two tags
+ // first get the vlan table
+ if (si->sub.eth.flags.dot1ad)
+ {
+ if (main_intf->dot1ad_vlans == 0)
+ {
+ // Allocate a vlan table from the pool
+ pool_get (em->vlan_pool, vlan_table);
+ main_intf->dot1ad_vlans = vlan_table - em->vlan_pool;
+ }
+ else
+ {
+ // Get ptr to existing vlan table
+ vlan_table =
+ vec_elt_at_index (em->vlan_pool, main_intf->dot1ad_vlans);
+ }
+ }
+ else
+ { // dot1q
+ if (main_intf->dot1q_vlans == 0)
+ {
+ // Allocate a vlan table from the pool
+ pool_get (em->vlan_pool, vlan_table);
+ main_intf->dot1q_vlans = vlan_table - em->vlan_pool;
+ }
+ else
+ {
+ // Get ptr to existing vlan table
+ vlan_table =
+ vec_elt_at_index (em->vlan_pool, main_intf->dot1q_vlans);
+ }
+ }
+
+ if (si->sub.eth.flags.one_tag)
+ {
+ *flags = si->sub.eth.flags.exact_match ?
+ SUBINT_CONFIG_MATCH_1_TAG :
+ (SUBINT_CONFIG_MATCH_1_TAG |
+ SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG);
+
+ if (si->sub.eth.flags.outer_vlan_id_any)
+ {
+ // not implemented yet
+ *unsupported = 1;
+ goto done;
+ }
+ else
+ {
+ // a single vlan, a common case
+ subint =
+ &vlan_table->vlans[si->sub.eth.
+ outer_vlan_id].single_tag_subint;
+ }
+
+ }
+ else
+ {
+ // Two tags
+ *flags = si->sub.eth.flags.exact_match ?
+ SUBINT_CONFIG_MATCH_2_TAG :
+ (SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG);
+
+ if (si->sub.eth.flags.outer_vlan_id_any
+ && si->sub.eth.flags.inner_vlan_id_any)
+ {
+ // not implemented yet
+ *unsupported = 1;
+ goto done;
+ }
- if (si->sub.eth.flags.one_tag) {
- *flags = si->sub.eth.flags.exact_match ?
- SUBINT_CONFIG_MATCH_1_TAG :
- (SUBINT_CONFIG_MATCH_1_TAG |
- SUBINT_CONFIG_MATCH_2_TAG |
- SUBINT_CONFIG_MATCH_3_TAG);
-
- if (si->sub.eth.flags.outer_vlan_id_any) {
- // not implemented yet
- *unsupported =1;
- goto done;
- } else {
- // a single vlan, a common case
- subint = &vlan_table->vlans[si->sub.eth.outer_vlan_id].single_tag_subint;
- }
-
- } else {
- // Two tags
- *flags = si->sub.eth.flags.exact_match ?
- SUBINT_CONFIG_MATCH_2_TAG :
- (SUBINT_CONFIG_MATCH_2_TAG |
- SUBINT_CONFIG_MATCH_3_TAG);
-
- if (si->sub.eth.flags.outer_vlan_id_any && si->sub.eth.flags.inner_vlan_id_any) {
- // not implemented yet
- *unsupported = 1;
- goto done;
- }
-
- if (si->sub.eth.flags.inner_vlan_id_any) {
- // a specific outer and "any" inner
- // don't need a qinq table for this
- subint = &vlan_table->vlans[si->sub.eth.outer_vlan_id].inner_any_subint;
- if (si->sub.eth.flags.exact_match) {
- *flags = SUBINT_CONFIG_MATCH_2_TAG;
- } else {
- *flags = SUBINT_CONFIG_MATCH_2_TAG |
- SUBINT_CONFIG_MATCH_3_TAG;
- }
- } else {
- // a specific outer + specifc innner vlan id, a common case
-
- // get the qinq table
- if (vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs == 0) {
- // Allocate a qinq table from the pool
- pool_get(em->qinq_pool, qinq_table);
- vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs = qinq_table - em->qinq_pool;
- } else {
- // Get ptr to existing qinq table
- qinq_table = vec_elt_at_index (em->qinq_pool, vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs);
- }
- subint = &qinq_table->vlans[si->sub.eth.inner_vlan_id].subint;
- }
+ if (si->sub.eth.flags.inner_vlan_id_any)
+ {
+ // a specific outer and "any" inner
+ // don't need a qinq table for this
+ subint =
+ &vlan_table->vlans[si->sub.eth.
+ outer_vlan_id].inner_any_subint;
+ if (si->sub.eth.flags.exact_match)
+ {
+ *flags = SUBINT_CONFIG_MATCH_2_TAG;
+ }
+ else
+ {
+ *flags = SUBINT_CONFIG_MATCH_2_TAG |
+ SUBINT_CONFIG_MATCH_3_TAG;
+ }
+ }
+ else
+ {
+ // a specific outer + specifc innner vlan id, a common case
+
+ // get the qinq table
+ if (vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs == 0)
+ {
+ // Allocate a qinq table from the pool
+ pool_get (em->qinq_pool, qinq_table);
+ vlan_table->vlans[si->sub.eth.outer_vlan_id].qinqs =
+ qinq_table - em->qinq_pool;
+ }
+ else
+ {
+ // Get ptr to existing qinq table
+ qinq_table =
+ vec_elt_at_index (em->qinq_pool,
+ vlan_table->vlans[si->sub.
+ eth.outer_vlan_id].
+ qinqs);
+ }
+ subint = &qinq_table->vlans[si->sub.eth.inner_vlan_id].subint;
+ }
+ }
}
- }
- done:
+done:
return subint;
}
clib_error_t *
-ethernet_sw_interface_up_down (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 flags)
+ethernet_sw_interface_up_down (vnet_main_t * vnm, u32 sw_if_index, u32 flags)
{
- subint_config_t * subint;
+ subint_config_t *subint;
u32 dummy_flags;
u32 dummy_unsup;
- clib_error_t * error = 0;
+ clib_error_t *error = 0;
// Find the config for this subinterface
- subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags, &dummy_unsup);
+ subint =
+ ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags,
+ &dummy_unsup);
- if (subint == 0) {
- // not implemented yet or not ethernet
- goto done;
- }
+ if (subint == 0)
+ {
+ // not implemented yet or not ethernet
+ goto done;
+ }
subint->sw_if_index =
((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? sw_if_index : ~0);
- done:
+done:
return error;
}
// Set the L2/L3 mode for the subinterface
void
-ethernet_sw_interface_set_l2_mode (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 l2)
+ethernet_sw_interface_set_l2_mode (vnet_main_t * vnm, u32 sw_if_index, u32 l2)
{
subint_config_t *subint;
u32 dummy_flags;
u32 dummy_unsup;
int is_port;
- vnet_sw_interface_t * sw = vnet_get_sw_interface (vnm, sw_if_index);
+ vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index);
is_port = !(sw->type == VNET_SW_INTERFACE_TYPE_SUB);
// Find the config for this subinterface
- subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags, &dummy_unsup);
+ subint =
+ ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags,
+ &dummy_unsup);
- if (subint == 0) {
- // unimplemented or not ethernet
- goto done;
- }
+ if (subint == 0)
+ {
+ // unimplemented or not ethernet
+ goto done;
+ }
// Double check that the config we found is for our interface (or the interface is down)
ASSERT ((subint->sw_if_index == sw_if_index) | (subint->sw_if_index == ~0));
- if (l2) {
- subint->flags |= SUBINT_CONFIG_L2;
- if (is_port)
- subint->flags |=
- SUBINT_CONFIG_MATCH_0_TAG | SUBINT_CONFIG_MATCH_1_TAG
- | SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG;
- } else {
- subint->flags &= ~SUBINT_CONFIG_L2;
- if (is_port)
- subint->flags &=
- ~(SUBINT_CONFIG_MATCH_1_TAG | SUBINT_CONFIG_MATCH_2_TAG
- | SUBINT_CONFIG_MATCH_3_TAG);
- }
+ if (l2)
+ {
+ subint->flags |= SUBINT_CONFIG_L2;
+ if (is_port)
+ subint->flags |=
+ SUBINT_CONFIG_MATCH_0_TAG | SUBINT_CONFIG_MATCH_1_TAG
+ | SUBINT_CONFIG_MATCH_2_TAG | SUBINT_CONFIG_MATCH_3_TAG;
+ }
+ else
+ {
+ subint->flags &= ~SUBINT_CONFIG_L2;
+ if (is_port)
+ subint->flags &=
+ ~(SUBINT_CONFIG_MATCH_1_TAG | SUBINT_CONFIG_MATCH_2_TAG
+ | SUBINT_CONFIG_MATCH_3_TAG);
+ }
- done:
+done:
return;
}
*/
void
ethernet_sw_interface_set_l2_mode_noport (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 l2)
+ u32 sw_if_index, u32 l2)
{
subint_config_t *subint;
u32 dummy_flags;
u32 dummy_unsup;
/* Find the config for this subinterface */
- subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags, &dummy_unsup);
+ subint =
+ ethernet_sw_interface_get_config (vnm, sw_if_index, &dummy_flags,
+ &dummy_unsup);
- if (subint == 0) {
- /* unimplemented or not ethernet */
- goto done;
- }
+ if (subint == 0)
+ {
+ /* unimplemented or not ethernet */
+ goto done;
+ }
/*
* Double check that the config we found is for our interface (or the
*/
ASSERT ((subint->sw_if_index == sw_if_index) | (subint->sw_if_index == ~0));
- if (l2) {
- subint->flags |= SUBINT_CONFIG_L2;
- } else {
- subint->flags &= ~SUBINT_CONFIG_L2;
- }
+ if (l2)
+ {
+ subint->flags |= SUBINT_CONFIG_L2;
+ }
+ else
+ {
+ subint->flags &= ~SUBINT_CONFIG_L2;
+ }
- done:
+done:
return;
}
static clib_error_t *
ethernet_sw_interface_add_del (vnet_main_t * vnm,
- u32 sw_if_index,
- u32 is_create)
+ u32 sw_if_index, u32 is_create)
{
- clib_error_t * error = 0;
+ clib_error_t *error = 0;
subint_config_t *subint;
u32 match_flags;
- u32 unsupported=0;
+ u32 unsupported = 0;
// Find the config for this subinterface
- subint = ethernet_sw_interface_get_config (vnm, sw_if_index, &match_flags, &unsupported);
+ subint =
+ ethernet_sw_interface_get_config (vnm, sw_if_index, &match_flags,
+ &unsupported);
- if (subint == 0) {
- // not implemented yet or not ethernet
- if (unsupported) {
- // this is the NYI case
- error = clib_error_return (0, "not implemented yet");
+ if (subint == 0)
+ {
+ // not implemented yet or not ethernet
+ if (unsupported)
+ {
+ // this is the NYI case
+ error = clib_error_return (0, "not implemented yet");
+ }
+ goto done;
}
- goto done;
- }
- if (!is_create) {
- subint->flags = 0;
- return error;
- }
+ if (!is_create)
+ {
+ subint->flags = 0;
+ return error;
+ }
// Initialize the subint
- if (subint->flags & SUBINT_CONFIG_VALID) {
- // Error vlan already in use
- error = clib_error_return (0, "vlan is already in use");
- } else {
- // Note that config is L3 by defaulty
- subint->flags = SUBINT_CONFIG_VALID | match_flags;
- subint->sw_if_index = ~0; // because interfaces are initially down
- }
+ if (subint->flags & SUBINT_CONFIG_VALID)
+ {
+ // Error vlan already in use
+ error = clib_error_return (0, "vlan is already in use");
+ }
+ else
+ {
+ // Note that config is L3 by defaulty
+ subint->flags = SUBINT_CONFIG_VALID | match_flags;
+ subint->sw_if_index = ~0; // because interfaces are initially down
+ }
- done:
+done:
return error;
}
VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ethernet_sw_interface_add_del);
-static char * ethernet_error_strings[] = {
+static char *ethernet_error_strings[] = {
#define ethernet_error(n,c,s) s,
#include "error.def"
#undef ethernet_error
};
+/* *INDENT-OFF* */
VLIB_REGISTER_NODE (ethernet_input_node) = {
.function = ethernet_input,
.name = "ethernet-input",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
-
.n_errors = ETHERNET_N_ERROR,
.error_strings = ethernet_error_strings,
-
.n_next_nodes = ETHERNET_INPUT_N_NEXT,
.next_nodes = {
#define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
foreach_ethernet_input_next
#undef _
},
-
.format_buffer = format_ethernet_header_with_length,
.format_trace = format_ethernet_input_trace,
.unformat_buffer = unformat_ethernet_header,
};
+/* *INDENT-ON* */
+/* *INDENT-OFF* */
VLIB_NODE_FUNCTION_MULTIARCH (ethernet_input_node, ethernet_input)
+/* *INDENT-ON* */
-VLIB_REGISTER_NODE (ethernet_input_type_node,static) = {
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (ethernet_input_type_node, static) = {
.function = ethernet_input_type,
.name = "ethernet-input-type",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
-
.n_next_nodes = ETHERNET_INPUT_N_NEXT,
.next_nodes = {
#define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
#undef _
},
};
+/* *INDENT-ON* */
+/* *INDENT-OFF* */
VLIB_NODE_FUNCTION_MULTIARCH (ethernet_input_type_node, ethernet_input_type)
+/* *INDENT-ON* */
-VLIB_REGISTER_NODE (ethernet_input_not_l2_node,static) = {
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (ethernet_input_not_l2_node, static) = {
.function = ethernet_input_not_l2,
.name = "ethernet-input-not-l2",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
-
.n_next_nodes = ETHERNET_INPUT_N_NEXT,
.next_nodes = {
#define _(s,n) [ETHERNET_INPUT_NEXT_##s] = n,
#undef _
},
};
+/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (ethernet_input_not_l2_node, ethernet_input_not_l2)
-void ethernet_set_rx_redirect (vnet_main_t * vnm,
- vnet_hw_interface_t * hi,
- u32 enable)
+/* *INDENT-OFF* */
+VLIB_NODE_FUNCTION_MULTIARCH (ethernet_input_not_l2_node,
+ ethernet_input_not_l2)
+/* *INDENT-ON* */
+
+
+void
+ethernet_set_rx_redirect (vnet_main_t * vnm,
+ vnet_hw_interface_t * hi, u32 enable)
{
// Insure all packets go to ethernet-input (i.e. untagged ipv4 packets
// don't go directly to ip4-input)
- vnet_hw_interface_rx_redirect_to_node
- (vnm, hi->hw_if_index, enable ? ethernet_input_node.index : ~0);
+ vnet_hw_interface_rx_redirect_to_node
+ (vnm, hi->hw_if_index, enable ? ethernet_input_node.index : ~0);
}
* Initialization and registration for the next_by_ethernet structure
*/
-clib_error_t * next_by_ethertype_init (next_by_ethertype_t * l3_next)
+clib_error_t *
+next_by_ethertype_init (next_by_ethertype_t * l3_next)
{
l3_next->input_next_by_type = sparse_vec_new
- (/* elt bytes */ sizeof (l3_next->input_next_by_type[0]),
+ ( /* elt bytes */ sizeof (l3_next->input_next_by_type[0]),
/* bits in index */ BITS (((ethernet_header_t *) 0)->type));
- vec_validate (l3_next->sparse_index_by_input_next_index, ETHERNET_INPUT_NEXT_DROP);
- vec_validate (l3_next->sparse_index_by_input_next_index, ETHERNET_INPUT_NEXT_PUNT);
- l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_DROP]
- = SPARSE_VEC_INVALID_INDEX;
- l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_PUNT]
- = SPARSE_VEC_INVALID_INDEX;
-
+ vec_validate (l3_next->sparse_index_by_input_next_index,
+ ETHERNET_INPUT_NEXT_DROP);
+ vec_validate (l3_next->sparse_index_by_input_next_index,
+ ETHERNET_INPUT_NEXT_PUNT);
+ l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_DROP] =
+ SPARSE_VEC_INVALID_INDEX;
+ l3_next->sparse_index_by_input_next_index[ETHERNET_INPUT_NEXT_PUNT] =
+ SPARSE_VEC_INVALID_INDEX;
+
/*
* Make sure we don't wipe out an ethernet registration by mistake
* Can happen if init function ordering constraints are missing.
*/
if (CLIB_DEBUG > 0)
{
- ethernet_main_t * em = ðernet_main;
- ASSERT(em->next_by_ethertype_register_called == 0);
+ ethernet_main_t *em = ðernet_main;
+ ASSERT (em->next_by_ethertype_register_called == 0);
}
return 0;
}
// Add an ethertype -> next index mapping to the structure
-clib_error_t * next_by_ethertype_register (next_by_ethertype_t * l3_next,
- u32 ethertype,
- u32 next_index)
+clib_error_t *
+next_by_ethertype_register (next_by_ethertype_t * l3_next,
+ u32 ethertype, u32 next_index)
{
u32 i;
- u16 * n;
- ethernet_main_t * em = ðernet_main;
+ u16 *n;
+ ethernet_main_t *em = ðernet_main;
if (CLIB_DEBUG > 0)
{
- ethernet_main_t * em = ðernet_main;
+ ethernet_main_t *em = ðernet_main;
em->next_by_ethertype_register_called = 1;
}
is updated. */
vec_validate (l3_next->sparse_index_by_input_next_index, next_index);
for (i = 1; i < vec_len (l3_next->input_next_by_type); i++)
- l3_next->sparse_index_by_input_next_index[l3_next->input_next_by_type[i]] = i;
+ l3_next->
+ sparse_index_by_input_next_index[l3_next->input_next_by_type[i]] = i;
// do not allow the cached next index's to be updated if L3
// redirect is enabled, as it will have overwritten them
- if (!em->redirect_l3) {
- // Cache common ethertypes directly
- if (ethertype == ETHERNET_TYPE_IP4) {
- l3_next->input_next_ip4 = next_index;
- } else if (ethertype == ETHERNET_TYPE_IP6) {
- l3_next->input_next_ip6 = next_index;
- } else if (ethertype == ETHERNET_TYPE_MPLS_UNICAST) {
- l3_next->input_next_mpls = next_index;
+ if (!em->redirect_l3)
+ {
+ // Cache common ethertypes directly
+ if (ethertype == ETHERNET_TYPE_IP4)
+ {
+ l3_next->input_next_ip4 = next_index;
+ }
+ else if (ethertype == ETHERNET_TYPE_IP6)
+ {
+ l3_next->input_next_ip6 = next_index;
+ }
+ else if (ethertype == ETHERNET_TYPE_MPLS_UNICAST)
+ {
+ l3_next->input_next_mpls = next_index;
+ }
}
- }
return 0;
}
-static clib_error_t * ethernet_input_init (vlib_main_t * vm)
+static clib_error_t *
+ethernet_input_init (vlib_main_t * vm)
{
- ethernet_main_t * em = ðernet_main;
- __attribute__((unused)) vlan_table_t * invalid_vlan_table;
- __attribute__((unused)) qinq_table_t * invalid_qinq_table;
+ ethernet_main_t *em = ðernet_main;
+ __attribute__ ((unused)) vlan_table_t *invalid_vlan_table;
+ __attribute__ ((unused)) qinq_table_t *invalid_qinq_table;
ethernet_setup_node (vm, ethernet_input_node.index);
ethernet_setup_node (vm, ethernet_input_type_node.index);
ethernet_setup_node (vm, ethernet_input_not_l2_node.index);
next_by_ethertype_init (&em->l3_next);
-
+
// Initialize pools and vector for vlan parsing
- vec_validate (em->main_intfs, 10); // 10 main interfaces
- pool_alloc(em->vlan_pool, 10);
- pool_alloc(em->qinq_pool, 1);
+ vec_validate (em->main_intfs, 10); // 10 main interfaces
+ pool_alloc (em->vlan_pool, 10);
+ pool_alloc (em->qinq_pool, 1);
// The first vlan pool will always be reserved for an invalid table
- pool_get(em->vlan_pool, invalid_vlan_table); // first id = 0
+ pool_get (em->vlan_pool, invalid_vlan_table); // first id = 0
// The first qinq pool will always be reserved for an invalid table
- pool_get(em->qinq_pool, invalid_qinq_table); // first id = 0
+ pool_get (em->qinq_pool, invalid_qinq_table); // first id = 0
return 0;
}
void
ethernet_register_input_type (vlib_main_t * vm,
- ethernet_type_t type,
- u32 node_index)
+ ethernet_type_t type, u32 node_index)
{
- ethernet_main_t * em = ðernet_main;
- ethernet_type_info_t * ti;
+ ethernet_main_t *em = ðernet_main;
+ ethernet_type_info_t *ti;
u32 i;
{
- clib_error_t * error = vlib_call_init_function (vm, ethernet_init);
+ clib_error_t *error = vlib_call_init_function (vm, ethernet_init);
if (error)
clib_error_report (error);
}
ti = ethernet_get_type_info (em, type);
ti->node_index = node_index;
- ti->next_index = vlib_node_add_next (vm,
- ethernet_input_node.index,
- node_index);
- i = vlib_node_add_next (vm,
- ethernet_input_type_node.index,
- node_index);
+ ti->next_index = vlib_node_add_next (vm,
+ ethernet_input_node.index, node_index);
+ i = vlib_node_add_next (vm, ethernet_input_type_node.index, node_index);
ASSERT (i == ti->next_index);
- i = vlib_node_add_next (vm,
- ethernet_input_not_l2_node.index,
- node_index);
+ i = vlib_node_add_next (vm, ethernet_input_not_l2_node.index, node_index);
ASSERT (i == ti->next_index);
// Add the L3 node for this ethertype to the next nodes structure
}
void
-ethernet_register_l2_input (vlib_main_t * vm,
- u32 node_index)
+ethernet_register_l2_input (vlib_main_t * vm, u32 node_index)
{
- ethernet_main_t * em = ðernet_main;
+ ethernet_main_t *em = ðernet_main;
u32 i;
- em->l2_next = vlib_node_add_next (vm, ethernet_input_node.index, node_index);
+ em->l2_next =
+ vlib_node_add_next (vm, ethernet_input_node.index, node_index);
/*
* Even if we never use these arcs, we have to align the next indices...
ASSERT (i == em->l2_next);
- i = vlib_node_add_next (vm,
- ethernet_input_not_l2_node.index,
- node_index);
+ i = vlib_node_add_next (vm, ethernet_input_not_l2_node.index, node_index);
ASSERT (i == em->l2_next);
}
// Register a next node for L3 redirect, and enable L3 redirect
void
-ethernet_register_l3_redirect (vlib_main_t * vm,
- u32 node_index)
+ethernet_register_l3_redirect (vlib_main_t * vm, u32 node_index)
{
- ethernet_main_t * em = ðernet_main;
+ ethernet_main_t *em = ðernet_main;
u32 i;
em->redirect_l3 = 1;
- em->redirect_l3_next = vlib_node_add_next(vm,
- ethernet_input_node.index,
- node_index);
+ em->redirect_l3_next = vlib_node_add_next (vm,
+ ethernet_input_node.index,
+ node_index);
/*
* Change the cached next nodes to the redirect node
*/
ASSERT (i == em->redirect_l3_next);
}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
#ifndef included_ethernet_packet_h
#define included_ethernet_packet_h
-typedef enum {
+typedef enum
+{
#define ethernet_type(n,s) ETHERNET_TYPE_##s = n,
#include <vnet/ethernet/types.def>
#undef ethernet_type
} ethernet_type_t;
-typedef struct {
+typedef struct
+{
/* Source/destination address. */
u8 dst_address[6];
u8 src_address[6];
/* I/G bit: individual (unicast)/group (broadcast/multicast). */
always_inline uword
ethernet_address_cast (u8 * a)
-{ return (a[0] >> 0) & 1; }
+{
+ return (a[0] >> 0) & 1;
+}
always_inline uword
ethernet_address_is_locally_administered (u8 * a)
-{ return (a[0] >> 1) & 1; }
+{
+ return (a[0] >> 1) & 1;
+}
always_inline void
ethernet_address_set_locally_administered (u8 * a)
-{ a[0] |= 1 << 1; }
+{
+ a[0] |= 1 << 1;
+}
/* For VLAN ethernet type. */
-typedef struct {
+typedef struct
+{
/* 3 bit priority, 1 bit CFI and 12 bit vlan id. */
u16 priority_cfi_and_id;
/* VLAN with ethertype first and vlan id second */
-typedef struct {
+typedef struct
+{
/* vlan type */
u16 type;
} ethernet_vlan_header_tv_t;
#endif /* included_ethernet_packet_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
#include <vnet/pg/pg.h>
#include <vnet/ethernet/ethernet.h>
-typedef struct {
+typedef struct
+{
pg_edit_t type;
pg_edit_t src_address;
pg_edit_t dst_address;
pg_edit_init (&e->dst_address, ethernet_header_t, dst_address);
}
-typedef struct {
+typedef struct
+{
pg_edit_t type;
pg_edit_t id;
pg_edit_t cfi;
} pg_ethernet_vlan_header_t;
static inline void
-pg_ethernet_vlan_header_init (pg_ethernet_vlan_header_t * v,
- int vlan_index)
+pg_ethernet_vlan_header_init (pg_ethernet_vlan_header_t * v, int vlan_index)
{
ASSERT (vlan_index < ARRAY_LEN (((ethernet_max_header_t *) 0)->vlan));
pg_edit_init (&v->type, ethernet_max_header_t, vlan[vlan_index].type);
pg_edit_init_bitfield (&v->id, ethernet_max_header_t,
- vlan[vlan_index].priority_cfi_and_id,
- 0, 12);
+ vlan[vlan_index].priority_cfi_and_id, 0, 12);
pg_edit_init_bitfield (&v->cfi, ethernet_max_header_t,
- vlan[vlan_index].priority_cfi_and_id,
- 12, 1);
+ vlan[vlan_index].priority_cfi_and_id, 12, 1);
pg_edit_init_bitfield (&v->priority, ethernet_max_header_t,
- vlan[vlan_index].priority_cfi_and_id,
- 13, 3);
+ vlan[vlan_index].priority_cfi_and_id, 13, 3);
}
uword
unformat_pg_ethernet_header (unformat_input_t * input, va_list * args)
{
- pg_stream_t * s = va_arg (*args, pg_stream_t *);
- pg_ethernet_header_t * e;
- pg_ethernet_vlan_header_t * v;
- pg_edit_t * ether_type_edit;
+ pg_stream_t *s = va_arg (*args, pg_stream_t *);
+ pg_ethernet_header_t *e;
+ pg_ethernet_vlan_header_t *v;
+ pg_edit_t *ether_type_edit;
u32 n_vlan, error, group_index;
-
+
e = pg_create_edit_group (s, sizeof (e[0]), sizeof (ethernet_header_t),
&group_index);
pg_ethernet_header_init (e);
error = 1;
- if (! unformat (input, "%U: %U -> %U",
- unformat_pg_edit,
- unformat_ethernet_type_net_byte_order, &e->type,
- unformat_pg_edit,
- unformat_ethernet_address, &e->src_address,
- unformat_pg_edit,
- unformat_ethernet_address, &e->dst_address))
+ if (!unformat (input, "%U: %U -> %U",
+ unformat_pg_edit,
+ unformat_ethernet_type_net_byte_order, &e->type,
+ unformat_pg_edit,
+ unformat_ethernet_address, &e->src_address,
+ unformat_pg_edit,
+ unformat_ethernet_address, &e->dst_address))
goto done;
n_vlan = 0;
group_index);
pg_ethernet_vlan_header_init (v, n_vlan);
- if (! unformat_user (input, unformat_pg_edit,
- unformat_pg_number, &v->id))
+ if (!unformat_user (input, unformat_pg_edit,
+ unformat_pg_number, &v->id))
goto done;
- if (! unformat (input, "priority %U", unformat_pg_edit,
- unformat_pg_number, &v->priority))
+ if (!unformat (input, "priority %U", unformat_pg_edit,
+ unformat_pg_number, &v->priority))
pg_edit_set_fixed (&v->priority, 0);
- if (! unformat (input, "cfi %U", unformat_pg_edit,
- unformat_pg_number, &v->cfi))
+ if (!unformat (input, "cfi %U", unformat_pg_edit,
+ unformat_pg_number, &v->cfi))
pg_edit_set_fixed (&v->cfi, 0);
/* Too many vlans given. */
}
{
- ethernet_main_t * em = ðernet_main;
- ethernet_type_info_t * ti = 0;
- pg_node_t * pg_node = 0;
+ ethernet_main_t *em = ðernet_main;
+ ethernet_type_info_t *ti = 0;
+ pg_node_t *pg_node = 0;
if (ether_type_edit->type == PG_EDIT_FIXED)
{
if (pg_node && pg_node->unformat_edit
&& unformat_user (input, pg_node->unformat_edit, s))
;
- else if (! unformat_user (input, unformat_pg_payload, s))
+ else if (!unformat_user (input, unformat_pg_payload, s))
goto done;
}
error = 0;
- done:
+done:
if (error)
pg_free_edit_group (s);
return error == 0;
}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
Code Review / vpp.git / commitdiff