Merge "Initial support for DPDK 18.05"
[samplevnf.git] / VNFs / DPPD-PROX / prox_shared.c
1 /*
2 // Copyright (c) 2010-2017 Intel Corporation
3 //
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 #include <stdio.h>
18 #include <rte_hash.h>
19 #include <rte_hash_crc.h>
20 #include <rte_version.h>
21
22 #include "quit.h"
23 #include "log.h"
24 #include "prox_shared.h"
25 #include "prox_globals.h"
26
27 #define INIT_HASH_TABLE_SIZE 8192
28
29 struct prox_shared {
30         struct rte_hash *hash;
31         size_t          size;
32 };
33
34 struct prox_shared sh_system;
35 struct prox_shared sh_socket[MAX_SOCKETS];
36 struct prox_shared sh_core[RTE_MAX_LCORE];
37
38 static char* get_sh_name(void)
39 {
40         static char name[] = "prox_sh";
41
42         name[0]++;
43         return name;
44 }
45
46 struct rte_hash_parameters param = {
47         .key_len = 256,
48         .hash_func = rte_hash_crc,
49         .hash_func_init_val = 0,
50         .socket_id = 0,
51 };
52
53 static void prox_sh_create_hash(struct prox_shared *ps, size_t size)
54 {
55         param.entries = size;
56         param.name = get_sh_name();
57         ps->hash = rte_hash_create(&param);
58         PROX_PANIC(ps->hash == NULL, "Failed to create hash table for shared data");
59         ps->size = size;
60         if (ps->size == INIT_HASH_TABLE_SIZE)
61                 plog_info("Shared data tracking hash table created with size %zu\n", ps->size);
62         else
63                 plog_info("Shared data tracking hash table grew to %zu\n", ps->size);
64 }
65
66 #if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
67 static int copy_hash(struct rte_hash *new_hash, struct rte_hash *old_hash)
68 {
69         const void *next_key;
70         void *next_data;
71         uint32_t iter = 0;
72
73         while (rte_hash_iterate(old_hash, &next_key, &next_data, &iter) >= 0) {
74                 if (rte_hash_add_key_data(new_hash, next_key, next_data) < 0)
75                         return -1;
76         }
77
78         return 0;
79 }
80 #endif
81
82 static int prox_sh_add(struct prox_shared *ps, const char *name, void *data)
83 {
84         char key[256] = {0};
85         int ret;
86
87         strncpy(key, name, sizeof(key));
88         if (ps->size == 0) {
89                 prox_sh_create_hash(ps, INIT_HASH_TABLE_SIZE);
90         }
91
92 #if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
93         do {
94                 ret = rte_hash_add_key_data(ps->hash, key, data);
95                 if (ret < 0) {
96                         struct rte_hash *old = ps->hash;
97                         int success;
98                         do {
99                                 prox_sh_create_hash(ps, ps->size * 2);
100                                 success = !copy_hash(ps->hash, old);
101                                 if (success)
102                                         rte_hash_free(old);
103                                 else
104                                         rte_hash_free(ps->hash);
105                         } while (!success);
106                 }
107         } while (ret < 0);
108 #else
109                 PROX_PANIC(1, "DPDK < 2.1 not fully supported");
110 #endif
111         return 0;
112 }
113
114 static void *prox_sh_find(struct prox_shared *sh, const char *name)
115 {
116 #if RTE_VERSION >= RTE_VERSION_NUM(2,1,0,0)
117         char key[256] = {0};
118         int ret;
119         void *data;
120
121         if (!sh->hash)
122                 return NULL;
123
124         strncpy(key, name, sizeof(key));
125         ret = rte_hash_lookup_data(sh->hash, key, &data);
126         if (ret >= 0)
127                 return data;
128 #else
129                 PROX_PANIC(1, "DPDK < 2.1 not fully supported");
130 #endif
131         return NULL;
132 }
133
134 int prox_sh_add_system(const char *name, void *data)
135 {
136         return prox_sh_add(&sh_system, name, data);
137 }
138
139 int prox_sh_add_socket(const int socket_id, const char *name, void *data)
140 {
141         if (socket_id >= MAX_SOCKETS)
142                 return -1;
143
144         return prox_sh_add(&sh_socket[socket_id], name, data);
145 }
146
147 int prox_sh_add_core(const int core_id, const char *name, void *data)
148 {
149         if (core_id >= RTE_MAX_LCORE)
150                 return -1;
151
152         return prox_sh_add(&sh_core[core_id], name, data);
153 }
154
155 void *prox_sh_find_system(const char *name)
156 {
157         return prox_sh_find(&sh_system, name);
158 }
159
160 void *prox_sh_find_socket(const int socket_id, const char *name)
161 {
162         if (socket_id >= MAX_SOCKETS)
163                 return NULL;
164
165         return prox_sh_find(&sh_socket[socket_id], name);
166 }
167
168 void *prox_sh_find_core(const int core_id, const char *name)
169 {
170         if (core_id >= RTE_MAX_LCORE)
171                 return NULL;
172
173         return prox_sh_find(&sh_core[core_id], name);
174 }