65f6a2b0384e1bea43e3e5f8c35efa79d250e8cb
[dpdk.git] / lib / librte_kni / rte_kni.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #ifndef RTE_EXEC_ENV_LINUXAPP
6 #error "KNI is not supported"
7 #endif
8
9 #include <string.h>
10 #include <fcntl.h>
11 #include <unistd.h>
12 #include <sys/ioctl.h>
13
14 #include <rte_spinlock.h>
15 #include <rte_string_fns.h>
16 #include <rte_ethdev.h>
17 #include <rte_malloc.h>
18 #include <rte_log.h>
19 #include <rte_kni.h>
20 #include <rte_memzone.h>
21 #include <exec-env/rte_kni_common.h>
22 #include "rte_kni_fifo.h"
23
24 #define MAX_MBUF_BURST_NUM            32
25
26 /* Maximum number of ring entries */
27 #define KNI_FIFO_COUNT_MAX     1024
28 #define KNI_FIFO_SIZE          (KNI_FIFO_COUNT_MAX * sizeof(void *) + \
29                                         sizeof(struct rte_kni_fifo))
30
31 #define KNI_REQUEST_MBUF_NUM_MAX      32
32
33 #define KNI_MEM_CHECK(cond) do { if (cond) goto kni_fail; } while (0)
34
35 /**
36  * KNI context
37  */
38 struct rte_kni {
39         char name[RTE_KNI_NAMESIZE];        /**< KNI interface name */
40         uint16_t group_id;                  /**< Group ID of KNI devices */
41         uint32_t slot_id;                   /**< KNI pool slot ID */
42         struct rte_mempool *pktmbuf_pool;   /**< pkt mbuf mempool */
43         unsigned mbuf_size;                 /**< mbuf size */
44
45         struct rte_kni_fifo *tx_q;          /**< TX queue */
46         struct rte_kni_fifo *rx_q;          /**< RX queue */
47         struct rte_kni_fifo *alloc_q;       /**< Allocated mbufs queue */
48         struct rte_kni_fifo *free_q;        /**< To be freed mbufs queue */
49
50         /* For request & response */
51         struct rte_kni_fifo *req_q;         /**< Request queue */
52         struct rte_kni_fifo *resp_q;        /**< Response queue */
53         void * sync_addr;                   /**< Req/Resp Mem address */
54
55         struct rte_kni_ops ops;             /**< operations for request */
56         uint8_t in_use : 1;                 /**< kni in use */
57 };
58
59 enum kni_ops_status {
60         KNI_REQ_NO_REGISTER = 0,
61         KNI_REQ_REGISTERED,
62 };
63
64 /**
65  * KNI memzone pool slot
66  */
67 struct rte_kni_memzone_slot {
68         uint32_t id;
69         uint8_t in_use : 1;                    /**< slot in use */
70
71         /* Memzones */
72         const struct rte_memzone *m_ctx;       /**< KNI ctx */
73         const struct rte_memzone *m_tx_q;      /**< TX queue */
74         const struct rte_memzone *m_rx_q;      /**< RX queue */
75         const struct rte_memzone *m_alloc_q;   /**< Allocated mbufs queue */
76         const struct rte_memzone *m_free_q;    /**< To be freed mbufs queue */
77         const struct rte_memzone *m_req_q;     /**< Request queue */
78         const struct rte_memzone *m_resp_q;    /**< Response queue */
79         const struct rte_memzone *m_sync_addr;
80
81         /* Free linked list */
82         struct rte_kni_memzone_slot *next;     /**< Next slot link.list */
83 };
84
85 /**
86  * KNI memzone pool
87  */
88 struct rte_kni_memzone_pool {
89         uint8_t initialized : 1;            /**< Global KNI pool init flag */
90
91         uint32_t max_ifaces;                /**< Max. num of KNI ifaces */
92         struct rte_kni_memzone_slot *slots;        /**< Pool slots */
93         rte_spinlock_t mutex;               /**< alloc/release mutex */
94
95         /* Free memzone slots linked-list */
96         struct rte_kni_memzone_slot *free;         /**< First empty slot */
97         struct rte_kni_memzone_slot *free_tail;    /**< Last empty slot */
98 };
99
100
101 static void kni_free_mbufs(struct rte_kni *kni);
102 static void kni_allocate_mbufs(struct rte_kni *kni);
103
104 static volatile int kni_fd = -1;
105 static struct rte_kni_memzone_pool kni_memzone_pool = {
106         .initialized = 0,
107 };
108
109 static const struct rte_memzone *
110 kni_memzone_reserve(const char *name, size_t len, int socket_id,
111                                                 unsigned flags)
112 {
113         const struct rte_memzone *mz = rte_memzone_lookup(name);
114
115         if (mz == NULL)
116                 mz = rte_memzone_reserve(name, len, socket_id, flags);
117
118         return mz;
119 }
120
121 /* Pool mgmt */
122 static struct rte_kni_memzone_slot*
123 kni_memzone_pool_alloc(void)
124 {
125         struct rte_kni_memzone_slot *slot;
126
127         rte_spinlock_lock(&kni_memzone_pool.mutex);
128
129         if (!kni_memzone_pool.free) {
130                 rte_spinlock_unlock(&kni_memzone_pool.mutex);
131                 return NULL;
132         }
133
134         slot = kni_memzone_pool.free;
135         kni_memzone_pool.free = slot->next;
136         slot->in_use = 1;
137
138         if (!kni_memzone_pool.free)
139                 kni_memzone_pool.free_tail = NULL;
140
141         rte_spinlock_unlock(&kni_memzone_pool.mutex);
142
143         return slot;
144 }
145
146 static void
147 kni_memzone_pool_release(struct rte_kni_memzone_slot *slot)
148 {
149         rte_spinlock_lock(&kni_memzone_pool.mutex);
150
151         if (kni_memzone_pool.free)
152                 kni_memzone_pool.free_tail->next = slot;
153         else
154                 kni_memzone_pool.free = slot;
155
156         kni_memzone_pool.free_tail = slot;
157         slot->next = NULL;
158         slot->in_use = 0;
159
160         rte_spinlock_unlock(&kni_memzone_pool.mutex);
161 }
162
163
164 /* Shall be called before any allocation happens */
165 void
166 rte_kni_init(unsigned int max_kni_ifaces)
167 {
168         uint32_t i;
169         struct rte_kni_memzone_slot *it;
170         const struct rte_memzone *mz;
171 #define OBJNAMSIZ 32
172         char obj_name[OBJNAMSIZ];
173         char mz_name[RTE_MEMZONE_NAMESIZE];
174
175         /* Immediately return if KNI is already initialized */
176         if (kni_memzone_pool.initialized) {
177                 RTE_LOG(WARNING, KNI, "Double call to rte_kni_init()");
178                 return;
179         }
180
181         if (max_kni_ifaces == 0) {
182                 RTE_LOG(ERR, KNI, "Invalid number of max_kni_ifaces %d\n",
183                                                         max_kni_ifaces);
184                 RTE_LOG(ERR, KNI, "Unable to initialize KNI\n");
185                 return;
186         }
187
188         /* Check FD and open */
189         if (kni_fd < 0) {
190                 kni_fd = open("/dev/" KNI_DEVICE, O_RDWR);
191                 if (kni_fd < 0) {
192                         RTE_LOG(ERR, KNI,
193                                 "Can not open /dev/%s\n", KNI_DEVICE);
194                         return;
195                 }
196         }
197
198         /* Allocate slot objects */
199         kni_memzone_pool.slots = (struct rte_kni_memzone_slot *)
200                                         rte_malloc(NULL,
201                                         sizeof(struct rte_kni_memzone_slot) *
202                                         max_kni_ifaces,
203                                         0);
204         KNI_MEM_CHECK(kni_memzone_pool.slots == NULL);
205
206         /* Initialize general pool variables */
207         kni_memzone_pool.initialized = 1;
208         kni_memzone_pool.max_ifaces = max_kni_ifaces;
209         kni_memzone_pool.free = &kni_memzone_pool.slots[0];
210         rte_spinlock_init(&kni_memzone_pool.mutex);
211
212         /* Pre-allocate all memzones of all the slots; panic on error */
213         for (i = 0; i < max_kni_ifaces; i++) {
214
215                 /* Recover current slot */
216                 it = &kni_memzone_pool.slots[i];
217                 it->id = i;
218
219                 /* Allocate KNI context */
220                 snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "KNI_INFO_%d", i);
221                 mz = kni_memzone_reserve(mz_name, sizeof(struct rte_kni),
222                                         SOCKET_ID_ANY, 0);
223                 KNI_MEM_CHECK(mz == NULL);
224                 it->m_ctx = mz;
225
226                 /* TX RING */
227                 snprintf(obj_name, OBJNAMSIZ, "kni_tx_%d", i);
228                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
229                                                         SOCKET_ID_ANY, 0);
230                 KNI_MEM_CHECK(mz == NULL);
231                 it->m_tx_q = mz;
232
233                 /* RX RING */
234                 snprintf(obj_name, OBJNAMSIZ, "kni_rx_%d", i);
235                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
236                                                         SOCKET_ID_ANY, 0);
237                 KNI_MEM_CHECK(mz == NULL);
238                 it->m_rx_q = mz;
239
240                 /* ALLOC RING */
241                 snprintf(obj_name, OBJNAMSIZ, "kni_alloc_%d", i);
242                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
243                                                         SOCKET_ID_ANY, 0);
244                 KNI_MEM_CHECK(mz == NULL);
245                 it->m_alloc_q = mz;
246
247                 /* FREE RING */
248                 snprintf(obj_name, OBJNAMSIZ, "kni_free_%d", i);
249                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
250                                                         SOCKET_ID_ANY, 0);
251                 KNI_MEM_CHECK(mz == NULL);
252                 it->m_free_q = mz;
253
254                 /* Request RING */
255                 snprintf(obj_name, OBJNAMSIZ, "kni_req_%d", i);
256                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
257                                                         SOCKET_ID_ANY, 0);
258                 KNI_MEM_CHECK(mz == NULL);
259                 it->m_req_q = mz;
260
261                 /* Response RING */
262                 snprintf(obj_name, OBJNAMSIZ, "kni_resp_%d", i);
263                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
264                                                         SOCKET_ID_ANY, 0);
265                 KNI_MEM_CHECK(mz == NULL);
266                 it->m_resp_q = mz;
267
268                 /* Req/Resp sync mem area */
269                 snprintf(obj_name, OBJNAMSIZ, "kni_sync_%d", i);
270                 mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
271                                                         SOCKET_ID_ANY, 0);
272                 KNI_MEM_CHECK(mz == NULL);
273                 it->m_sync_addr = mz;
274
275                 if ((i+1) == max_kni_ifaces) {
276                         it->next = NULL;
277                         kni_memzone_pool.free_tail = it;
278                 } else
279                         it->next = &kni_memzone_pool.slots[i+1];
280         }
281
282         return;
283
284 kni_fail:
285         RTE_LOG(ERR, KNI, "Unable to allocate memory for max_kni_ifaces:%d."
286                 "Increase the amount of hugepages memory\n", max_kni_ifaces);
287 }
288
289
290 struct rte_kni *
291 rte_kni_alloc(struct rte_mempool *pktmbuf_pool,
292               const struct rte_kni_conf *conf,
293               struct rte_kni_ops *ops)
294 {
295         int ret;
296         struct rte_kni_device_info dev_info;
297         struct rte_kni *ctx;
298         char intf_name[RTE_KNI_NAMESIZE];
299         const struct rte_memzone *mz;
300         struct rte_kni_memzone_slot *slot = NULL;
301
302         if (!pktmbuf_pool || !conf || !conf->name[0])
303                 return NULL;
304
305         /* Check if KNI subsystem has been initialized */
306         if (kni_memzone_pool.initialized != 1) {
307                 RTE_LOG(ERR, KNI, "KNI subsystem has not been initialized. Invoke rte_kni_init() first\n");
308                 return NULL;
309         }
310
311         /* Get an available slot from the pool */
312         slot = kni_memzone_pool_alloc();
313         if (!slot) {
314                 RTE_LOG(ERR, KNI, "Cannot allocate more KNI interfaces; increase the number of max_kni_ifaces(current %d) or release unused ones.\n",
315                         kni_memzone_pool.max_ifaces);
316                 return NULL;
317         }
318
319         /* Recover ctx */
320         ctx = slot->m_ctx->addr;
321         snprintf(intf_name, RTE_KNI_NAMESIZE, "%s", conf->name);
322
323         if (ctx->in_use) {
324                 RTE_LOG(ERR, KNI, "KNI %s is in use\n", ctx->name);
325                 return NULL;
326         }
327         memset(ctx, 0, sizeof(struct rte_kni));
328         if (ops)
329                 memcpy(&ctx->ops, ops, sizeof(struct rte_kni_ops));
330         else
331                 ctx->ops.port_id = UINT16_MAX;
332
333         memset(&dev_info, 0, sizeof(dev_info));
334         dev_info.bus = conf->addr.bus;
335         dev_info.devid = conf->addr.devid;
336         dev_info.function = conf->addr.function;
337         dev_info.vendor_id = conf->id.vendor_id;
338         dev_info.device_id = conf->id.device_id;
339         dev_info.core_id = conf->core_id;
340         dev_info.force_bind = conf->force_bind;
341         dev_info.group_id = conf->group_id;
342         dev_info.mbuf_size = conf->mbuf_size;
343         dev_info.mtu = conf->mtu;
344
345         memcpy(dev_info.mac_addr, conf->mac_addr, ETHER_ADDR_LEN);
346
347         snprintf(ctx->name, RTE_KNI_NAMESIZE, "%s", intf_name);
348         snprintf(dev_info.name, RTE_KNI_NAMESIZE, "%s", intf_name);
349
350         RTE_LOG(INFO, KNI, "pci: %02x:%02x:%02x \t %02x:%02x\n",
351                 dev_info.bus, dev_info.devid, dev_info.function,
352                         dev_info.vendor_id, dev_info.device_id);
353         /* TX RING */
354         mz = slot->m_tx_q;
355         ctx->tx_q = mz->addr;
356         kni_fifo_init(ctx->tx_q, KNI_FIFO_COUNT_MAX);
357         dev_info.tx_phys = mz->phys_addr;
358
359         /* RX RING */
360         mz = slot->m_rx_q;
361         ctx->rx_q = mz->addr;
362         kni_fifo_init(ctx->rx_q, KNI_FIFO_COUNT_MAX);
363         dev_info.rx_phys = mz->phys_addr;
364
365         /* ALLOC RING */
366         mz = slot->m_alloc_q;
367         ctx->alloc_q = mz->addr;
368         kni_fifo_init(ctx->alloc_q, KNI_FIFO_COUNT_MAX);
369         dev_info.alloc_phys = mz->phys_addr;
370
371         /* FREE RING */
372         mz = slot->m_free_q;
373         ctx->free_q = mz->addr;
374         kni_fifo_init(ctx->free_q, KNI_FIFO_COUNT_MAX);
375         dev_info.free_phys = mz->phys_addr;
376
377         /* Request RING */
378         mz = slot->m_req_q;
379         ctx->req_q = mz->addr;
380         kni_fifo_init(ctx->req_q, KNI_FIFO_COUNT_MAX);
381         dev_info.req_phys = mz->phys_addr;
382
383         /* Response RING */
384         mz = slot->m_resp_q;
385         ctx->resp_q = mz->addr;
386         kni_fifo_init(ctx->resp_q, KNI_FIFO_COUNT_MAX);
387         dev_info.resp_phys = mz->phys_addr;
388
389         /* Req/Resp sync mem area */
390         mz = slot->m_sync_addr;
391         ctx->sync_addr = mz->addr;
392         dev_info.sync_va = mz->addr;
393         dev_info.sync_phys = mz->phys_addr;
394
395         ctx->pktmbuf_pool = pktmbuf_pool;
396         ctx->group_id = conf->group_id;
397         ctx->slot_id = slot->id;
398         ctx->mbuf_size = conf->mbuf_size;
399
400         ret = ioctl(kni_fd, RTE_KNI_IOCTL_CREATE, &dev_info);
401         KNI_MEM_CHECK(ret < 0);
402
403         ctx->in_use = 1;
404
405         /* Allocate mbufs and then put them into alloc_q */
406         kni_allocate_mbufs(ctx);
407
408         return ctx;
409
410 kni_fail:
411         if (slot)
412                 kni_memzone_pool_release(&kni_memzone_pool.slots[slot->id]);
413
414         return NULL;
415 }
416
417 static void
418 kni_free_fifo(struct rte_kni_fifo *fifo)
419 {
420         int ret;
421         struct rte_mbuf *pkt;
422
423         do {
424                 ret = kni_fifo_get(fifo, (void **)&pkt, 1);
425                 if (ret)
426                         rte_pktmbuf_free(pkt);
427         } while (ret);
428 }
429
430 static void *
431 va2pa(struct rte_mbuf *m)
432 {
433         return (void *)((unsigned long)m -
434                         ((unsigned long)m->buf_addr -
435                          (unsigned long)m->buf_iova));
436 }
437
438 static void
439 obj_free(struct rte_mempool *mp __rte_unused, void *opaque, void *obj,
440                 unsigned obj_idx __rte_unused)
441 {
442         struct rte_mbuf *m = obj;
443         void *mbuf_phys = opaque;
444
445         if (va2pa(m) == mbuf_phys)
446                 rte_pktmbuf_free(m);
447 }
448
449 static void
450 kni_free_fifo_phy(struct rte_mempool *mp, struct rte_kni_fifo *fifo)
451 {
452         void *mbuf_phys;
453         int ret;
454
455         do {
456                 ret = kni_fifo_get(fifo, &mbuf_phys, 1);
457                 if (ret)
458                         rte_mempool_obj_iter(mp, obj_free, mbuf_phys);
459         } while (ret);
460 }
461
462 int
463 rte_kni_release(struct rte_kni *kni)
464 {
465         struct rte_kni_device_info dev_info;
466         uint32_t slot_id;
467         uint32_t retry = 5;
468
469         if (!kni || !kni->in_use)
470                 return -1;
471
472         snprintf(dev_info.name, sizeof(dev_info.name), "%s", kni->name);
473         if (ioctl(kni_fd, RTE_KNI_IOCTL_RELEASE, &dev_info) < 0) {
474                 RTE_LOG(ERR, KNI, "Fail to release kni device\n");
475                 return -1;
476         }
477
478         /* mbufs in all fifo should be released, except request/response */
479
480         /* wait until all rxq packets processed by kernel */
481         while (kni_fifo_count(kni->rx_q) && retry--)
482                 usleep(1000);
483
484         if (kni_fifo_count(kni->rx_q))
485                 RTE_LOG(ERR, KNI, "Fail to free all Rx-q items\n");
486
487         kni_free_fifo_phy(kni->pktmbuf_pool, kni->alloc_q);
488         kni_free_fifo(kni->tx_q);
489         kni_free_fifo(kni->free_q);
490
491         slot_id = kni->slot_id;
492
493         /* Memset the KNI struct */
494         memset(kni, 0, sizeof(struct rte_kni));
495
496         /* Release memzone */
497         if (slot_id > kni_memzone_pool.max_ifaces) {
498                 RTE_LOG(ERR, KNI, "KNI pool: corrupted slot ID: %d, max: %d\n",
499                         slot_id, kni_memzone_pool.max_ifaces);
500                 return -1;
501         }
502         kni_memzone_pool_release(&kni_memzone_pool.slots[slot_id]);
503
504         return 0;
505 }
506
507 /* default callback for request of configuring device mac address */
508 static int
509 kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[])
510 {
511         int ret = 0;
512
513         if (!rte_eth_dev_is_valid_port(port_id)) {
514                 RTE_LOG(ERR, KNI, "Invalid port id %d\n", port_id);
515                 return -EINVAL;
516         }
517
518         RTE_LOG(INFO, KNI, "Configure mac address of %d", port_id);
519
520         ret = rte_eth_dev_default_mac_addr_set(port_id,
521                                                (struct ether_addr *)mac_addr);
522         if (ret < 0)
523                 RTE_LOG(ERR, KNI, "Failed to config mac_addr for port %d\n",
524                         port_id);
525
526         return ret;
527 }
528
529 /* default callback for request of configuring promiscuous mode */
530 static int
531 kni_config_promiscusity(uint16_t port_id, uint8_t to_on)
532 {
533         if (!rte_eth_dev_is_valid_port(port_id)) {
534                 RTE_LOG(ERR, KNI, "Invalid port id %d\n", port_id);
535                 return -EINVAL;
536         }
537
538         RTE_LOG(INFO, KNI, "Configure promiscuous mode of %d to %d\n",
539                 port_id, to_on);
540
541         if (to_on)
542                 rte_eth_promiscuous_enable(port_id);
543         else
544                 rte_eth_promiscuous_disable(port_id);
545
546         return 0;
547 }
548
549 int
550 rte_kni_handle_request(struct rte_kni *kni)
551 {
552         unsigned ret;
553         struct rte_kni_request *req;
554
555         if (kni == NULL)
556                 return -1;
557
558         /* Get request mbuf */
559         ret = kni_fifo_get(kni->req_q, (void **)&req, 1);
560         if (ret != 1)
561                 return 0; /* It is OK of can not getting the request mbuf */
562
563         if (req != kni->sync_addr) {
564                 RTE_LOG(ERR, KNI, "Wrong req pointer %p\n", req);
565                 return -1;
566         }
567
568         /* Analyze the request and call the relevant actions for it */
569         switch (req->req_id) {
570         case RTE_KNI_REQ_CHANGE_MTU: /* Change MTU */
571                 if (kni->ops.change_mtu)
572                         req->result = kni->ops.change_mtu(kni->ops.port_id,
573                                                         req->new_mtu);
574                 break;
575         case RTE_KNI_REQ_CFG_NETWORK_IF: /* Set network interface up/down */
576                 if (kni->ops.config_network_if)
577                         req->result = kni->ops.config_network_if(\
578                                         kni->ops.port_id, req->if_up);
579                 break;
580         case RTE_KNI_REQ_CHANGE_MAC_ADDR: /* Change MAC Address */
581                 if (kni->ops.config_mac_address)
582                         req->result = kni->ops.config_mac_address(
583                                         kni->ops.port_id, req->mac_addr);
584                 else if (kni->ops.port_id != UINT16_MAX)
585                         req->result = kni_config_mac_address(
586                                         kni->ops.port_id, req->mac_addr);
587                 break;
588         case RTE_KNI_REQ_CHANGE_PROMISC: /* Change PROMISCUOUS MODE */
589                 if (kni->ops.config_promiscusity)
590                         req->result = kni->ops.config_promiscusity(
591                                         kni->ops.port_id, req->promiscusity);
592                 else if (kni->ops.port_id != UINT16_MAX)
593                         req->result = kni_config_promiscusity(
594                                         kni->ops.port_id, req->promiscusity);
595                 break;
596         default:
597                 RTE_LOG(ERR, KNI, "Unknown request id %u\n", req->req_id);
598                 req->result = -EINVAL;
599                 break;
600         }
601
602         /* Construct response mbuf and put it back to resp_q */
603         ret = kni_fifo_put(kni->resp_q, (void **)&req, 1);
604         if (ret != 1) {
605                 RTE_LOG(ERR, KNI, "Fail to put the muf back to resp_q\n");
606                 return -1; /* It is an error of can't putting the mbuf back */
607         }
608
609         return 0;
610 }
611
612 unsigned
613 rte_kni_tx_burst(struct rte_kni *kni, struct rte_mbuf **mbufs, unsigned num)
614 {
615         void *phy_mbufs[num];
616         unsigned int ret;
617         unsigned int i;
618
619         for (i = 0; i < num; i++)
620                 phy_mbufs[i] = va2pa(mbufs[i]);
621
622         ret = kni_fifo_put(kni->rx_q, phy_mbufs, num);
623
624         /* Get mbufs from free_q and then free them */
625         kni_free_mbufs(kni);
626
627         return ret;
628 }
629
630 unsigned
631 rte_kni_rx_burst(struct rte_kni *kni, struct rte_mbuf **mbufs, unsigned num)
632 {
633         unsigned ret = kni_fifo_get(kni->tx_q, (void **)mbufs, num);
634
635         /* If buffers removed, allocate mbufs and then put them into alloc_q */
636         if (ret)
637                 kni_allocate_mbufs(kni);
638
639         return ret;
640 }
641
642 static void
643 kni_free_mbufs(struct rte_kni *kni)
644 {
645         int i, ret;
646         struct rte_mbuf *pkts[MAX_MBUF_BURST_NUM];
647
648         ret = kni_fifo_get(kni->free_q, (void **)pkts, MAX_MBUF_BURST_NUM);
649         if (likely(ret > 0)) {
650                 for (i = 0; i < ret; i++)
651                         rte_pktmbuf_free(pkts[i]);
652         }
653 }
654
655 static void
656 kni_allocate_mbufs(struct rte_kni *kni)
657 {
658         int i, ret;
659         struct rte_mbuf *pkts[MAX_MBUF_BURST_NUM];
660         void *phys[MAX_MBUF_BURST_NUM];
661         int allocq_free;
662
663         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, pool) !=
664                          offsetof(struct rte_kni_mbuf, pool));
665         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, buf_addr) !=
666                          offsetof(struct rte_kni_mbuf, buf_addr));
667         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, next) !=
668                          offsetof(struct rte_kni_mbuf, next));
669         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, data_off) !=
670                          offsetof(struct rte_kni_mbuf, data_off));
671         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, data_len) !=
672                          offsetof(struct rte_kni_mbuf, data_len));
673         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, pkt_len) !=
674                          offsetof(struct rte_kni_mbuf, pkt_len));
675         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, ol_flags) !=
676                          offsetof(struct rte_kni_mbuf, ol_flags));
677
678         /* Check if pktmbuf pool has been configured */
679         if (kni->pktmbuf_pool == NULL) {
680                 RTE_LOG(ERR, KNI, "No valid mempool for allocating mbufs\n");
681                 return;
682         }
683
684         allocq_free = (kni->alloc_q->read - kni->alloc_q->write - 1) \
685                         & (MAX_MBUF_BURST_NUM - 1);
686         for (i = 0; i < allocq_free; i++) {
687                 pkts[i] = rte_pktmbuf_alloc(kni->pktmbuf_pool);
688                 if (unlikely(pkts[i] == NULL)) {
689                         /* Out of memory */
690                         RTE_LOG(ERR, KNI, "Out of memory\n");
691                         break;
692                 }
693                 phys[i] = va2pa(pkts[i]);
694         }
695
696         /* No pkt mbuf allocated */
697         if (i <= 0)
698                 return;
699
700         ret = kni_fifo_put(kni->alloc_q, phys, i);
701
702         /* Check if any mbufs not put into alloc_q, and then free them */
703         if (ret >= 0 && ret < i && ret < MAX_MBUF_BURST_NUM) {
704                 int j;
705
706                 for (j = ret; j < i; j++)
707                         rte_pktmbuf_free(pkts[j]);
708         }
709 }
710
711 struct rte_kni *
712 rte_kni_get(const char *name)
713 {
714         uint32_t i;
715         struct rte_kni_memzone_slot *it;
716         struct rte_kni *kni;
717
718         if (name == NULL || name[0] == '\0')
719                 return NULL;
720
721         /* Note: could be improved perf-wise if necessary */
722         for (i = 0; i < kni_memzone_pool.max_ifaces; i++) {
723                 it = &kni_memzone_pool.slots[i];
724                 if (it->in_use == 0)
725                         continue;
726                 kni = it->m_ctx->addr;
727                 if (strncmp(kni->name, name, RTE_KNI_NAMESIZE) == 0)
728                         return kni;
729         }
730
731         return NULL;
732 }
733
734 const char *
735 rte_kni_get_name(const struct rte_kni *kni)
736 {
737         return kni->name;
738 }
739
740 static enum kni_ops_status
741 kni_check_request_register(struct rte_kni_ops *ops)
742 {
743         /* check if KNI request ops has been registered*/
744         if( NULL == ops )
745                 return KNI_REQ_NO_REGISTER;
746
747         if ((ops->change_mtu == NULL)
748                 && (ops->config_network_if == NULL)
749                 && (ops->config_mac_address == NULL)
750                 && (ops->config_promiscusity == NULL))
751                 return KNI_REQ_NO_REGISTER;
752
753         return KNI_REQ_REGISTERED;
754 }
755
756 int
757 rte_kni_register_handlers(struct rte_kni *kni,struct rte_kni_ops *ops)
758 {
759         enum kni_ops_status req_status;
760
761         if (NULL == ops) {
762                 RTE_LOG(ERR, KNI, "Invalid KNI request operation.\n");
763                 return -1;
764         }
765
766         if (NULL == kni) {
767                 RTE_LOG(ERR, KNI, "Invalid kni info.\n");
768                 return -1;
769         }
770
771         req_status = kni_check_request_register(&kni->ops);
772         if ( KNI_REQ_REGISTERED == req_status) {
773                 RTE_LOG(ERR, KNI, "The KNI request operation has already registered.\n");
774                 return -1;
775         }
776
777         memcpy(&kni->ops, ops, sizeof(struct rte_kni_ops));
778         return 0;
779 }
780
781 int
782 rte_kni_unregister_handlers(struct rte_kni *kni)
783 {
784         if (NULL == kni) {
785                 RTE_LOG(ERR, KNI, "Invalid kni info.\n");
786                 return -1;
787         }
788
789         memset(&kni->ops, 0, sizeof(struct rte_kni_ops));
790
791         return 0;
792 }
793 void
794 rte_kni_close(void)
795 {
796         if (kni_fd < 0)
797                 return;
798
799         close(kni_fd);
800         kni_fd = -1;
801 }