2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 * init.c: mechanism for functions to be called at init/exit.
18 * Copyright (c) 2008 Eliot Dresselhaus
20 * Permission is hereby granted, free of charge, to any person obtaining
21 * a copy of this software and associated documentation files (the
22 * "Software"), to deal in the Software without restriction, including
23 * without limitation the rights to use, copy, modify, merge, publish,
24 * distribute, sublicense, and/or sell copies of the Software, and to
25 * permit persons to whom the Software is furnished to do so, subject to
26 * the following conditions:
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
31 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
40 #include <vlib/vlib.h>
41 #include <vppinfra/ptclosure.h>
45 * @brief Init function ordering and execution implementation
46 * Topological sort for all classes of init functions, and
47 * a relatively simple API routine to invoke them.
50 /*? %%clicmd:group_label Init functions %% ?*/
53 comma_split (u8 * s, u8 ** a, u8 ** b)
57 while (*s && *s != ',')
70 * @brief Topological sorter for init function chains.
71 * @param head [in/out] address of the listhead to be sorted
72 * @returns 0 on success, otherwise a clib_error_t *.
75 clib_error_t *vlib_sort_init_exit_functions
76 (_vlib_init_function_list_elt_t ** head)
80 u8 **init_f_names = 0;
82 char **these_constraints;
83 char *this_constraint_c;
95 _vlib_init_function_list_elt_t *this_reg = 0;
97 u8 **keys_to_delete = 0;
100 * two hash tables: name to index in init_f_names, and
101 * init function registration pointer by index
103 index_by_name = hash_create_string (0, sizeof (uword));
104 reg_by_index = hash_create (0, sizeof (uword));
108 /* pass 1, collect init fcn names, construct a before b pairs */
111 init_f_name = format (0, "%s%c", this_reg->name, 0);
112 hash_set (reg_by_index, vec_len (init_f_names), (uword) this_reg);
114 hash_set_mem (index_by_name, init_f_name, vec_len (init_f_names));
116 vec_add1 (init_f_names, init_f_name);
118 these_constraints = this_reg->runs_before;
119 while (these_constraints && these_constraints[0])
121 this_constraint_c = these_constraints[0];
123 constraint_tuple = format (0, "%s,%s%c", init_f_name,
124 this_constraint_c, 0);
125 vec_add1 (constraints, constraint_tuple);
129 these_constraints = this_reg->runs_after;
130 while (these_constraints && these_constraints[0])
132 this_constraint_c = these_constraints[0];
134 constraint_tuple = format (0, "%s,%s%c",
135 this_constraint_c, init_f_name, 0);
136 vec_add1 (constraints, constraint_tuple);
140 this_reg = this_reg->next_init_function;
144 * pass 2: collect "a then b then c then d" constraints.
145 * all init fcns must be known at this point.
150 these_constraints = this_reg->init_order;
153 /* Across the list of constraints */
154 while (these_constraints && these_constraints[0])
156 this_constraint_c = these_constraints[0];
157 p = hash_get_mem (index_by_name, this_constraint_c);
161 ("order constraint fcn '%s' not found", this_constraint_c);
168 prev_name = this_constraint_c;
173 constraint_tuple = format (0, "%s,%s%c", prev_name,
174 this_constraint_c, 0);
175 vec_add1 (constraints, constraint_tuple);
176 prev_name = this_constraint_c;
179 this_reg = this_reg->next_init_function;
182 n_init_fns = vec_len (init_f_names);
183 orig = clib_ptclosure_alloc (n_init_fns);
185 for (i = 0; i < vec_len (constraints); i++)
187 this_constraint = constraints[i];
189 if (comma_split (this_constraint, &a_name, &b_name))
190 return clib_error_return (0, "comma_split failed!");
192 p = hash_get_mem (index_by_name, a_name);
194 * Note: the next two errors mean that something is
195 * b0rked. As in: if you code "A runs before on B," and you type
196 * B incorrectly, you lose. Nonexistent init functions are tolerated.
200 clib_warning ("init function '%s' not found (before '%s')",
206 p = hash_get_mem (index_by_name, b_name);
209 clib_warning ("init function '%s' not found (after '%s')",
215 /* add a before b to the original set of constraints */
216 orig[a_index][b_index] = 1;
217 vec_free (this_constraint);
220 /* Compute the positive transitive closure of the original constraints */
221 closure = clib_ptclosure (orig);
223 /* Compute a partial order across feature nodes, if one exists. */
225 for (i = 0; i < n_init_fns; i++)
227 for (j = 0; j < n_init_fns; j++)
230 goto item_constrained;
232 /* Item i can be output */
233 vec_add1 (result, i);
235 for (k = 0; k < n_init_fns; k++)
238 * Add a "Magic" a before a constraint.
239 * This means we'll never output it again
248 /* see if we got a partial order... */
249 if (vec_len (result) != n_init_fns)
250 return clib_error_return
251 (0, "Failed to find a suitable init function order!");
255 * Bind the index variables, and output the feature node name vector
256 * using the partial order we just computed. Result is in stack
257 * order, because the entry with the fewest constraints (e.g. none)
258 * is output first, etc.
259 * Reset the listhead, and add items in result (aka reverse) order.
262 for (i = 0; i < n_init_fns; i++)
264 p = hash_get (reg_by_index, result[i]);
266 this_reg = (_vlib_init_function_list_elt_t *) p[0];
268 this_reg->next_init_function = *head;
272 /* Finally, clean up all the fine data we allocated */
273 hash_foreach_pair (hp, index_by_name,
275 vec_add1 (keys_to_delete, (u8 *)hp->key);
277 hash_free (index_by_name);
278 for (i = 0; i < vec_len (keys_to_delete); i++)
279 vec_free (keys_to_delete[i]);
280 vec_free (keys_to_delete);
281 hash_free (reg_by_index);
283 clib_ptclosure_free (orig);
284 clib_ptclosure_free (closure);
289 * @brief call a set of init / exit / main-loop enter functions
290 * @param vm vlib_main_t
291 * @param head address of the listhead to sort and then invoke
292 * @returns 0 on success, clib_error_t * on error
294 * The "init_functions_called" hash supports a subtle mix of procedural
295 * and formally-specified ordering constraints. The following schemes
296 * are *roughly* equivalent:
298 * static clib_error_t *init_runs_first (vlib_main_t *vm)
300 * clib_error_t *error;
302 * ... do some stuff...
304 * if ((error = vlib_call_init_function (init_runs_next)))
308 * VLIB_INIT_FUNCTION (init_runs_first);
312 * static clib_error_t *init_runs_first (vlib_main_t *vm)
314 * ... do some stuff...
316 * VLIB_INIT_FUNCTION (init_runs_first) =
318 * .runs_before = VLIB_INITS("init_runs_next"),
321 * The first form will [most likely] call "init_runs_next" on the
322 * spot. The second form means that "init_runs_first" runs before
323 * "init_runs_next," possibly much earlier in the sequence.
325 * Please DO NOT construct sets of init functions where A before B
326 * actually means A *right before* B. It's not necessary - simply combine
327 * A and B - and it leads to hugely annoying debugging exercises.
330 static inline clib_error_t *
331 call_init_exit_functions_internal (vlib_main_t *vm,
332 _vlib_init_function_list_elt_t **headp,
333 int call_once, int do_sort, int is_global)
335 vlib_global_main_t *vgm = vlib_get_global_main ();
336 clib_error_t *error = 0;
337 _vlib_init_function_list_elt_t *i;
339 if (do_sort && (error = vlib_sort_init_exit_functions (headp)))
348 h = hash_get (vgm->init_functions_called, i->f);
350 h = hash_get (vm->worker_init_functions_called, i->f);
357 hash_set1 (vgm->init_functions_called, i->f);
359 hash_set1 (vm->worker_init_functions_called, i->f);
365 i = i->next_init_function;
371 vlib_call_init_exit_functions (vlib_main_t *vm,
372 _vlib_init_function_list_elt_t **headp,
373 int call_once, int is_global)
375 return call_init_exit_functions_internal (vm, headp, call_once,
376 1 /* do_sort */, is_global);
380 vlib_call_init_exit_functions_no_sort (vlib_main_t *vm,
381 _vlib_init_function_list_elt_t **headp,
382 int call_once, int is_global)
384 return call_init_exit_functions_internal (vm, headp, call_once,
385 0 /* do_sort */, is_global);
389 vlib_call_all_init_functions (vlib_main_t * vm)
391 vlib_global_main_t *vgm = vlib_get_global_main ();
392 /* Call placeholder functions to make sure purely static modules are
394 #define _(f) vlib_##f##_reference ();
395 foreach_vlib_module_reference;
398 return vlib_call_init_exit_functions (vm, &vgm->init_function_registrations,
399 1 /* call_once */, 1 /* is_global */);
403 vlib_call_all_main_loop_enter_functions (vlib_main_t * vm)
405 vlib_global_main_t *vgm = vlib_get_global_main ();
406 return vlib_call_init_exit_functions (
407 vm, &vgm->main_loop_enter_function_registrations, 1 /* call_once */,
412 vlib_call_all_main_loop_exit_functions (vlib_main_t * vm)
414 vlib_global_main_t *vgm = vlib_get_global_main ();
415 return vlib_call_init_exit_functions (
416 vm, &vgm->main_loop_exit_function_registrations, 1 /* call_once */,
421 vlib_call_all_config_functions (vlib_main_t * vm,
422 unformat_input_t * input, int is_early)
424 vlib_global_main_t *vgm = vlib_get_global_main ();
425 clib_error_t *error = 0;
426 vlib_config_function_runtime_t *c, **all;
430 hash = hash_create_string (0, sizeof (uword));
433 c = vgm->config_function_registrations;
437 hash_set_mem (hash, c->name, vec_len (all));
439 unformat_init (&c->input, 0, 0);
440 c = c->next_registration;
443 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
447 if (!unformat (input, "%s %v", &s, &v) || !(p = hash_get_mem (hash, s)))
449 error = clib_error_create ("unknown input `%s %v'", s, v);
454 if (vec_len (c->input.buffer) > 0)
455 vec_add1 (c->input.buffer, ' ');
456 vec_add (c->input.buffer, v, vec_len (v));
461 for (i = 0; i < vec_len (all); i++)
465 /* Is this an early config? Are we doing early configs? */
466 if (is_early ^ c->is_early)
469 /* Already called? */
470 if (hash_get (vgm->init_functions_called, c->function))
472 hash_set1 (vgm->init_functions_called, c->function);
474 error = c->function (vm, &c->input);
480 for (i = 0; i < vec_len (all); i++)
483 unformat_free (&c->input);
491 vlib_init_dump (void)
493 vlib_global_main_t *vgm = vlib_get_global_main ();
496 _vlib_init_function_list_elt_t *head, *this;
497 head = vgm->init_function_registrations;
502 fformat (stdout, "[%d]: %s\n", i++, this->name);
503 this = this->next_init_function;
507 static clib_error_t *
508 show_init_function_command_fn (vlib_main_t * vm,
509 unformat_input_t * input,
510 vlib_cli_command_t * cmd)
512 vlib_global_main_t *vgm = vlib_get_global_main ();
516 _vlib_init_function_list_elt_t *head, *this;
517 uword *index_by_name;
519 u8 **init_f_names = 0;
522 _vlib_init_function_list_elt_t *this_reg = 0;
524 u8 **keys_to_delete = 0;
526 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
528 if (unformat (input, "init"))
530 else if (unformat (input, "enter"))
532 else if (unformat (input, "exit"))
534 else if (unformat (input, "verbose %d", &verbose))
536 else if (unformat (input, "verbose"))
545 head = vgm->init_function_registrations;
548 head = vgm->main_loop_enter_function_registrations;
551 head = vgm->main_loop_exit_function_registrations;
554 return clib_error_return (0, "BUG");
563 vlib_cli_output (vm, "[%d]: %s", i++, this->name);
564 this = this->next_init_function;
569 index_by_name = hash_create_string (0, sizeof (uword));
570 reg_by_index = hash_create (0, sizeof (uword));
574 /* collect init fcn names */
577 init_f_name = format (0, "%s%c", this_reg->name, 0);
578 hash_set (reg_by_index, vec_len (init_f_names), (uword) this_reg);
580 hash_set_mem (index_by_name, init_f_name, vec_len (init_f_names));
581 vec_add1 (init_f_names, init_f_name);
583 this_reg = this_reg->next_init_function;
586 for (i = 0; i < n_init_fns; i++)
588 p = hash_get (reg_by_index, i);
590 this_reg = (_vlib_init_function_list_elt_t *) p[0];
591 vlib_cli_output (vm, "[%d] %s", i, this_reg->name);
593 char **runs_before, **runs_after, **init_order;
594 runs_before = this_reg->runs_before;
595 while (runs_before && runs_before[0])
597 _vlib_init_function_list_elt_t *successor;
598 uword successor_index;
599 p = hash_get_mem (index_by_name, runs_before[0]);
602 clib_warning ("couldn't find successor '%s'", runs_before[0]);
606 successor_index = p[0];
607 p = hash_get (reg_by_index, p[0]);
609 successor = (_vlib_init_function_list_elt_t *) p[0];
610 vlib_cli_output (vm, " before '%s' [%lld]",
611 successor->name, successor_index);
614 runs_after = this_reg->runs_after;
615 while (runs_after && runs_after[0])
617 _vlib_init_function_list_elt_t *predecessor;
618 uword predecessor_index;
619 p = hash_get_mem (index_by_name, runs_after[0]);
622 clib_warning ("couldn't find predecessor '%s'",
627 predecessor_index = p[0];
628 p = hash_get (reg_by_index, p[0]);
630 predecessor = (_vlib_init_function_list_elt_t *) p[0];
631 vlib_cli_output (vm, " after '%s' [%lld]",
632 predecessor->name, predecessor_index);
635 init_order = this_reg->init_order;
636 while (init_order && init_order[0])
638 _vlib_init_function_list_elt_t *inorder;
640 p = hash_get_mem (index_by_name, init_order[0]);
643 clib_warning ("couldn't find order element'%s'",
648 inorder_index = p[0];
649 p = hash_get (reg_by_index, p[0]);
651 inorder = (_vlib_init_function_list_elt_t *) p[0];
652 vlib_cli_output (vm, " in order '%s' [%lld]",
653 inorder->name, inorder_index);
658 hash_foreach_pair (hp, index_by_name,
660 vec_add1 (keys_to_delete, (u8 *)hp->key);
662 hash_free (index_by_name);
663 for (i = 0; i < vec_len (keys_to_delete); i++)
664 vec_free (keys_to_delete[i]);
665 vec_free (keys_to_delete);
666 hash_free (reg_by_index);
672 * Show init function order
675 * @cliexstart{show init-function [init | enter | exit] [verbose [nn]]}
678 VLIB_CLI_COMMAND (show_init_function, static) = {
679 .path = "show init-function",
680 .short_help = "show init-function [init | enter | exit][verbose [nn]]",
681 .function = show_init_function_command_fn,
686 * fd.io coding-style-patch-verification: ON
689 * eval: (c-set-style "gnu")