summaryrefslogtreecommitdiffstats
path: root/src/vnet/l2/l2_bd.h
blob: 360880839ec8f8a21dff29203b4d22349f12739f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
/*
 * l2_bd.h : layer 2 bridge domain
 *
 * Copyright (c) 2013 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef included_l2bd_h
#define included_l2bd_h

#include <vlib/vlib.h>
#include <vnet/vnet.h>
#include <vnet/ip/ip6_packet.h>
#include <vnet/ethernet/mac_address.h>

typedef enum l2_bd_port_type_t_
{
  L2_BD_PORT_TYPE_NORMAL = 0,
  L2_BD_PORT_TYPE_BVI = 1,
  L2_BD_PORT_TYPE_UU_FWD = 2,
} l2_bd_port_type_t;

typedef struct
{
  /* hash bd_id -> bd_index */
  uword *bd_index_by_bd_id;

  /* Busy bd_index bitmap */
  uword *bd_index_bitmap;

  /* convenience */
  vlib_main_t *vlib_main;
  vnet_main_t *vnet_main;
} bd_main_t;

extern bd_main_t bd_main;

/* Bridge domain member  */

#define L2_FLOOD_MEMBER_NORMAL 0
#define L2_FLOOD_MEMBER_BVI    1

typedef struct
{
  u32 sw_if_index;		/* the output L2 interface */
  u8 flags;			/* 0=normal, 1=bvi */
  u8 shg;			/* split horizon group number  */
  u16 spare;
} l2_flood_member_t;

/* Per-bridge domain configuration */

typedef struct
{
  /*
   * Contains bit enables for flooding, learning, and forwarding.
   * All other feature bits should always be set.
   */
  u32 feature_bitmap;
  /*
   * identity of the bridge-domain's BVI interface
   * set to ~0 if there is no BVI
   */
  u32 bvi_sw_if_index;

  /*
   * identity of the bridge-domain's UU flood interface
   * set to ~0 if there is no such configuration
   */
  u32 uu_fwd_sw_if_index;

  /* bridge domain id, not to be confused with bd_index */
  u32 bd_id;

  /* Vector of member ports */
  l2_flood_member_t *members;

  /* First flood_count member ports are flooded */
  u32 flood_count;

  /* Tunnel Master (Multicast vxlan) are always flooded */
  u32 tun_master_count;

  /* Tunnels (Unicast vxlan) are flooded if there are no masters */
  u32 tun_normal_count;

  /* Interface on which packets are not flooded */
  u32 no_flood_count;

  /* hash ip4/ip6 -> mac for arp/nd termination */
  uword *mac_by_ip4;
  uword *mac_by_ip6;

  /* mac aging */
  u8 mac_age;

  /* sequence number for bridge domain based flush of MACs */
  u8 seq_num;

  /* Bridge domain tag (C string NULL terminated) */
  u8 *bd_tag;

} l2_bridge_domain_t;

/* Limit Bridge Domain ID to 24 bits to match 24-bit VNI range */
#define L2_BD_ID_MAX ((1<<24)-1)

typedef struct
{
  u32 bd_id;
  u8 flood;
  u8 uu_flood;
  u8 forward;
  u8 learn;
  u8 arp_term;
  u8 arp_ufwd;
  u8 mac_age;
  u8 *bd_tag;
  u8 is_add;
} l2_bridge_domain_add_del_args_t;

/* Return 1 if bridge domain has been initialized */
always_inline u32
bd_is_valid (l2_bridge_domain_t * bd_config)
{
  return (bd_config->feature_bitmap != 0);
}

/* Init bridge domain if not done already */
void bd_validate (l2_bridge_domain_t * bd_config);


void
bd_add_member (l2_bridge_domain_t * bd_config, l2_flood_member_t * member);

u32 bd_remove_member (l2_bridge_domain_t * bd_config, u32 sw_if_index);

typedef enum bd_flags_t_
{
  L2_NONE = 0,
  L2_LEARN = (1 << 0),
  L2_FWD = (1 << 1),
  L2_FLOOD = (1 << 2),
  L2_UU_FLOOD = (1 << 3),
  L2_ARP_TERM = (1 << 4),
  L2_ARP_UFWD = (1 << 5),
} bd_flags_t;

u32 bd_set_flags (vlib_main_t * vm, u32 bd_index, bd_flags_t flags,
		  u32 enable);
void bd_set_mac_age (vlib_main_t * vm, u32 bd_index, u8 age);
int bd_add_del (l2_bridge_domain_add_del_args_t * args);

/**
 * \brief Get a bridge domain.
 *
 * Get a bridge domain with the given bridge domain ID.
 *
 * \param bdm bd_main pointer.
 * \param bd_id The bridge domain ID
 * \return The bridge domain index in \c l2input_main->l2_bridge_domain_t vector.
 */
u32 bd_find_index (bd_main_t * bdm, u32 bd_id);

/**
 * \brief Create a bridge domain.
 *
 * Create a bridge domain with the given bridge domain ID
 *
 * \param bdm bd_main pointer.
 * \return The bridge domain index in \c l2input_main->l2_bridge_domain_t vector.
 */
u32 bd_add_bd_index (bd_main_t * bdm, u32 bd_id);

/**
 * \brief Get or create a bridge domain.
 *
 * Get a bridge domain with the given bridge domain ID, if one exists, otherwise
 * create one with the given ID, or the first unused ID if the given ID is ~0..
 *
 * \param bdm bd_main pointer.
 * \param bd_id The bridge domain ID
 * \return The bridge domain index in \c l2input_main->l2_bridge_domain_t vector.
 */
static inline u32
bd_find_or_add_bd_index (bd_main_t * bdm, u32 bd_id)
{
  u32 bd_index = bd_find_index (bdm, bd_id);
  if (bd_index == ~0)
    return bd_add_bd_index (bdm, bd_id);
  return bd_index;
}

u32 bd_add_del_ip_mac (u32 bd_index,
		       ip46_type_t type,
		       const ip46_address_t * ip_addr,
		       const mac_address_t * mac, u8 is_add);

void bd_flush_ip_mac (u32 bd_index);

#endif

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */
span> { dvr_dpo_add_or_lock (uplink_sw_if_index, fib_proto_to_dpo (fproto), &gg->gg_dpo[fproto]); } /* * Add the uplink to the BD * packets direct from the uplink have had policy applied */ gg->gg_uplink_itf = gbp_itf_l2_add_and_lock (gg->gg_uplink_sw_if_index, gbi); gbp_itf_l2_set_input_feature (gg->gg_uplink_itf, L2INPUT_FEAT_GBP_NULL_CLASSIFY); } hash_set (gbp_endpoint_group_db.gg_hash_sclass, gg->gg_sclass, gg - gbp_endpoint_group_pool); } else { gg = gbp_endpoint_group_get (ggi); gg->gg_locks++; } GBP_EPG_DBG ("add: %U", format_gbp_endpoint_group, gg); return (0); } void gbp_endpoint_group_unlock (index_t ggi) { gbp_endpoint_group_t *gg; if (INDEX_INVALID == ggi) return; gg = gbp_endpoint_group_get (ggi); gg->gg_locks--; if (0 == gg->gg_locks) { fib_protocol_t fproto; gg = pool_elt_at_index (gbp_endpoint_group_pool, ggi); gbp_itf_unlock (&gg->gg_uplink_itf); FOR_EACH_FIB_IP_PROTOCOL (fproto) { dpo_reset (&gg->gg_dpo[fproto]); } gbp_bridge_domain_unlock (gg->gg_gbd); gbp_route_domain_unlock (gg->gg_rd); if (SCLASS_INVALID != gg->gg_sclass) hash_unset (gbp_epg_sclass_db, gg->gg_sclass); hash_unset (gbp_endpoint_group_db.gg_hash_sclass, gg->gg_sclass); pool_put (gbp_endpoint_group_pool, gg); } } int gbp_endpoint_group_delete (sclass_t sclass) { index_t ggi; ggi = gbp_endpoint_group_find (sclass); if (INDEX_INVALID != ggi) { GBP_EPG_DBG ("del: %U", format_gbp_endpoint_group, gbp_endpoint_group_get (ggi)); gbp_endpoint_group_unlock (ggi); return (0); } return (VNET_API_ERROR_NO_SUCH_ENTRY); } u32 gbp_endpoint_group_get_bd_id (const gbp_endpoint_group_t * gg) { const gbp_bridge_domain_t *gb; gb = gbp_bridge_domain_get (gg->gg_gbd); return (gb->gb_bd_id); } index_t gbp_endpoint_group_get_fib_index (const gbp_endpoint_group_t * gg, fib_protocol_t fproto) { const gbp_route_domain_t *grd; grd = gbp_route_domain_get (gg->gg_rd); return (grd->grd_fib_index[fproto]); } void gbp_endpoint_group_walk (gbp_endpoint_group_cb_t cb, void *ctx) { gbp_endpoint_group_t *gbpe; /* *INDENT-OFF* */ pool_foreach(gbpe, gbp_endpoint_group_pool, { if (!cb(gbpe, ctx)) break; }); /* *INDENT-ON* */ } static clib_error_t * gbp_endpoint_group_cli (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { gbp_endpoint_retention_t retention = { 0 }; vnid_t vnid = VNID_INVALID, sclass; vnet_main_t *vnm = vnet_get_main (); u32 uplink_sw_if_index = ~0; u32 bd_id = ~0; u32 rd_id = ~0; u8 add = 1; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "%U", unformat_vnet_sw_interface, vnm, &uplink_sw_if_index)) ; else if (unformat (input, "add")) add = 1; else if (unformat (input, "del")) add = 0; else if (unformat (input, "epg %d", &vnid)) ; else if (unformat (input, "sclass %d", &sclass)) ; else if (unformat (input, "bd %d", &bd_id)) ; else if (unformat (input, "rd %d", &rd_id)) ; else break; } if (VNID_INVALID == vnid) return clib_error_return (0, "EPG-ID must be specified"); if (add) { if (~0 == bd_id) return clib_error_return (0, "Bridge-domain must be specified"); if (~0 == rd_id) return clib_error_return (0, "route-domain must be specified"); gbp_endpoint_group_add_and_lock (vnid, sclass, bd_id, rd_id, uplink_sw_if_index, &retention); } else gbp_endpoint_group_delete (vnid); return (NULL); } /*? * Configure a GBP Endpoint Group * * @cliexpar * @cliexstart{gbp endpoint-group [del] epg <ID> bd <ID> rd <ID> [sclass <ID>] [<interface>]} * @cliexend ?*/ /* *INDENT-OFF* */ VLIB_CLI_COMMAND (gbp_endpoint_group_cli_node, static) = { .path = "gbp endpoint-group", .short_help = "gbp endpoint-group [del] epg <ID> bd <ID> rd <ID> [sclass <ID>] [<interface>]", .function = gbp_endpoint_group_cli, }; static u8 * format_gbp_endpoint_retention (u8 * s, va_list * args) { gbp_endpoint_retention_t *rt = va_arg (*args, gbp_endpoint_retention_t*); s = format (s, "[remote-EP-timeout:%d]", rt->remote_ep_timeout); return (s); } u8 * format_gbp_endpoint_group (u8 * s, va_list * args) { gbp_endpoint_group_t *gg = va_arg (*args, gbp_endpoint_group_t*); if (NULL != gg) s = format (s, "[%d] %d, sclass:%d bd:%d rd:%d uplink:%U retention:%U locks:%d", gg - gbp_endpoint_group_pool, gg->gg_vnid, gg->gg_sclass, gg->gg_gbd, gg->gg_rd, format_gbp_itf_hdl, gg->gg_uplink_itf, format_gbp_endpoint_retention, &gg->gg_retention, gg->gg_locks); else s = format (s, "NULL"); return (s); } static int gbp_endpoint_group_show_one (gbp_endpoint_group_t *gg, void *ctx) { vlib_main_t *vm; vm = ctx; vlib_cli_output (vm, " %U",format_gbp_endpoint_group, gg); return (1); } static clib_error_t * gbp_endpoint_group_show (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { vlib_cli_output (vm, "Endpoint-Groups:"); gbp_endpoint_group_walk (gbp_endpoint_group_show_one, vm); return (NULL); } /*? * Show Group Based Policy Endpoint_Groups and derived information * * @cliexpar * @cliexstart{show gbp endpoint_group} * @cliexend ?*/ /* *INDENT-OFF* */ VLIB_CLI_COMMAND (gbp_endpoint_group_show_node, static) = { .path = "show gbp endpoint-group", .short_help = "show gbp endpoint-group\n", .function = gbp_endpoint_group_show, }; /* *INDENT-ON* */ static clib_error_t * gbp_endpoint_group_init (vlib_main_t * vm) { gg_logger = vlib_log_register_class ("gbp", "epg"); return (NULL); } VLIB_INIT_FUNCTION (gbp_endpoint_group_init); /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */