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