1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
*------------------------------------------------------------------
* Copyright (c) 2009 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*------------------------------------------------------------------
*/
#ifndef included_vlibmemory_api_common_h
#define included_vlibmemory_api_common_h
#include <svm/svm_common.h>
#include <vlibapi/api_common.h>
#include <vlibmemory/unix_shared_memory_queue.h>
/* Allocated in shared memory */
/*
* Ring-allocation scheme for client API messages
*
* Only one proc/thread has control of a given message buffer.
* To free a buffer allocated from one of these rings, we clear
* a field in the buffer (header), and leave.
*
* No locks, no hits, no errors...
*/
typedef struct ring_alloc_
{
unix_shared_memory_queue_t *rp;
u16 size;
u16 nitems;
u32 hits;
u32 misses;
} ring_alloc_t;
/*
* Initializers for the (shared-memory) rings
* _(size, n). Note: each msg has an 8 byte header.
* Might want to change that to an index sometime.
*/
#define foreach_vl_aring_size \
_(64+8, 1024) \
_(256+8, 128) \
_(1024+8, 64)
#define foreach_clnt_aring_size \
_(1024+8, 1024) \
_(2048+8, 128) \
_(4096+8, 8)
typedef struct vl_shmem_hdr_
{
int version;
/* getpid () for the VLIB client process */
volatile int vl_pid;
/* Client sends VLIB msgs here. */
unix_shared_memory_queue_t *vl_input_queue;
/* Vector of rings; one for each size. */
/* VLIB allocates buffers to send msgs to clients here. */
ring_alloc_t *vl_rings;
/* Clients allocate buffer to send msgs to VLIB here. */
ring_alloc_t *client_rings;
/* Number of detected application restarts */
u32 application_restarts;
/* Number of messages reclaimed during application restart */
u32 restart_reclaims;
/* Number of garbage-collected messages */
u32 garbage_collects;
} vl_shmem_hdr_t;
#define VL_SHM_VERSION 2
#define VL_API_EPOCH_MASK 0xFF
#define VL_API_EPOCH_SHIFT 8
void *vl_msg_api_alloc (int nbytes);
void *vl_msg_api_alloc_or_null (int nbytes);
void *vl_msg_api_alloc_as_if_client (int nbytes);
void *vl_msg_api_alloc_as_if_client_or_null (int nbytes);
void vl_msg_api_free (void *a);
int vl_map_shmem (const char *region_name, int is_vlib);
void vl_register_mapped_shmem_region (svm_region_t * rp);
void vl_unmap_shmem (void);
void vl_msg_api_send_shmem (unix_shared_memory_queue_t * q, u8 * elem);
void vl_msg_api_send_shmem_nolock (unix_shared_memory_queue_t * q, u8 * elem);
void vl_msg_api_send (vl_api_registration_t * rp, u8 * elem);
int vl_client_connect (const char *name, int ctx_quota, int input_queue_size);
void vl_client_disconnect (void);
unix_shared_memory_queue_t *vl_api_client_index_to_input_queue (u32 index);
vl_api_registration_t *vl_api_client_index_to_registration (u32 index);
int vl_client_api_map (const char *region_name);
void vl_client_api_unmap (void);
void vl_set_memory_region_name (const char *name);
void vl_set_memory_root_path (const char *root_path);
void vl_set_memory_uid (int uid);
void vl_set_memory_gid (int gid);
void vl_set_global_memory_baseva (u64 baseva);
void vl_set_global_memory_size (u64 size);
void vl_set_api_memory_size (u64 size);
void vl_set_global_pvt_heap_size (u64 size);
void vl_set_api_pvt_heap_size (u64 size);
void vl_client_disconnect_from_vlib (void);
int vl_client_connect_to_vlib (const char *svm_name, const char *client_name,
int rx_queue_size);
int vl_client_connect_to_vlib_no_rx_pthread (const char *svm_name,
const char *client_name,
int rx_queue_size);
u16 vl_client_get_first_plugin_msg_id (const char *plugin_name);
void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
u32 vl_api_memclnt_create_internal (char *, unix_shared_memory_queue_t *);
#endif /* included_vlibmemory_api_common_h */
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
|
