Line data    Source code

       1             : /*
       2             :  *------------------------------------------------------------------
       3             :  * Copyright (c) 2018 Cisco and/or its affiliates.
       4             :  * Licensed under the Apache License, Version 2.0 (the "License");
       5             :  * you may not use this file except in compliance with the License.
       6             :  * You may obtain a copy of the License at:
       7             :  *
       8             :  *     http://www.apache.org/licenses/LICENSE-2.0
       9             :  *
      10             :  * Unless required by applicable law or agreed to in writing, software
      11             :  * distributed under the License is distributed on an "AS IS" BASIS,
      12             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      13             :  * See the License for the specific language governing permissions and
      14             :  * limitations under the License.
      15             :  *------------------------------------------------------------------
      16             :  */
      17             : 
      18             : #ifndef SRC_VLIBMEMORY_MEMORY_API_H_
      19             : #define SRC_VLIBMEMORY_MEMORY_API_H_
      20             : 
      21             : #include <svm/svm.h>
      22             : #include <svm/ssvm.h>
      23             : #include <svm/queue.h>
      24             : #include <vlib/vlib.h>
      25             : #include <vlibapi/api.h>
      26             : #include <vlibapi/memory_shared.h>
      27             : 
      28             : svm_queue_t *vl_api_client_index_to_input_queue (u32 index);
      29             : int vl_mem_api_init (const char *region_name);
      30             : void vl_mem_api_dead_client_scan (api_main_t * am, vl_shmem_hdr_t * shm,
      31             :                                   f64 now);
      32             : int vl_mem_api_handle_msg_main (vlib_main_t * vm, vlib_node_runtime_t * node);
      33             : int vl_mem_api_handle_msg_private (vlib_main_t * vm,
      34             :                                    vlib_node_runtime_t * node, u32 reg_index);
      35             : int vl_mem_api_handle_rpc (vlib_main_t * vm, vlib_node_runtime_t * node);
      36             : 
      37             : vl_api_registration_t *vl_mem_api_client_index_to_registration (u32 handle);
      38             : void vl_mem_api_enable_disable (vlib_main_t * vm, int yesno);
      39             : u32 vl_api_memclnt_create_internal (char *, svm_queue_t *);
      40             : 
      41             : static inline u32
      42         806 : vl_msg_api_handle_get_epoch (u32 index)
      43             : {
      44         806 :   return (index & VL_API_EPOCH_MASK);
      45             : }
      46             : 
      47             : static inline u32
      48         807 : vl_msg_api_handle_get_index (u32 index)
      49             : {
      50         807 :   return (index >> VL_API_EPOCH_SHIFT);
      51             : }
      52             : 
      53             : static inline u32
      54          62 : vl_msg_api_handle_from_index_and_epoch (u32 index, u32 epoch)
      55             : {
      56             :   u32 handle;
      57          62 :   ASSERT (index < 0x00FFFFFF);
      58             : 
      59          62 :   handle = (index << VL_API_EPOCH_SHIFT) | (epoch & VL_API_EPOCH_MASK);
      60          62 :   return handle;
      61             : }
      62             : 
      63             : static inline u8
      64         759 : vl_msg_api_handle_is_valid (u32 handle, u32 restarts)
      65             : {
      66         759 :   u32 epoch = vl_msg_api_handle_get_epoch (handle);
      67         759 :   return ((restarts & VL_API_EPOCH_MASK) == epoch);
      68             : }
      69             : 
      70             : #define VL_MEM_API_LOG_Q_LEN(fmt, qlen)                                       \
      71             :   if (TRACE_VLIB_MEMORY_QUEUE)                                                \
      72             :     do                                                                        \
      73             :       {                                                                       \
      74             :         ELOG_TYPE_DECLARE (e) = {                                             \
      75             :           .format = fmt,                                                      \
      76             :           .format_args = "i4",                                                \
      77             :         };                                                                    \
      78             :         struct                                                                \
      79             :         {                                                                     \
      80             :           u32 len;                                                            \
      81             :         } * ed;                                                               \
      82             :         ed = ELOG_DATA (&vlib_global_main.elog_main, e);                      \
      83             :         ed->len = qlen;                                                       \
      84             :       }                                                                       \
      85             :   while (0)
      86             : 
      87             : #endif /* SRC_VLIBMEMORY_MEMORY_API_H_ */
      88             : 
      89             : /*
      90             :  * fd.io coding-style-patch-verification: ON
      91             :  *
      92             :  * Local Variables:
      93             :  * eval: (c-set-style "gnu")
      94             :  * End:
      95             :  */