src/vlib/init.c

   1 /*
   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:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  14  */
  15 /*
  16  * init.c: mechanism for functions to be called at init/exit.
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  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:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  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.
  38  */
  39
  40 #include <vlib/vlib.h>
  41
  42 clib_error_t *
  43 vlib_call_init_exit_functions (vlib_main_t * vm,
  44                                _vlib_init_function_list_elt_t * head,
  45                                int call_once)
  46 {
  47   clib_error_t *error = 0;
  48   _vlib_init_function_list_elt_t *i;
  49
  50   i = head;
  51   while (i)
  52     {
  53       if (call_once && !hash_get (vm->init_functions_called, i->f))
  54         {
  55           if (call_once)
  56             hash_set1 (vm->init_functions_called, i->f);
  57           error = i->f (vm);
  58           if (error)
  59             return error;
  60         }
  61       i = i->next_init_function;
  62     }
  63   return error;
  64 }
  65
  66 clib_error_t *
  67 vlib_call_all_init_functions (vlib_main_t * vm)
  68 {
  69   /* Call dummy functions to make sure purely static modules are
  70      linked in. */
  71 #define _(f) vlib_##f##_reference ();
  72   foreach_vlib_module_reference;
  73 #undef _
  74
  75   return vlib_call_init_exit_functions
  76     (vm, vm->init_function_registrations, 1 /* call_once */ );
  77 }
  78
  79 clib_error_t *
  80 vlib_call_all_main_loop_enter_functions (vlib_main_t * vm)
  81 {
  82   return vlib_call_init_exit_functions
  83     (vm, vm->main_loop_enter_function_registrations, 1 /* call_once */ );
  84 }
  85
  86 clib_error_t *
  87 vlib_call_all_main_loop_exit_functions (vlib_main_t * vm)
  88 {
  89   return vlib_call_init_exit_functions
  90     (vm, vm->main_loop_exit_function_registrations, 1 /* call_once */ );
  91 }
  92
  93 clib_error_t *
  94 vlib_call_all_config_functions (vlib_main_t * vm,
  95                                 unformat_input_t * input, int is_early)
  96 {
  97   clib_error_t *error = 0;
  98   vlib_config_function_runtime_t *c, **all;
  99   uword *hash = 0, *p;
 100   uword i;
 101
 102   hash = hash_create_string (0, sizeof (uword));
 103   all = 0;
 104
 105   c = vm->config_function_registrations;
 106
 107   while (c)
 108     {
 109       hash_set_mem (hash, c->name, vec_len (all));
 110       vec_add1 (all, c);
 111       unformat_init (&c->input, 0, 0);
 112       c = c->next_registration;
 113     }
 114
 115   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 116     {
 117       u8 *s, *v;
 118
 119       if (!unformat (input, "%s %v", &s, &v) || !(p = hash_get_mem (hash, s)))
 120         {
 121           error = clib_error_create ("unknown input `%s %v'", s, v);
 122           goto done;
 123         }
 124
 125       c = all[p[0]];
 126       if (vec_len (c->input.buffer) > 0)
 127         vec_add1 (c->input.buffer, ' ');
 128       vec_add (c->input.buffer, v, vec_len (v));
 129       vec_free (v);
 130       vec_free (s);
 131     }
 132
 133   for (i = 0; i < vec_len (all); i++)
 134     {
 135       c = all[i];
 136
 137       /* Is this an early config? Are we doing early configs? */
 138       if (is_early ^ c->is_early)
 139         continue;
 140
 141       /* Already called? */
 142       if (hash_get (vm->init_functions_called, c->function))
 143         continue;
 144       hash_set1 (vm->init_functions_called, c->function);
 145
 146       error = c->function (vm, &c->input);
 147       if (error)
 148         goto done;
 149     }
 150
 151 done:
 152   for (i = 0; i < vec_len (all); i++)
 153     {
 154       c = all[i];
 155       unformat_free (&c->input);
 156     }
 157   vec_free (all);
 158   hash_free (hash);
 159   return error;
 160 }
 161
 162 /*
 163  * fd.io coding-style-patch-verification: ON
 164  *
 165  * Local Variables:
 166  * eval: (c-set-style "gnu")
 167  * End:
 168  */