X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fadj%2Fadj_delegate.h;h=d49c6661c192a1d8d347b5982982ad92b44e3d32;hb=282872127bbeee6ae59ab3f885c09bad601ee0cc;hp=9f7d8c64afca8bb5f514b8352373ed4208619899;hpb=793c7fe5fcb224c8bf8f9a051be82eef5fd62ca1;p=vpp.git

diff --git a/src/vnet/adj/adj_delegate.h b/src/vnet/adj/adj_delegate.h
index 9f7d8c64afc..d49c6661c19 100644
--- a/src/vnet/adj/adj_delegate.h
+++ b/src/vnet/adj/adj_delegate.h
@@ -12,6 +12,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * A Delagate is a means to implement the Delagation design pattern;
+ * the extension of an object's functionality through the composition of,
+ * and delgation to, other objects.
+ * These 'other' objects are delegates. Delagates are thus attached to
+ * ADJ objects to extend their functionality.
+ */
 
 #ifndef __ADJ_DELEGATE_T__
 #define __ADJ_DELEGATE_T__
@@ -19,44 +26,26 @@
 #include <vnet/adj/adj.h>
 
 /**
- * Delegate types
+ * Built-in delegate types.
+ * When adding new types, if your code is within the vnet subsystem, then add a
+ * new  type here. If not then use the adj_delegate_register_new_type API to
+ * register a new type.
  */
 typedef enum adj_delegate_type_t_ {
     /**
      * BFD session state
      */
     ADJ_DELEGATE_BFD,
+    /**
+     * Stacking of a midchain's nexthop
+     */
+    ADJ_DELEGATE_MIDCHAIN,
 } adj_delegate_type_t;
 
-#define FOR_EACH_ADJ_DELEGATE(_adj, _adt, _aed, _body)        \
-{                                                             \
-    for (_adt = ADJ_DELEGATE_BFD;                             \
-         _adt <= ADJ_DELEGATE_BFD;                            \
-         _adt++)                                              \
-    {                                                         \
-        _aed = adj_delegate_get(_adj, _adt);                  \
-        if (NULL != _aed) {                                   \
-            _body;                                            \
-        }                                                     \
-    }                                                         \
-}
-
-/**
- * Distillation of the BFD session states into a go/no-go for using
- * the associated tracked adjacency
- */
-typedef enum adj_bfd_state_t_
-{
-    ADJ_BFD_STATE_DOWN,
-    ADJ_BFD_STATE_UP,
-} adj_bfd_state_t;
+#define ADJ_DELEGATE_LAST (ADJ_DELEGATE_MIDCHAIN)
 
 /**
- * A Delagate is a means to implement the Delagation design pattern;
- * the extension of an object's functionality through the composition of,
- * and delgation to, other objects.
- * These 'other' objects are delegates. Delagates are thus attached to
- * ADJ objects to extend their functionality.
+ * Adj delegate. This object is attached to the adjacency.
  */
 typedef struct adj_delegate_t_
 {
@@ -71,45 +60,76 @@ typedef struct adj_delegate_t_
     adj_delegate_type_t ad_type;
 
     /**
-     * A union of data for the different delegate types
+     * The index passed by the provider to identify its delegate instance.
+     * As with all things VPP this is a pool index.
      */
-    union
-    {
-        /**
-         * BFD delegate daa
-         */
-        struct {
-            /**
-             * BFD session state
-             */
-            adj_bfd_state_t ad_bfd_state;
-            /**
-             * BFD session index
-             */
-            u32 ad_bfd_index;
-        };
-    };
+    index_t ad_index;
 } adj_delegate_t;
 
 /**
- * An ADJ delegate virtual function table
+ * Indication that the adjacency has been deleted. The delegate provider should free
+ * the delegate.
+ */
+typedef void (*adj_delegate_adj_deleted_t)(adj_delegate_t *aed);
+
+/**
+ * Format function for the delegate
  */
-typedef void (*adj_delegate_last_lock_gone_t)(ip_adjacency_t *adj, adj_delegate_t *aed);
 typedef u8 * (*adj_delegate_format_t)(const adj_delegate_t *aed, u8 *s);
+
+/**
+ * Notification that an adjacency has been created
+ */
+typedef void (*adj_delegate_adj_created_t)(adj_index_t ai);
+
+/**
+ * An ADJ delegate virtual function table
+ */
 typedef struct adj_delegate_vft_t_ {
-  adj_delegate_format_t adv_format;
-  adj_delegate_last_lock_gone_t adv_last_lock;
+    adj_delegate_format_t adv_format;
+    adj_delegate_adj_deleted_t adv_adj_deleted;
+    adj_delegate_adj_created_t adv_adj_created;
 } adj_delegate_vft_t;
 
-extern void adj_delegate_remove(ip_adjacency_t *adj,
+/**
+ * @brief Remove a delegate from an adjacency
+ *
+ * @param ai The adjacency to remove the delegate from
+ * @param type The type of delegate being removed
+ */
+extern void adj_delegate_remove(adj_index_t ai,
                                 adj_delegate_type_t type);
 
-extern adj_delegate_t *adj_delegate_find_or_add(ip_adjacency_t *adj,
-                                                adj_delegate_type_t fdt);
+/**
+ * @brief Add a delegate to an adjacency
+ *
+ * @param ai The adjacency to add the delegate to
+ * @param type The type of delegate being added
+ * @param adi The provider's [pool] index of its attached objet
+ */
+extern int adj_delegate_add(ip_adjacency_t *adj,
+                            adj_delegate_type_t fdt,
+                            index_t adi);
+
+/**
+ * @brief Get a delegate from an adjacency
+ *
+ * @param ai The adjacency to get the delegate from
+ * @param type The type of delegate being sought
+ */
 extern adj_delegate_t *adj_delegate_get(const ip_adjacency_t *adj,
                                         adj_delegate_type_t type);
 
-extern u8 *format_adj_delegate(u8 * s, va_list * args);
-extern void adj_delegate_register_type(adj_delegate_type_t type, const adj_delegate_vft_t *vft);
+/**
+ * @brief Register a VFT for one of the built-in types
+ */
+extern void adj_delegate_register_type(adj_delegate_type_t type,
+                                       const adj_delegate_vft_t *vft);
+
+/**
+ * @brief create a new delegate type and register a new VFT
+ */
+extern adj_delegate_type_t adj_delegate_register_new_type(
+    const adj_delegate_vft_t *vft);
 
 #endif