Line data    Source code

       1             : /*
       2             :  *------------------------------------------------------------------
       3             :  * Copyright (c) 2009 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 included_vlibmemory_api_common_h
      19             : #define included_vlibmemory_api_common_h
      20             : 
      21             : #include <svm/svm_common.h>
      22             : #include <vlibapi/api.h>
      23             : #include <vlibmemory/memory_api.h>
      24             : #include <vlibmemory/memory_client.h>
      25             : #include <vlibmemory/socket_api.h>
      26             : #include <vlibmemory/socket_client.h>
      27             : 
      28             : void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
      29             : void vl_api_force_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
      30             : u16 vl_client_get_first_plugin_msg_id (const char *plugin_name);
      31             : void vl_api_send_pending_rpc_requests (vlib_main_t * vm);
      32             : u8 *vl_api_serialize_message_table (api_main_t * am, u8 * vector);
      33             : 
      34             : always_inline void
      35      700360 : vl_api_send_msg (vl_api_registration_t * rp, u8 * elem)
      36             : {
      37      700360 :   if (PREDICT_FALSE (rp->registration_type > REGISTRATION_TYPE_SHMEM))
      38             :     {
      39      699056 :       vl_socket_api_send (rp, elem);
      40             :     }
      41             :   else
      42             :     {
      43        1304 :       vl_msg_api_send_shmem (rp->vl_input_queue, (u8 *) & elem);
      44             :     }
      45      700360 : }
      46             : 
      47             : always_inline int
      48          95 : vl_api_can_send_msg (vl_api_registration_t * rp)
      49             : {
      50          95 :   if (PREDICT_FALSE (rp->registration_type > REGISTRATION_TYPE_SHMEM))
      51          95 :     return 1;
      52             :   else
      53           0 :     return vl_mem_api_can_send (rp->vl_input_queue);
      54             : }
      55             : 
      56             : /*
      57             :  * Suggests to an API handler to relinguish control. Currently limits
      58             :  * an handler to a maximum of 1ms or it earlier if the client queue is
      59             :  * full.
      60             :  *
      61             :  * May be enhanced in the future based on other performance
      62             :  * characteristics of the main thread.
      63             :  */
      64             : #define VL_API_MAX_TIME_IN_HANDLER 0.001        /* 1 ms */
      65             : always_inline int
      66        4983 : vl_api_process_may_suspend (vlib_main_t * vm, vl_api_registration_t * rp,
      67             :                             f64 start)
      68             : {
      69             :   /* Is client queue full (leave space for reply message) */
      70        4983 :   if (rp->registration_type <= REGISTRATION_TYPE_SHMEM &&
      71          12 :       rp->vl_input_queue->cursize + 1 >= rp->vl_input_queue->maxsize)
      72           0 :     return true;
      73        4983 :   if (vlib_time_now (vm) > start + VL_API_MAX_TIME_IN_HANDLER)
      74          19 :     return true;
      75        4964 :   return false;
      76             : }
      77             : 
      78             : always_inline vl_api_registration_t *
      79      442599 : vl_api_client_index_to_registration (u32 index)
      80             : {
      81      442599 :   if (vl_socket_api_registration_handle_is_valid (ntohl (index)))
      82      441861 :     return vl_socket_api_client_handle_to_registration (ntohl (index));
      83         738 :   return vl_mem_api_client_index_to_registration (index);
      84             : }
      85             : 
      86             : always_inline u32
      87      700597 : vl_api_registration_file_index (vl_api_registration_t * reg)
      88             : {
      89      700597 :   return reg->clib_file_index;
      90             : }
      91             : 
      92             : always_inline clib_file_t *
      93      700365 : vl_api_registration_file (vl_api_registration_t * reg)
      94             : {
      95      700365 :   return clib_file_get (&file_main, vl_api_registration_file_index (reg));
      96             : }
      97             : 
      98             : always_inline void
      99        1150 : vl_api_registration_del_file (vl_api_registration_t * reg)
     100             : {
     101        1150 :   clib_file_t *cf = vl_api_registration_file (reg);
     102        1150 :   if (cf)
     103        1150 :     clib_file_del (&file_main, cf);
     104        1150 : }
     105             : 
     106             : always_inline clib_error_t *
     107          73 : vl_api_send_fd_msg (vl_api_registration_t * reg, int fds[], int n_fds)
     108             : {
     109          73 :   clib_file_t *cf = vl_api_registration_file (reg);
     110          73 :   if (cf)
     111          73 :     return vl_sock_api_send_fd_msg (cf->file_descriptor, fds, n_fds);
     112           0 :   return 0;
     113             : }
     114             : 
     115             : always_inline clib_error_t *
     116             : vl_api_recv_fd_msg (vl_api_registration_t * reg, int fds[], int n_fds,
     117             :                     u32 wait)
     118             : {
     119             :   clib_file_t *cf = vl_api_registration_file (reg);
     120             :   if (cf)
     121             :     return vl_sock_api_recv_fd_msg (cf->file_descriptor, fds, n_fds, wait);
     122             :   return 0;
     123             : }
     124             : 
     125             : /*
     126             :  * vl_api_clnt process data used by transports (socket api in particular)
     127             :  */
     128             : extern vlib_node_registration_t vl_api_clnt_node;
     129             : extern volatile int **vl_api_queue_cursizes;
     130             : 
     131             : typedef enum vl_api_clnt_process_events
     132             : {
     133             :   QUEUE_SIGNAL_EVENT = 1,
     134             :   SOCKET_READ_EVENT
     135             : } vl_api_clnt_process_events_t;
     136             : 
     137             : #define foreach_histogram_bucket                \
     138             : _(400)                                          \
     139             : _(200)                                          \
     140             : _(100)                                          \
     141             : _(10)
     142             : 
     143             : typedef enum
     144             : {
     145             : #define _(n) SLEEP_##n##_US,
     146             :   foreach_histogram_bucket
     147             : #undef _
     148             :     SLEEP_N_BUCKETS,
     149             : } histogram_index_t;
     150             : 
     151             : extern u64 vector_rate_histogram[];
     152             : 
     153             : /*
     154             :  * sockclnt APIs XXX are these actually used anywhere?
     155             :  */
     156             : vl_api_registration_t *sockclnt_get_registration (u32 index);
     157             : void socksvr_add_pending_output (struct clib_file *uf,
     158             :                                  struct vl_api_registration_ *cf,
     159             :                                  u8 * buffer, uword buffer_bytes);
     160             : void vl_socket_process_msg (struct clib_file *uf,
     161             :                             struct vl_api_registration_ *rp, i8 * input_v);
     162             : u32 sockclnt_open_index (char *client_name, char *hostname, int port);
     163             : void sockclnt_close_index (u32 index);
     164             : void vl_client_msg_api_send (vl_api_registration_t * cm, u8 * elem);
     165             : 
     166             : #endif /* included_vlibmemory_api_common_h */
     167             : 
     168             : /*
     169             :  * fd.io coding-style-patch-verification: ON
     170             :  *
     171             :  * Local Variables:
     172             :  * eval: (c-set-style "gnu")
     173             :  * End:
     174             :  */