FD.io VPP  v21.01.1
Vector Packet Processing
ip_neighbor_watch.c
Go to the documentation of this file.
1 /*
2  * ip_neighboor_watch.c; IP neighbor watching
3  *
4  * Copyright (c) 2019 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
20 #include <vnet/ip/ip_types_api.h>
22 
23 #include <vnet/ip-neighbor/ip_neighbor.api_enum.h>
24 #include <vnet/ip-neighbor/ip_neighbor.api_types.h>
25 
26 #include <vlibmemory/api.h>
27 
28 /**
29  * Database of registered watchers
30  * The key for a watcher is {type, sw_if_index, addreess}
31  * interface=~0 / address=all-zeros imples any.
32  */
34 {
37 
39 
40 static uword
43 {
44  ip_neighbor_event_t *ipne, *ipnes = NULL;
45  uword event_type = ~0;
46 
47  while (1)
48  {
50 
51  ipnes = vlib_process_get_event_data (vm, &event_type);
52 
53  switch (event_type)
54  {
55  default:
56  vec_foreach (ipne, ipnes) ip_neighbor_handle_event (ipne);
57  break;
58 
59  case ~0:
60  /* timeout - */
61  break;
62  }
63 
64  vec_reset_length (ipnes);
65  }
66  return 0;
67 }
68 
69 /* *INDENT-OFF* */
71  .function = ip_neighbor_event_process,
72  .type = VLIB_NODE_TYPE_PROCESS,
73  .name = "ip-neighbor-event",
74 };
75 /* *INDENT-ON* */
76 
77 
78 static clib_error_t *
80 {
81  ip_neighbor_key_t *key, *empty_keys = NULL;
82  ip_neighbor_watcher_t *watchers;
83  uword *v;
84  i32 pos;
85 
86  /* walk the entire IP neighbour DB and removes the client's registrations */
87  /* *INDENT-OFF* */
88  mhash_foreach(key, v, &ipnw_db.ipnwdb_hash,
89  ({
90  watchers = (ip_neighbor_watcher_t*) *v;
91 
92  vec_foreach_index_backwards (pos, watchers) {
93  if (watchers[pos].ipw_client == client_index)
94  vec_del1(watchers, pos);
95  }
96 
97  if (vec_len(watchers) == 0)
98  vec_add1 (empty_keys, *key);
99  }));
100  /* *INDENT-OFF* */
101 
102  vec_foreach (key, empty_keys)
103  mhash_unset (&ipnw_db.ipnwdb_hash, key, NULL);
104  vec_free (empty_keys);
105  return (NULL);
106 }
107 
109 
110 static int
112  const ip_neighbor_watcher_t * w2)
113 {
114  return (0 == clib_memcmp (w1, w2, sizeof(*w1)));
115 }
116 
117 void
120  const ip_neighbor_watcher_t * watch)
121 {
123  .ipnk_ip = *ip,
124  .ipnk_sw_if_index = (sw_if_index == 0 ? ~0 : sw_if_index),
125  };
126  ip_neighbor_watcher_t *ipws = NULL;
127  uword *p;
128 
129  p = mhash_get (&ipnw_db.ipnwdb_hash, &key);
130 
131  if (p)
132  {
133  ipws = (ip_neighbor_watcher_t*) p[0];
134 
135  if (~0 != vec_search_with_function (ipws, watch,
137  /* duplicate */
138  return;
139  }
140 
141  vec_add1 (ipws, *watch);
142 
143  mhash_set (&ipnw_db.ipnwdb_hash, &key, (uword) ipws, NULL);
144 }
145 
146 void
149  const ip_neighbor_watcher_t * watch)
150 {
152  .ipnk_ip = *ip,
153  .ipnk_sw_if_index = (sw_if_index == 0 ? ~0 : sw_if_index),
154  };
155  ip_neighbor_watcher_t *ipws = NULL;
156  uword *p;
157  u32 pos;
158 
159  p = mhash_get (&ipnw_db.ipnwdb_hash, &key);
160 
161  if (!p)
162  return;
163 
164  ipws = (ip_neighbor_watcher_t*) p[0];
165 
166  pos = vec_search_with_function (ipws, watch, ip_neighbor_watch_cmp);
167 
168  if (~0 == pos)
169  return;
170 
171  vec_del1 (ipws, pos);
172 
173  if (vec_len(ipws) == 0)
174  mhash_unset (&ipnw_db.ipnwdb_hash, &key, NULL);
175 }
176 
177 static void
179  index_t ipni,
181 {
182  ip_neighbor_watcher_t *watcher;
183 
184  vec_foreach (watcher, watchers) {
185  ip_neighbor_event_t *ipne;
186 
189  0, 1, sizeof(*ipne));
190  ipne->ipne_watch = *watcher;
191  ipne->ipne_flags = flags;
193  }
194 }
195 
196 void
199 {
200  const ip_neighbor_t *ipn;
202  uword *p;
203 
204  ipn = ip_neighbor_get (ipni);
205 
206  clib_memcpy (&key, ipn->ipn_key, sizeof (key));
207 
208  /* Search the DB from longest to shortest key */
209  p = mhash_get (&ipnw_db.ipnwdb_hash, &key);
210 
211  if (p) {
212  ip_neighbor_signal ((ip_neighbor_watcher_t*) p[0], ipni, flags);
213  }
214 
215  ip_address_reset (&key.ipnk_ip);
216  p = mhash_get (&ipnw_db.ipnwdb_hash, &key);
217 
218  if (p) {
219  ip_neighbor_signal ((ip_neighbor_watcher_t*) p[0], ipni, flags);
220  }
221 
222  key.ipnk_sw_if_index = ~0;
223  p = mhash_get (&ipnw_db.ipnwdb_hash, &key);
224 
225  if (p) {
226  ip_neighbor_signal ((ip_neighbor_watcher_t*) p[0], ipni, flags);
227  }
228 }
229 
230 static clib_error_t *
232  unformat_input_t * input,
233  vlib_cli_command_t * cmd)
234 {
235  ip_neighbor_watcher_t *watchers, *watcher;
237  uword *v;
238 
239  /* *INDENT-OFF* */
240  mhash_foreach(key, v, &ipnw_db.ipnwdb_hash,
241  ({
242  watchers = (ip_neighbor_watcher_t*) *v;
243 
244  ASSERT(vec_len(watchers));
245  vlib_cli_output (vm, "Key: %U", format_ip_neighbor_key, key);
246 
247  vec_foreach (watcher, watchers)
248  vlib_cli_output (vm, " %U", format_ip_neighbor_watcher, watcher);
249  }));
250  /* *INDENT-ON* */
251  return (NULL);
252 }
253 
254 /* *INDENT-OFF* */
255 VLIB_CLI_COMMAND (show_ip_neighbor_watchers_cmd_node, static) = {
256  .path = "show ip neighbor-watcher",
257  .function = ip_neighbor_watchers_show,
258  .short_help = "show ip neighbors-watcher",
259 };
260 /* *INDENT-ON* */
261 
262 static clib_error_t *
264 {
265  mhash_init (&ipnw_db.ipnwdb_hash,
266  sizeof (ip_neighbor_watcher_t *), sizeof (ip_neighbor_key_t));
267  return (NULL);
268 }
269 
270 /* *INDENT-OFF* */
272 {
273  .runs_after = VLIB_INITS("ip_neighbor_init"),
274 };
275 /* *INDENT-ON* */
276 
277 
278 /*
279  * fd.io coding-style-patch-verification: ON
280  *
281  * Local Variables:
282  * eval: (c-set-style "gnu")
283  * End:
284  */
static clib_error_t * want_ip_neighbor_events_reaper(u32 client_index)
static uword ip_neighbor_event_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: mhash.h:46
static int ip_neighbor_watch_cmp(const ip_neighbor_watcher_t *w1, const ip_neighbor_watcher_t *w2)
static clib_error_t * ip_neighbor_watch_init(vlib_main_t *vm)
vlib_node_registration_t ip_neighbor_event_process_node
(constructor) VLIB_REGISTER_NODE (ip_neighbor_event_process_node)
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:656
void ip_neighbor_clone(const ip_neighbor_t *ipn, ip_neighbor_t *clone)
struct ip_neighbor_watch_db_t_ ip_neighbor_watch_db_t
Database of registered watchers The key for a watcher is {type, sw_if_index, addreess} interface=~0 /...
#define mhash_foreach(k, v, mh, body)
Definition: mhash.h:159
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:592
vlib_main_t * vm
Definition: in2out_ed.c:1580
ip_neighbor_event_flags_t ipne_flags
void ip_neighbor_handle_event(ip_neighbor_event_t *ipne)
From the watcher to the API to publish a new neighbor.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
#define clib_memcpy(d, s, n)
Definition: string.h:180
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
A representation of an IP neighbour/peer.
void ip_neighbor_publish(index_t ipni, ip_neighbor_event_flags_t flags)
unsigned int u32
Definition: types.h:88
void ip_neighbor_unwatch(const ip_address_t *ip, u32 sw_if_index, const ip_neighbor_watcher_t *watch)
VL_MSG_API_REAPER_FUNCTION(want_ip_neighbor_events_reaper)
struct _unformat_input_t unformat_input_t
Database of registered watchers The key for a watcher is {type, sw_if_index, addreess} interface=~0 /...
static void * vlib_process_signal_event_data(vlib_main_t *vm, uword node_index, uword type_opaque, uword n_data_elts, uword n_data_elt_bytes)
Definition: node_funcs.h:909
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:875
static void ip_neighbor_signal(ip_neighbor_watcher_t *watchers, index_t ipni, ip_neighbor_event_flags_t flags)
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
__clib_export void mhash_init(mhash_t *h, uword n_value_bytes, uword n_key_bytes)
Definition: mhash.c:168
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:170
#define clib_memcmp(s1, s2, m1)
Definition: string.h:720
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
static ip_neighbor_watch_db_t ipnw_db
void ip_neighbor_watch(const ip_address_t *ip, u32 sw_if_index, const ip_neighbor_watcher_t *watch)
#define vec_search_with_function(v, E, fn)
Search a vector for the index of the entry that matches.
Definition: vec.h:1033
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
signed int i32
Definition: types.h:77
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
enum ip_neighbor_event_flags_t_ ip_neighbor_event_flags_t
ip_neighbor_key_t * ipn_key
The idempotent key.
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
typedef key
Definition: ipsec_types.api:86
__clib_export uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:346
static void * vlib_process_get_event_data(vlib_main_t *vm, uword *return_event_type_opaque)
Definition: node_funcs.h:526
vl_api_address_t ip
Definition: l2.api:501
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
ip_neighbor_t * ip_neighbor_get(index_t ipni)
Definition: ip_neighbor.c:88
void ip_address_reset(ip_address_t *ip)
Definition: ip_types.c:299
#define vec_foreach(var, vec)
Vector iterator.
static clib_error_t * ip_neighbor_watchers_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define VLIB_INITS(...)
Definition: init.h:357
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
ip_neighbor_watcher_t ipne_watch