vlib/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 * vlib_call_all_init_functions (vlib_main_t * vm)
  67 {
  68   /* Call dummy functions to make sure purely static modules are
  69      linked in. */
  70 #define _(f) vlib_##f##_reference ();
  71   foreach_vlib_module_reference;
  72 #undef _
  73
  74   return vlib_call_init_exit_functions
  75     (vm, vm->init_function_registrations, 1 /* call_once */);
  76 }
  77
  78 clib_error_t * vlib_call_all_main_loop_enter_functions (vlib_main_t * vm)
  79 {
  80   return vlib_call_init_exit_functions
  81     (vm, vm->main_loop_enter_function_registrations, 1 /* call_once */);
  82 }
  83
  84 clib_error_t * vlib_call_all_main_loop_exit_functions (vlib_main_t * vm)
  85 {
  86   return vlib_call_init_exit_functions
  87     (vm, vm->main_loop_exit_function_registrations, 1 /* call_once */);
  88 }
  89
  90 clib_error_t * vlib_call_all_config_functions (vlib_main_t * vm,
  91                                                unformat_input_t * input,
  92                                                int is_early)
  93 {
  94   clib_error_t * error = 0;
  95   vlib_config_function_runtime_t * c, ** all;
  96   uword * hash = 0, * p;
  97   uword i;
  98
  99   hash = hash_create_string (0, sizeof (uword));
 100   all = 0;
 101
 102   c = vm->config_function_registrations;
 103
 104   while (c)
 105     {
 106       hash_set_mem (hash, c->name, vec_len (all));
 107       vec_add1 (all, c);
 108       unformat_init (&c->input, 0, 0);
 109       c = c->next_registration;
 110     }
 111
 112   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 113     {
 114       u8 * s, * v;
 115
 116       if (! unformat (input, "%s %v", &s, &v)
 117           || ! (p = hash_get_mem (hash, s)))
 118         {
 119           error = clib_error_create ("unknown input `%s %v'", s, v);
 120           goto done;
 121         }
 122
 123       c = all[p[0]];
 124       if (vec_len (c->input.buffer) > 0)
 125         vec_add1 (c->input.buffer, ' ');
 126       vec_add (c->input.buffer, v, vec_len (v));
 127       vec_free (v);
 128       vec_free (s);
 129     }
 130
 131   for (i = 0; i < vec_len (all); i++)
 132     {
 133       c = all[i];
 134
 135       /* Is this an early config? Are we doing early configs? */
 136       if (is_early ^ c->is_early)
 137         continue;
 138
 139       /* Already called? */
 140       if (hash_get (vm->init_functions_called, c->function))
 141         continue;
 142       hash_set1 (vm->init_functions_called, c->function);
 143
 144       error = c->function (vm, &c->input);
 145       if (error)
 146         goto done;
 147     }
 148
 149  done:
 150   for (i = 0; i < vec_len (all); i++)
 151     {
 152       c = all[i];
 153       unformat_free (&c->input);
 154     }
 155   vec_free (all);
 156   hash_free (hash);
 157   return error;
 158 }