src/plugins/lacp/node.h

   1 /*
   2  * Copyright (c) 2017 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 #ifndef __included_lacp_node_h__
  16 #define __included_lacp_node_h__
  17
  18 #include <vlib/vlib.h>
  19 #include <vlib/unix/unix.h>
  20 #include <vppinfra/format.h>
  21 #include <vppinfra/hash.h>
  22 #include <lacp/protocol.h>
  23 #include <lacp/rx_machine.h>
  24 #include <lacp/tx_machine.h>
  25 #include <lacp/mux_machine.h>
  26 #include <lacp/ptx_machine.h>
  27
  28 typedef enum
  29 {
  30   LACP_PACKET_TEMPLATE_ETHERNET,
  31   LACP_N_PACKET_TEMPLATES,
  32 } lacp_packet_template_id_t;
  33
  34 typedef enum
  35 {
  36   MARKER_PACKET_TEMPLATE_ETHERNET,
  37   MARKER_N_PACKET_TEMPLATES,
  38 } marker_packet_template_id_t;
  39
  40 enum
  41 {
  42   LACP_PROCESS_EVENT_START = 1,
  43   LACP_PROCESS_EVENT_STOP = 2,
  44 } lacp_process_event_t;
  45
  46 #define LACP_DBG(n, args...)                    \
  47   {                                             \
  48     lacp_main_t *_lm = &lacp_main;              \
  49     if (_lm->debug || n->debug)                 \
  50       clib_warning (args);                      \
  51   }
  52
  53 #define LACP_DBG2(n, e, s, m, t)                  \
  54   {                                               \
  55     lacp_main_t *_lm = &lacp_main;                \
  56     if ((m)->debug && (_lm->debug || (n)->debug)) \
  57       (*m->debug)(n, e, s, t);                    \
  58   }
  59
  60 /* Packet counters */
  61 #define foreach_lacp_error                                               \
  62 _ (NONE, "good lacp packets -- consumed")                                \
  63 _ (CACHE_HIT, "good lacp packets -- cache hit")                          \
  64 _ (UNSUPPORTED, "unsupported slow protocol packets")                     \
  65 _ (TOO_SMALL, "bad lacp packets -- packet too small")                    \
  66 _ (BAD_TLV, "bad lacp packets -- bad TLV length")                        \
  67 _ (DISABLED, "lacp packets received on disabled interfaces")
  68
  69 typedef enum
  70 {
  71 #define _(sym,str) LACP_ERROR_##sym,
  72   foreach_lacp_error
  73 #undef _
  74     LACP_N_ERROR,
  75 } lacp_error_t;
  76
  77 /* lacp packet trace capture */
  78 typedef struct
  79 {
  80   u32 len;
  81   union
  82   {
  83     marker_pdu_t marker;
  84     lacp_pdu_t lacpdu;
  85   } pkt;
  86 } lacp_input_trace_t;
  87
  88 /** LACP interface details struct */
  89 typedef struct
  90 {
  91   u32 sw_if_index;
  92   u8 interface_name[64];
  93   u32 rx_state;
  94   u32 tx_state;
  95   u32 mux_state;
  96   u32 ptx_state;
  97   u8 bond_interface_name[64];
  98   u16 actor_system_priority;
  99   u8 actor_system[6];
 100   u16 actor_key;
 101   u16 actor_port_priority;
 102   u16 actor_port_number;
 103   u8 actor_state;
 104   u16 partner_system_priority;
 105   u8 partner_system[6];
 106   u16 partner_key;
 107   u16 partner_port_priority;
 108   u16 partner_port_number;
 109   u8 partner_state;
 110 } lacp_interface_details_t;
 111
 112 typedef struct
 113 {
 114   /** API message ID base */
 115   u16 msg_id_base;
 116
 117   /* convenience variables */
 118   vlib_main_t *vlib_main;
 119   vnet_main_t *vnet_main;
 120
 121   /* Background process node index */
 122   u32 lacp_process_node_index;
 123
 124   /* Packet templates for different encap types */
 125   vlib_packet_template_t packet_templates[LACP_N_PACKET_TEMPLATES];
 126
 127   /* Packet templates for different encap types */
 128   vlib_packet_template_t marker_packet_templates[MARKER_N_PACKET_TEMPLATES];
 129
 130   /* LACP interface count */
 131   u32 lacp_int;
 132
 133   /* debug is on or off */
 134   u8 debug;
 135 } lacp_main_t;
 136
 137 extern lacp_state_struct lacp_state_array[];
 138 extern lacp_main_t lacp_main;
 139
 140 clib_error_t *lacp_plugin_api_hookup (vlib_main_t * vm);
 141 int lacp_dump_ifs (lacp_interface_details_t ** out_bondids);
 142 lacp_error_t lacp_input (vlib_main_t * vm, vlib_buffer_t * b0, u32 bi0);
 143 void lacp_periodic (vlib_main_t * vm);
 144 u8 *lacp_input_format_trace (u8 * s, va_list * args);
 145 void lacp_init_neighbor (slave_if_t * sif, u8 * hw_address,
 146                          u16 port_number, u32 group);
 147 void lacp_init_state_machines (vlib_main_t * vm, slave_if_t * sif);
 148 void lacp_init_rx_machine (vlib_main_t * vm, slave_if_t * sif);
 149 void lacp_init_tx_machine (vlib_main_t * vm, slave_if_t * sif);
 150 void lacp_init_ptx_machine (vlib_main_t * vm, slave_if_t * sif);
 151 void lacp_init_mux_machine (vlib_main_t * vm, slave_if_t * sif);
 152 void lacp_selection_logic (vlib_main_t * vm, slave_if_t * sif);
 153 void lacp_send_lacp_pdu (vlib_main_t * vm, slave_if_t * sif);
 154
 155 static inline void
 156 lacp_stop_timer (f64 * timer)
 157 {
 158   *timer = 0.0;
 159 }
 160
 161 static inline u8
 162 lacp_timer_is_running (f64 timer)
 163 {
 164   return (timer != 0.0);
 165 }
 166
 167 static inline u8
 168 lacp_timer_is_expired (vlib_main_t * vm, f64 timer)
 169 {
 170   f64 now = vlib_time_now (vm);
 171
 172   return (now >= timer);
 173 }
 174
 175 static inline u8 *
 176 format_rx_sm_state (u8 * s, va_list * args)
 177 {
 178   lacp_state_struct lacp_rx_sm_state_array[] = {
 179 #define _(b, s, n) {.bit = b, .str = #s, },
 180     foreach_lacp_rx_sm_state
 181 #undef _
 182     {.str = NULL}
 183   };
 184   int state = va_arg (*args, int);
 185   lacp_state_struct *state_entry =
 186     (lacp_state_struct *) & lacp_rx_sm_state_array;
 187
 188   if (state >= (sizeof (lacp_rx_sm_state_array) / sizeof (*state_entry)))
 189     s = format (s, "Bad state %d", state);
 190   else
 191     s = format (s, "%s", state_entry[state].str);
 192
 193   return s;
 194 }
 195
 196 static inline u8 *
 197 format_tx_sm_state (u8 * s, va_list * args)
 198 {
 199   lacp_state_struct lacp_tx_sm_state_array[] = {
 200 #define _(b, s, n) {.bit = b, .str = #s, },
 201     foreach_lacp_tx_sm_state
 202 #undef _
 203     {.str = NULL}
 204   };
 205   int state = va_arg (*args, int);
 206   lacp_state_struct *state_entry =
 207     (lacp_state_struct *) & lacp_tx_sm_state_array;
 208
 209   if (state >= (sizeof (lacp_tx_sm_state_array) / sizeof (*state_entry)))
 210     s = format (s, "Bad state %d", state);
 211   else
 212     s = format (s, "%s", state_entry[state].str);
 213
 214   return s;
 215 }
 216
 217 static inline u8 *
 218 format_mux_sm_state (u8 * s, va_list * args)
 219 {
 220   lacp_state_struct lacp_mux_sm_state_array[] = {
 221 #define _(b, s, n) {.bit = b, .str = #s, },
 222     foreach_lacp_mux_sm_state
 223 #undef _
 224     {.str = NULL}
 225   };
 226   int state = va_arg (*args, int);
 227   lacp_state_struct *state_entry =
 228     (lacp_state_struct *) & lacp_mux_sm_state_array;
 229
 230   if (state >= (sizeof (lacp_mux_sm_state_array) / sizeof (*state_entry)))
 231     s = format (s, "Bad state %d", state);
 232   else
 233     s = format (s, "%s", state_entry[state].str);
 234
 235   return s;
 236 }
 237
 238 static inline u8 *
 239 format_ptx_sm_state (u8 * s, va_list * args)
 240 {
 241   lacp_state_struct lacp_ptx_sm_state_array[] = {
 242 #define _(b, s, n) {.bit = b, .str = #s, },
 243     foreach_lacp_ptx_sm_state
 244 #undef _
 245     {.str = NULL}
 246   };
 247   int state = va_arg (*args, int);
 248   lacp_state_struct *state_entry =
 249     (lacp_state_struct *) & lacp_ptx_sm_state_array;
 250
 251   if (state >= (sizeof (lacp_ptx_sm_state_array) / sizeof (*state_entry)))
 252     s = format (s, "Bad state %d", state);
 253   else
 254     s = format (s, "%s", state_entry[state].str);
 255
 256   return s;
 257 }
 258
 259 static inline int
 260 lacp_bit_test (u8 val, u8 bit)
 261 {
 262   if (val & (1 << bit))
 263     return 1;
 264   else
 265     return 0;
 266 }
 267
 268 #endif /* __included_lacp_node_h__ */
 269
 270 /*
 271  * fd.io coding-style-patch-verification: ON
 272  *
 273  * Local Variables:
 274  * eval: (c-set-style "gnu")
 275  * End:
 276  */