FD.io VPP  v18.11-rc0-18-g2a3fb1a
Vector Packet Processing
netmap.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2016 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 #include <stdint.h>
19 #include <net/if.h>
20 #include <sys/ioctl.h>
21 #include <sys/types.h>
22 #include <fcntl.h>
24 
25 #include <vlib/vlib.h>
26 #include <vlib/unix/unix.h>
27 #include <vnet/ethernet/ethernet.h>
29 
31 
32 static u32
34  u32 flags)
35 {
36  /* nothing for now */
37  return 0;
38 }
39 
40 static clib_error_t *
42 {
45  u32 idx = uf->private_data;
46 
49 
50  /* Schedule the rx node */
52 
53  return 0;
54 }
55 
56 static void
58 {
59  if (nif->clib_file_index != ~0)
60  {
62  nif->clib_file_index = ~0;
63  }
64  else if (nif->fd > -1)
65  close (nif->fd);
66 
67  if (nif->mem_region)
68  {
69  netmap_mem_region_t *reg = &nm->mem_regions[nif->mem_region];
70  if (--reg->refcnt == 0)
71  {
72  munmap (reg->mem, reg->region_size);
73  reg->region_size = 0;
74  }
75  }
76 
77 
79  &nif->if_index);
80  vec_free (nif->host_if_name);
81  vec_free (nif->req);
82 
83  memset (nif, 0, sizeof (*nif));
84  pool_put (nm->interfaces, nif);
85 }
86 
87 int
89 {
90  /* if worker threads are enabled, switch to polling mode */
92  {
93  vlib_node_set_state (this_vlib_main,
94  netmap_input_node.index,
95  VLIB_NODE_STATE_POLLING);
96  }));
97 
98  return 0;
99 }
100 
101 int
103 {
105  {
106  vlib_node_set_state (this_vlib_main,
107  netmap_input_node.index,
108  VLIB_NODE_STATE_INTERRUPT);
109  }));
110 
111  return 0;
112 }
113 
114 int
115 netmap_create_if (vlib_main_t * vm, u8 * if_name, u8 * hw_addr_set,
116  u8 is_pipe, u8 is_master, u32 * sw_if_index)
117 {
118  netmap_main_t *nm = &netmap_main;
119  int ret = 0;
120  netmap_if_t *nif = 0;
121  u8 hw_addr[6];
122  clib_error_t *error = 0;
124  vnet_main_t *vnm = vnet_get_main ();
125  uword *p;
126  struct nmreq *req = 0;
127  netmap_mem_region_t *reg;
129  int fd;
130 
131  p = mhash_get (&nm->if_index_by_host_if_name, if_name);
132  if (p)
133  return VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
134 
135  fd = open ("/dev/netmap", O_RDWR);
136  if (fd < 0)
137  return VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
138 
139  pool_get (nm->interfaces, nif);
140  nif->if_index = nif - nm->interfaces;
141  nif->fd = fd;
142  nif->clib_file_index = ~0;
143 
144  vec_validate (req, 0);
145  nif->req = req;
146  req->nr_version = NETMAP_API;
147  req->nr_flags = NR_REG_ALL_NIC;
148 
149  if (is_pipe)
150  req->nr_flags = is_master ? NR_REG_PIPE_MASTER : NR_REG_PIPE_SLAVE;
151  else
152  req->nr_flags = NR_REG_ALL_NIC;
153 
155  snprintf (req->nr_name, IFNAMSIZ, "%s", if_name);
156  req->nr_name[IFNAMSIZ - 1] = 0;
157 
158  if (ioctl (nif->fd, NIOCREGIF, req))
159  {
160  ret = VNET_API_ERROR_NOT_CONNECTED;
161  goto error;
162  }
163 
164  nif->mem_region = req->nr_arg2;
165  vec_validate (nm->mem_regions, nif->mem_region);
166  reg = &nm->mem_regions[nif->mem_region];
167  if (reg->region_size == 0)
168  {
169  reg->mem = mmap (NULL, req->nr_memsize, PROT_READ | PROT_WRITE,
170  MAP_SHARED, fd, 0);
171  clib_warning ("mem %p", reg->mem);
172  if (reg->mem == MAP_FAILED)
173  {
174  ret = VNET_API_ERROR_NOT_CONNECTED;
175  goto error;
176  }
177  reg->region_size = req->nr_memsize;
178  }
179  reg->refcnt++;
180 
181  nif->nifp = NETMAP_IF (reg->mem, req->nr_offset);
182  nif->first_rx_ring = 0;
183  nif->last_rx_ring = 0;
184  nif->first_tx_ring = 0;
185  nif->last_tx_ring = 0;
186  nif->host_if_name = if_name;
187  nif->per_interface_next_index = ~0;
188 
189  if (tm->n_vlib_mains > 1)
190  clib_spinlock_init (&nif->lockp);
191 
192  {
193  clib_file_t template = { 0 };
195  template.file_descriptor = nif->fd;
196  template.private_data = nif->if_index;
197  nif->clib_file_index = clib_file_add (&file_main, &template);
198  }
199 
200  /*use configured or generate random MAC address */
201  if (hw_addr_set)
202  memcpy (hw_addr, hw_addr_set, 6);
203  else
204  {
205  f64 now = vlib_time_now (vm);
206  u32 rnd;
207  rnd = (u32) (now * 1e6);
208  rnd = random_u32 (&rnd);
209 
210  memcpy (hw_addr + 2, &rnd, sizeof (rnd));
211  hw_addr[0] = 2;
212  hw_addr[1] = 0xfe;
213  }
214 
216  nif->if_index, hw_addr,
217  &nif->hw_if_index,
219 
220  if (error)
221  {
222  clib_error_report (error);
223  ret = VNET_API_ERROR_SYSCALL_ERROR_1;
224  goto error;
225  }
226 
227  sw = vnet_get_hw_sw_interface (vnm, nif->hw_if_index);
228  nif->sw_if_index = sw->sw_if_index;
229 
230  mhash_set_mem (&nm->if_index_by_host_if_name, if_name, &nif->if_index, 0);
231 
232  if (sw_if_index)
233  *sw_if_index = nif->sw_if_index;
234 
235  if (tm->n_vlib_mains > 1 && pool_elts (nm->interfaces) == 1)
237 
238  return 0;
239 
240 error:
241  close_netmap_if (nm, nif);
242  return ret;
243 }
244 
245 int
246 netmap_delete_if (vlib_main_t * vm, u8 * host_if_name)
247 {
248  vnet_main_t *vnm = vnet_get_main ();
249  netmap_main_t *nm = &netmap_main;
250  netmap_if_t *nif;
251  uword *p;
253 
254  p = mhash_get (&nm->if_index_by_host_if_name, host_if_name);
255  if (p == NULL)
256  {
257  clib_warning ("Host interface %s does not exist", host_if_name);
258  return VNET_API_ERROR_SYSCALL_ERROR_1;
259  }
260  nif = pool_elt_at_index (nm->interfaces, p[0]);
261 
262  /* bring down the interface */
264 
266 
267  close_netmap_if (nm, nif);
268 
269  if (tm->n_vlib_mains > 1 && pool_elts (nm->interfaces) == 0)
271 
272  return 0;
273 }
274 
275 static clib_error_t *
277 {
278  netmap_main_t *nm = &netmap_main;
281  uword *p;
282 
283  memset (nm, 0, sizeof (netmap_main_t));
284 
285  nm->input_cpu_first_index = 0;
286  nm->input_cpu_count = 1;
287 
288  /* find out which cpus will be used for input */
289  p = hash_get_mem (tm->thread_registrations_by_name, "workers");
290  tr = p ? (vlib_thread_registration_t *) p[0] : 0;
291 
292  if (tr && tr->count > 0)
293  {
295  nm->input_cpu_count = tr->count;
296  }
297 
299 
302 
303  return 0;
304 }
305 
307 
308 /*
309  * fd.io coding-style-patch-verification: ON
310  *
311  * Local Variables:
312  * eval: (c-set-style "gnu")
313  * End:
314  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:437
vmrglw vmrglh hi
static void clib_file_del(clib_file_main_t *um, clib_file_t *f)
Definition: file.h:109
uint32_t nr_offset
Definition: net_netmap.h:477
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:541
netmap_if_t * interfaces
Definition: netmap.h:80
void ethernet_delete_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface.c:321
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
int netmap_worker_thread_enable()
Definition: netmap.c:88
static void vlib_node_set_interrupt_pending(vlib_main_t *vm, u32 node_index)
Definition: node_funcs.h:196
#define NULL
Definition: clib.h:55
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:353
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:225
uint32_t nr_memsize
Definition: net_netmap.h:478
static void mhash_init_vec_string(mhash_t *h, uword n_value_bytes)
Definition: mhash.h:84
static uword * clib_bitmap_set(uword *ai, uword i, uword value)
Sets the ith bit of a bitmap to new_value Removes trailing zeros from the bitmap. ...
Definition: bitmap.h:167
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:448
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
unsigned char u8
Definition: types.h:56
clib_file_function_t * read_function
Definition: file.h:67
double f64
Definition: types.h:142
static vnet_sw_interface_t * vnet_get_hw_sw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 sw_if_index
Definition: netmap.h:52
clib_file_t * file_pool
Definition: file.h:88
#define NIOCREGIF
Definition: net_netmap.h:595
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
u32 per_interface_next_index
Definition: netmap.h:55
char nr_name[IFNAMSIZ]
Definition: net_netmap.h:475
clib_file_main_t file_main
Definition: main.c:63
u32 input_cpu_count
Definition: netmap.h:98
unsigned int u32
Definition: types.h:88
static clib_error_t * netmap_fd_read_ready(clib_file_t *uf)
Definition: netmap.c:41
struct netmap_if * nifp
Definition: netmap.h:62
#define NETMAP_API
Definition: net_netmap.h:42
static void clib_spinlock_init(clib_spinlock_t *p)
Definition: lock.h:57
struct nmreq * req
Definition: netmap.h:59
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
netmap_mem_region_t * mem_regions
Definition: netmap.h:92
uword mhash_set_mem(mhash_t *h, void *key, uword *new_value, uword *old_value)
Definition: mhash.c:271
u32 clib_file_index
Definition: netmap.h:53
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
uint32_t nr_version
Definition: net_netmap.h:476
static u32 netmap_eth_flag_change(vnet_main_t *vnm, vnet_hw_interface_t *hi, u32 flags)
Definition: netmap.c:33
#define foreach_vlib_main(body)
Definition: threads.h:244
u16 first_rx_ring
Definition: netmap.h:65
mhash_t if_index_by_host_if_name
Definition: netmap.h:89
u32 flags
Definition: vhost_user.h:110
vlib_main_t * vm
Definition: buffer.c:294
int fd
Definition: netmap.h:61
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
u16 first_tx_ring
Definition: netmap.h:63
#define NR_ACCEPT_VNET_HDR
Definition: net_netmap.h:543
#define clib_warning(format, args...)
Definition: error.h:59
u32 hw_if_index
Definition: netmap.h:51
int netmap_create_if(vlib_main_t *vm, u8 *if_name, u8 *hw_addr_set, u8 is_pipe, u8 is_master, u32 *sw_if_index)
Definition: netmap.c:115
u16 last_rx_ring
Definition: netmap.h:66
static void close_netmap_if(netmap_main_t *nm, netmap_if_t *nif)
Definition: netmap.c:57
u16 last_tx_ring
Definition: netmap.h:64
uword if_index
Definition: netmap.h:50
vlib_node_registration_t netmap_input_node
(constructor) VLIB_REGISTER_NODE (netmap_input_node)
Definition: node.c:280
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
u16 mem_region
Definition: netmap.h:60
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
Definition: file.h:96
clib_spinlock_t lockp
Definition: netmap.h:48
u8 * host_if_name
Definition: netmap.h:49
int netmap_worker_thread_disable()
Definition: netmap.c:102
clib_error_t * ethernet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u8 *address, u32 *hw_if_index_return, ethernet_flag_change_function_t flag_change)
Definition: interface.c:275
#define clib_error_report(e)
Definition: error.h:113
static void vlib_node_set_state(vlib_main_t *vm, u32 node_index, vlib_node_state_t new_state)
Set node dispatch state.
Definition: node_funcs.h:147
uword * thread_registrations_by_name
Definition: threads.h:297
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u32 input_cpu_first_index
Definition: netmap.h:95
vnet_device_class_t netmap_device_class
u64 uword
Definition: types.h:112
uint16_t nr_arg2
Definition: net_netmap.h:511
uword * pending_input_bitmap
Definition: netmap.h:83
#define hash_get_mem(h, key)
Definition: hash.h:269
static u32 random_u32(u32 *seed)
32-bit random number generator
Definition: random.h:69
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
uword private_data
Definition: file.h:64
netmap_main_t netmap_main
Definition: netmap.c:30
Definition: file.h:51
u32 ** rx_buffers
Definition: netmap.h:86
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:62
static clib_error_t * netmap_init(vlib_main_t *vm)
Definition: netmap.c:276
uint32_t nr_flags
Definition: net_netmap.h:513
int netmap_delete_if(vlib_main_t *vm, u8 *host_if_name)
Definition: netmap.c:246
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128