FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
sr_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * sr_api.c - ipv6 segment routing api
4  *
5  * Copyright (c) 2016 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <vnet/vnet.h>
21 #include <vnet/srv6/sr.h>
22 #include <vlibmemory/api.h>
23 
24 #include <vnet/interface.h>
25 #include <vnet/api_errno.h>
26 #include <vnet/feature/feature.h>
27 
28 #include <vnet/vnet_msg_enum.h>
29 
30 #define vl_typedefs /* define message structures */
31 #include <vnet/vnet_all_api_h.h>
32 #undef vl_typedefs
33 
34 #define vl_endianfun /* define message structures */
35 #include <vnet/vnet_all_api_h.h>
36 #undef vl_endianfun
37 
38 /* instantiate all the print functions we know about */
39 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
40 #define vl_printfun
41 #include <vnet/vnet_all_api_h.h>
42 #undef vl_printfun
43 
45 
46 #define foreach_vpe_api_msg \
47 _(SR_LOCALSID_ADD_DEL, sr_localsid_add_del) \
48 _(SR_POLICY_ADD, sr_policy_add) \
49 _(SR_POLICY_MOD, sr_policy_mod) \
50 _(SR_POLICY_DEL, sr_policy_del) \
51 _(SR_STEERING_ADD_DEL, sr_steering_add_del) \
52 _(SR_SET_ENCAP_SOURCE, sr_set_encap_source) \
53 _(SR_SET_ENCAP_HOP_LIMIT, sr_set_encap_hop_limit) \
54 _(SR_LOCALSIDS_DUMP, sr_localsids_dump) \
55 _(SR_POLICIES_DUMP, sr_policies_dump) \
56 _(SR_STEERING_POL_DUMP, sr_steering_pol_dump)
57 
60 {
61  vl_api_sr_localsid_add_del_reply_t *rmp;
62  int rv = 0;
63 /*
64  * int sr_cli_localsid (char is_del, ip6_address_t *localsid_addr,
65  * char end_psp, u8 behavior, u32 sw_if_index, u32 vlan_index, u32 fib_table,
66  * ip46_address_t *nh_addr, void *ls_plugin_mem)
67  */
68  if (mp->behavior == SR_BEHAVIOR_X ||
69  mp->behavior == SR_BEHAVIOR_DX6 ||
72 
73  ip46_address_t prefix;
74 
75  clib_memset (&prefix, 0, sizeof (ip46_address_t));
76  if ((mp->nh_addr4[0] | mp->nh_addr4[1] | mp->
77  nh_addr4[2] | mp->nh_addr4[3]) != 0)
78  memcpy (&prefix.ip4, mp->nh_addr4, sizeof (prefix.ip4));
79  else
80  memcpy (&prefix.ip6, mp->nh_addr6, sizeof (prefix.ip6));
81 
82  rv = sr_cli_localsid (mp->is_del,
83  (ip6_address_t *) & mp->localsid, 0,
84  mp->end_psp,
85  mp->behavior,
86  ntohl (mp->sw_if_index),
87  ntohl (mp->vlan_index),
88  ntohl (mp->fib_table), &prefix, NULL);
89 
91  REPLY_MACRO (VL_API_SR_LOCALSID_ADD_DEL_REPLY);
92 }
93 
94 static void
96 {
97  vl_api_sr_policy_add_reply_t *rmp;
98  ip6_address_t *segments = 0, *seg;
99  ip6_address_t *this_address = (ip6_address_t *) mp->sids.sids;
100 
101  int i;
102  for (i = 0; i < mp->sids.num_sids; i++)
103  {
104  vec_add2 (segments, seg, 1);
105  clib_memcpy (seg->as_u8, this_address->as_u8, sizeof (*this_address));
106  this_address++;
107  }
108 
109 /*
110  * sr_policy_add (ip6_address_t *bsid, ip6_address_t *segments,
111  * u32 weight, u8 behavior, u32 fib_table, u8 is_encap,
112  * u16 behavior, void *plugin_mem)
113  */
114  int rv = 0;
115  rv = sr_policy_add ((ip6_address_t *) & mp->bsid_addr,
116  segments,
117  ntohl (mp->sids.weight),
118  mp->type, ntohl (mp->fib_table), mp->is_encap, 0, NULL);
119  vec_free (segments);
120 
121  REPLY_MACRO (VL_API_SR_POLICY_ADD_REPLY);
122 }
123 
124 static void
126 {
127  vl_api_sr_policy_mod_reply_t *rmp;
128 
129  ip6_address_t *segments = 0, *seg;
130  ip6_address_t *this_address = (ip6_address_t *) mp->sids.sids;
131 
132  int i;
133  for (i = 0; i < mp->sids.num_sids; i++)
134  {
135  vec_add2 (segments, seg, 1);
136  clib_memcpy (seg->as_u8, this_address->as_u8, sizeof (*this_address));
137  this_address++;
138  }
139 
140  int rv = 0;
141 /*
142  * int
143  * sr_policy_mod(ip6_address_t *bsid, u32 index, u32 fib_table,
144  * u8 operation, ip6_address_t *segments, u32 sl_index,
145  * u32 weight, u8 is_encap)
146  */
147  rv = sr_policy_mod ((ip6_address_t *) & mp->bsid_addr,
148  ntohl (mp->sr_policy_index),
149  ntohl (mp->fib_table),
150  mp->operation,
151  segments, ntohl (mp->sl_index),
152  ntohl (mp->sids.weight));
153  vec_free (segments);
154 
155  REPLY_MACRO (VL_API_SR_POLICY_MOD_REPLY);
156 }
157 
158 static void
160 {
161  vl_api_sr_policy_del_reply_t *rmp;
162  int rv = 0;
163 /*
164  * int
165  * sr_policy_del (ip6_address_t *bsid, u32 index)
166  */
167  rv = sr_policy_del ((ip6_address_t *) & mp->bsid_addr,
168  ntohl (mp->sr_policy_index));
169 
170  REPLY_MACRO (VL_API_SR_POLICY_DEL_REPLY);
171 }
172 
173 static void
175 {
176  vl_api_sr_set_encap_source_reply_t *rmp;
177  int rv = 0;
179 
180  REPLY_MACRO (VL_API_SR_SET_ENCAP_SOURCE_REPLY);
181 }
182 
183 static void
185 {
186  vl_api_sr_set_encap_hop_limit_reply_t *rmp;
187  int rv = 0;
188 
189  if (mp->hop_limit == 0)
190  rv = VNET_API_ERROR_INVALID_VALUE;
191  else
193 
194  REPLY_MACRO (VL_API_SR_SET_ENCAP_HOP_LIMIT_REPLY);
195 }
196 
199 {
200  vl_api_sr_steering_add_del_reply_t *rmp;
201  int rv = 0;
202 /*
203  * int
204  * sr_steering_policy(int is_del, ip6_address_t *bsid, u32 sr_policy_index,
205  * u32 table_id, ip46_address_t *prefix, u32 mask_width, u32 sw_if_index,
206  * u8 traffic_type)
207  */
208  if (mp->traffic_type == SR_STEER_L2)
210 
211  rv = sr_steering_policy (mp->is_del,
212  (ip6_address_t *) & mp->bsid_addr,
213  ntohl (mp->sr_policy_index),
214  ntohl (mp->table_id),
215  (ip46_address_t *) & mp->prefix_addr,
216  ntohl (mp->mask_width),
217  ntohl (mp->sw_if_index), mp->traffic_type);
218 
220  REPLY_MACRO (VL_API_SR_STEERING_ADD_DEL_REPLY);
221 }
222 
223 static void send_sr_localsid_details
225 {
227 
228  rmp = vl_msg_api_alloc (sizeof (*rmp));
229  clib_memset (rmp, 0, sizeof (*rmp));
230  rmp->_vl_msg_id = ntohs (VL_API_SR_LOCALSIDS_DETAILS);
231  clib_memcpy (rmp->addr.addr, &t->localsid, sizeof (ip6_address_t));
232  rmp->end_psp = t->end_psp;
233  rmp->behavior = htons (t->behavior);
234  rmp->fib_table = htonl (t->fib_table);
235  rmp->vlan_index = htonl (t->vlan_index);
236  if (ip46_address_is_ip4 (&t->next_hop))
237  clib_memcpy (rmp->xconnect_nh_addr4, &t->next_hop.ip4,
238  sizeof (ip4_address_t));
239  else
240  clib_memcpy (rmp->xconnect_nh_addr6, &t->next_hop.ip6,
241  sizeof (ip6_address_t));
242  rmp->xconnect_iface_or_vrf_table = htonl (t->sw_if_index);
243  rmp->context = context;
244 
245  vl_api_send_msg (reg, (u8 *) rmp);
246 }
247 
250 {
252  ip6_sr_main_t *sm = &sr_main;
254 
256  if (!reg)
257  return;
258 
259  /* *INDENT-OFF* */
260  pool_foreach (t, sm->localsids,
261  ({
262  send_sr_localsid_details(t, reg, mp->context);
263  }));
264  /* *INDENT-ON* */
265 }
266 
267 static void send_sr_policies_details
269 {
271  ip6_sr_main_t *sm = &sr_main;
272 
273  u32 *sl_index;
274  ip6_sr_sl_t *segment_list = 0;
275  vl_api_srv6_sid_list_t *write_sid_list;
276 
277  rmp = vl_msg_api_alloc (sizeof (*rmp) +
278  vec_len (t->segments_lists) *
279  sizeof (vl_api_srv6_sid_list_t));
280  clib_memset (rmp, 0,
281  (sizeof (*rmp) +
282  vec_len (t->segments_lists) *
283  sizeof (vl_api_srv6_sid_list_t)));
284 
285  rmp->_vl_msg_id = ntohs (VL_API_SR_POLICIES_DETAILS);
286  clib_memcpy (rmp->bsid.addr, &t->bsid, sizeof (ip6_address_t));
287  rmp->is_encap = t->is_encap;
288  rmp->type = t->type;
289  rmp->fib_table = htonl (t->fib_table);
291 
292  /* Fill in all the segments lists */
293  vec_foreach (sl_index, t->segments_lists)
294  {
295  segment_list = pool_elt_at_index (sm->sid_lists, *sl_index);
296  write_sid_list = &rmp->sid_lists[sl_index - t->segments_lists];
297  write_sid_list->num_sids = vec_len (segment_list->segments);
298  write_sid_list->weight = htonl (segment_list->weight);
299  clib_memcpy (write_sid_list->sids, segment_list->segments,
300  vec_len (segment_list->segments) * sizeof (ip6_address_t));
301  }
302 
303  rmp->context = context;
304  vl_api_send_msg (reg, (u8 *) rmp);
305 }
306 
307 static void
309 {
311  ip6_sr_main_t *sm = &sr_main;
312  ip6_sr_policy_t *t;
313 
315  if (!reg)
316  return;
317 
318  /* *INDENT-OFF* */
319  pool_foreach (t, sm->sr_policies,
320  ({
321  send_sr_policies_details(t, reg, mp->context);
322  }));
323  /* *INDENT-ON* */
324 }
325 
328 {
330  ip6_sr_main_t *sm = &sr_main;
331 
332  rmp = vl_msg_api_alloc (sizeof (*rmp));
333  clib_memset (rmp, 0, sizeof (*rmp));
334  rmp->_vl_msg_id = ntohs (VL_API_SR_STEERING_POL_DETAILS);
335 
336  //Get the SR policy BSID
337  ip6_sr_policy_t *p;
339  clib_memcpy (rmp->bsid.addr, &p->bsid, sizeof (ip6_address_t));
340 
341  //Get the steering
343  rmp->fib_table = htonl (t->classify.l3.fib_table);
344  rmp->mask_width = htonl (t->classify.l3.mask_width);
345  if (ip46_address_is_ip4 (&t->classify.l3.prefix))
346  clib_memcpy (rmp->prefix_addr, &t->classify.l3.prefix.ip4,
347  sizeof (ip4_address_t));
348  else
349  clib_memcpy (rmp->prefix_addr, &t->classify.l3.prefix.ip6,
350  sizeof (ip6_address_t));
351 
352  rmp->sw_if_index = htonl (t->classify.l2.sw_if_index);
353 
354  rmp->context = context;
355  vl_api_send_msg (reg, (u8 *) rmp);
356 }
357 
360 {
362  ip6_sr_main_t *sm = &sr_main;
364 
366  if (!reg)
367  return;
368 
369  /* *INDENT-OFF* */
371  ({
372  send_sr_steering_pol_details(t, reg, mp->context);
373  }));
374  /* *INDENT-ON* */
375 }
376 
377 /*
378  * sr_api_hookup
379  * Add vpe's API message handlers to the table.
380  * vlib has already mapped shared memory and
381  * added the client registration handlers.
382  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
383  */
384 #define vl_msg_name_crc_list
385 #include <vnet/vnet_all_api_h.h>
386 #undef vl_msg_name_crc_list
387 
388 static void
390 {
391 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
392  foreach_vl_msg_name_crc_sr;
393 #undef _
394 }
395 
396 static clib_error_t *
398 {
399  api_main_t *am = vlibapi_get_main ();
400 
401 #define _(N,n) \
402  vl_msg_api_set_handlers(VL_API_##N, #n, \
403  vl_api_##n##_t_handler, \
404  vl_noop_handler, \
405  vl_api_##n##_t_endian, \
406  vl_api_##n##_t_print, \
407  sizeof(vl_api_##n##_t), 1);
409 #undef _
410 
411  /*
412  * Set up the (msg_name, crc, message-id) table
413  */
415 
416  return 0;
417 }
418 
420 
421 /*
422  * fd.io coding-style-patch-verification: ON
423  *
424  * Local Variables:
425  * eval: (c-set-style "gnu")
426  * End:
427  */
ip6_sr_main_t sr_main
Definition: sr.c:31
int sr_cli_localsid(char is_del, ip6_address_t *localsid_addr, u16 prefixlen, char end_psp, u8 behavior, u32 sw_if_index, u32 vlan_index, u32 fib_table, ip46_address_t *nh_addr, void *ls_plugin_mem)
SR localsid add/del.
Definition: sr_localsid.c:66
u8 type
Type (default is 0)
Definition: sr.h:97
u32 vlan_index
VLAN tag (not an index)
Definition: sr.h:136
void sr_set_source(ip6_address_t *address)
#define SR_BEHAVIOR_X
Definition: sr.h:38
SR LocalSID.
Definition: sr.h:118
u32 fib_table
FIB table.
Definition: sr.h:105
u8 as_u8[16]
Definition: ip6_packet.h:48
int sr_steering_policy(int is_del, ip6_address_t *bsid, u32 sr_policy_index, u32 table_id, ip46_address_t *prefix, u32 mask_width, u32 sw_if_index, u8 traffic_type)
Steer traffic L2 and L3 traffic through a given SR policy.
Definition: sr_steering.c:60
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static void send_sr_policies_details(ip6_sr_policy_t *t, vl_api_registration_t *reg, u32 context)
Definition: sr_api.c:268
vl_api_srv6_sid_t bsid
Definition: sr.api:240
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
ip6_address_t * segments
SIDs (key)
Definition: sr.h:70
u8 bsid_addr[16]
Definition: sr.api:81
static void vl_api_sr_policy_add_t_handler(vl_api_sr_policy_add_t *mp)
Definition: sr_api.c:95
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:561
for(i=1;i<=collision_buckets;i++)
int i
u16 behavior
Behavior associated to this localsid.
Definition: sr.h:126
vl_api_prefix_t prefix
Definition: ip.api:144
static u8 ip46_address_is_ip4(const ip46_address_t *ip46)
Definition: ip46_address.h:55
void * vl_msg_api_alloc(int nbytes)
ip6_sr_steering_policy_t * steer_policies
Definition: sr.h:258
unsigned char u8
Definition: types.h:56
IPv6 SR Set SRv6 encapsulation hop-limit.
Definition: sr.api:145
vl_api_srv6_sid_list_t sids
Definition: sr.api:110
struct sr_steering_key_t::@454::@457 l2
#define clib_memcpy(d, s, n)
Definition: string.h:180
static void vl_api_sr_steering_add_del_t_handler(vl_api_sr_steering_add_del_t *mp)
Definition: sr_api.c:198
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
vl_api_srv6_sid_list_t sids
Definition: sr.api:86
static void vl_api_sr_policy_mod_t_handler(vl_api_sr_policy_mod_t *mp)
Definition: sr_api.c:125
SR Segment List (SID list)
Definition: sr.h:68
unsigned int u32
Definition: types.h:88
vl_api_srv6_sid_t addr
Definition: sr.api:191
struct sr_steering_key_t::@454::@456 l3
static void send_sr_localsid_details(ip6_sr_localsid_t *t, vl_api_registration_t *reg, u32 context)
Definition: sr_api.c:224
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
static void vl_api_sr_localsids_dump_t_handler(vl_api_sr_localsids_dump_t *mp)
Definition: sr_api.c:249
static void setup_message_id_table(api_main_t *am)
Definition: sr_api.c:389
static void send_sr_steering_pol_details(ip6_sr_steering_policy_t *t, vl_api_registration_t *reg, u32 context)
Definition: sr_api.c:327
char end_psp
Combined with End.PSP?
Definition: sr.h:124
sr_steering_key_t classify
Traffic classification.
Definition: sr.h:230
#define REPLY_MACRO(t)
#define SR_BEHAVIOR_DX4
Definition: sr.h:43
vl_api_srv6_sid_t bsid
Definition: sr.api:214
static void vl_api_sr_steering_pol_dump_t_handler(vl_api_sr_policies_dump_t *mp)
Definition: sr_api.c:359
u8 is_encap
Mode (0 is SRH insert, 1 Encaps)
Definition: sr.h:107
vlib_main_t * vm
Definition: in2out_ed.c:1810
u32 sr_policy
SR Policy index.
Definition: sr.h:231
u32 weight
SID list weight (wECMP / UCMP)
Definition: sr.h:72
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:225
An API client registration, only in vpp/vlib.
Definition: api_common.h:46
ip6_sr_localsid_t * localsids
Definition: sr.h:252
#define BAD_SW_IF_INDEX_LABEL
vl_api_srv6_sid_t localsid
Definition: sr.api:52
VLIB_API_INIT_FUNCTION(sr_api_hookup)
vl_api_srv6_sid_list_t sid_lists[num_sid_lists]
Definition: sr.api:219
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
int sr_policy_del(ip6_address_t *bsid, u32 index)
Delete a SR policy.
u32 * segments_lists
SID lists indexes (vector)
Definition: sr.h:93
static void vl_api_sr_set_encap_hop_limit_t_handler(vl_api_sr_set_encap_hop_limit_t *mp)
Definition: sr_api.c:184
IPv6 SR Set SRv6 encapsulation source.
Definition: sr.api:133
static void vl_api_sr_policies_dump_t_handler(vl_api_sr_policies_dump_t *mp)
Definition: sr_api.c:308
IPv6 SR steering add/del.
Definition: sr.api:164
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:57
int sr_policy_add(ip6_address_t *bsid, ip6_address_t *segments, u32 weight, u8 behavior, u32 fib_table, u8 is_encap, u16 plugin, void *plugin_mem)
Create a new SR policy.
IPv6 SR policy deletion.
Definition: sr.api:119
vl_api_srv6_sid_t bsid_addr
Definition: sr.api:123
#define foreach_vpe_api_msg
Definition: sr_api.c:46
u32 fib_table
FIB table where localsid is registered.
Definition: sr.h:134
#define SR_BEHAVIOR_DX2
Definition: sr.h:41
IPv6 SR policy add.
Definition: sr.api:77
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip6_sr_policy_t * sr_policies
Definition: sr.h:246
SR Policy.
Definition: sr.h:91
static void vl_api_sr_policy_del_t_handler(vl_api_sr_policy_del_t *mp)
Definition: sr_api.c:159
static clib_error_t * sr_api_hookup(vlib_main_t *vm)
Definition: sr_api.c:397
ip6_sr_sl_t * sid_lists
Definition: sr.h:243
void sr_set_hop_limit(u8 hop_limit)
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:378
Segment Routing data structures definitions.
Segment Routing main datastructure.
Definition: sr.h:237
IPv6 SR policy modification.
Definition: sr.api:100
#define vec_foreach(var, vec)
Vector iterator.
u8 traffic_type
Traffic type (IPv4, IPv6, L2)
Definition: sr.h:224
ip46_address_t next_hop
Next_hop for xconnect usage only.
Definition: sr.h:138
static void vl_api_sr_localsid_add_del_t_handler(vl_api_sr_localsid_add_del_t *mp)
Definition: sr_api.c:59
Dump the list of SR policies.
Definition: sr.api:205
#define SR_STEER_L2
Definition: sr.h:48
u32 sw_if_index
xconnect only
Definition: sr.h:130
IPv6 SR LocalSID add/del request.
Definition: sr.api:47
ip6_address_t localsid
LocalSID IPv6 address.
Definition: sr.h:120
static void vl_api_sr_set_encap_source_t_handler(vl_api_sr_set_encap_source_t *mp)
Definition: sr_api.c:174
int sr_policy_mod(ip6_address_t *bsid, u32 index, u32 fib_table, u8 operation, ip6_address_t *segments, u32 sl_index, u32 weight)
Modify an existing SR policy.
ip6_address_t bsid
BindingSID (key)
Definition: sr.h:95
#define SR_BEHAVIOR_DX6
Definition: sr.h:42
#define VALIDATE_SW_IF_INDEX(mp)
Dump the list of SR LocalSIDs.
Definition: sr.api:182