FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
memory_shared.h
Go to the documentation of this file.
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_SHARED_H_
19 #define SRC_VLIBMEMORY_MEMORY_SHARED_H_
20 
21 #include <vlibapi/api_common.h>
22 #include <vppinfra/error.h>
23 
24 /* Allocated in shared memory */
25 
26 /*
27  * Ring-allocation scheme for client API messages
28  *
29  * Only one proc/thread has control of a given message buffer.
30  * To free a buffer allocated from one of these rings, we clear
31  * a field in the buffer (header), and leave.
32  *
33  * No locks, no hits, no errors...
34  */
35 typedef struct ring_alloc_
36 {
42 } ring_alloc_t;
43 
44 typedef enum
45 {
50 
52 {
54  u8 _pad;
58 
60  "Size must be exactly 8 bytes");
61 
62 /*
63  * Initializers for the (shared-memory) rings
64  * _(size, n). Note: each msg has space for a header.
65  */
66 #define foreach_vl_aring_size \
67 _(64+sizeof(ring_alloc_t), 1024) \
68 _(256+sizeof(ring_alloc_t), 128) \
69 _(1024+sizeof(ring_alloc_t), 64)
70 
71 #define foreach_clnt_aring_size \
72  _(1024+sizeof(ring_alloc_t), 1024) \
73  _(2048+sizeof(ring_alloc_t), 128) \
74  _(4096+sizeof(ring_alloc_t), 8)
75 
76 typedef struct vl_shmem_hdr_
77 {
78  int version;
79 
80  /* getpid () for the VLIB client process */
81  volatile int vl_pid;
82 
83  /* Client sends VLIB msgs here. */
85 
86  /* Vector of rings; one for each size. */
87 
88  /* VLIB allocates buffers to send msgs to clients here. */
90 
91  /* Clients allocate buffer to send msgs to VLIB here. */
93 
94  /* Number of detected application restarts */
96 
97  /* Number of messages reclaimed during application restart */
99 
100  /* Number of garbage-collected messages */
102 
103  /* Socket file index used to bootstrap shmem region */
106 
107 #define VL_SHM_VERSION 2
108 #define VL_API_EPOCH_MASK 0xFF
109 #define VL_API_EPOCH_SHIFT 8
110 
111 void *vl_msg_api_alloc (int nbytes);
112 void *vl_msg_api_alloc_zero (int nbytes);
113 void *vl_msg_api_alloc_or_null (int nbytes);
114 void *vl_msg_api_alloc_as_if_client (int nbytes);
115 void *vl_msg_api_alloc_zero_as_if_client (int nbytes);
116 void *vl_msg_api_alloc_as_if_client_or_null (int nbytes);
118  int nbytes);
119 void vl_msg_api_free (void *a);
120 void vl_msg_api_free_w_region (svm_region_t * vlib_rp, void *a);
121 int vl_map_shmem (const char *region_name, int is_vlib);
122 void vl_unmap_shmem (void);
123 void vl_unmap_shmem_client (void);
125 void vl_msg_api_send_shmem (svm_queue_t * q, u8 * elem);
127 void vl_set_memory_region_name (const char *name);
128 void vl_set_memory_root_path (const char *root_path);
129 void vl_set_memory_uid (int uid);
130 void vl_set_memory_gid (int gid);
131 void vl_set_global_memory_baseva (u64 baseva);
136 void vl_init_shmem (svm_region_t * vlib_rp, vl_api_shm_elem_config_t * config,
137  int is_vlib, int is_private_region);
138 
139 #endif /* SRC_VLIBMEMORY_MEMORY_SHARED_H_ */
140 
141 /*
142  * fd.io coding-style-patch-verification: ON
143  *
144  * Local Variables:
145  * eval: (c-set-style "gnu")
146  * End:
147  */
void * vl_msg_api_alloc(int nbytes)
void vl_init_shmem(svm_region_t *vlib_rp, vl_api_shm_elem_config_t *config, int is_vlib, int is_private_region)
void vl_unmap_shmem_client(void)
a
Definition: bitmap.h:538
void vl_unmap_shmem(void)
u32 application_restarts
Definition: memory_shared.h:95
unsigned long u64
Definition: types.h:89
vl_api_shm_config_type_t
Definition: memory_shared.h:44
void * vl_msg_api_alloc_zero(int nbytes)
ring_alloc_t * client_rings
Definition: memory_shared.h:92
STATIC_ASSERT(sizeof(vl_api_shm_elem_config_t)==8, "Size must be exactly 8 bytes")
unsigned char u8
Definition: types.h:56
unsigned int u32
Definition: types.h:88
void vl_set_memory_gid(int gid)
svm_queue_t * rp
Definition: memory_shared.h:37
struct ring_alloc_ ring_alloc_t
volatile int vl_pid
Definition: memory_shared.h:81
void * vl_msg_api_alloc_zero_as_if_client(int nbytes)
unsigned short u16
Definition: types.h:57
void * vl_msg_api_alloc_as_if_client(int nbytes)
void vl_msg_api_send_shmem(svm_queue_t *q, u8 *elem)
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
ring_alloc_t * vl_rings
Definition: memory_shared.h:89
void vl_msg_api_free(void *a)
struct vl_api_shm_elem_config_ vl_api_shm_elem_config_t
svm_queue_t * vl_input_queue
Definition: memory_shared.h:84
string name[64]
Definition: ip.api:44
void vl_set_api_pvt_heap_size(u64 size)
struct vl_shmem_hdr_ vl_shmem_hdr_t
void * vl_msg_api_alloc_or_null(int nbytes)
void vl_set_memory_uid(int uid)
void vl_msg_api_free_w_region(svm_region_t *vlib_rp, void *a)
void vl_set_api_memory_size(u64 size)
void vl_register_mapped_shmem_region(svm_region_t *rp)
void vl_set_global_memory_baseva(u64 baseva)
void vl_set_global_memory_size(u64 size)
struct _svm_queue svm_queue_t
API common definitions See api_doc.md for more info.
void * vl_msg_api_alloc_as_if_client_or_null(int nbytes)
void vl_set_global_pvt_heap_size(u64 size)
void vl_set_memory_root_path(const char *root_path)
int vl_map_shmem(const char *region_name, int is_vlib)
void vl_set_memory_region_name(const char *name)
Definition: memory_api.c:982
int vl_mem_api_can_send(svm_queue_t *q)
void * vl_mem_api_alloc_as_if_client_w_reg(vl_api_registration_t *reg, int nbytes)