pmdinfogen: add SPDX license tag
[dpdk.git] / kernel / linux / kni / kni_net.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright(c) 2010-2014 Intel Corporation.
4  */
5
6 /*
7  * This code is inspired from the book "Linux Device Drivers" by
8  * Alessandro Rubini and Jonathan Corbet, published by O'Reilly & Associates
9  */
10
11 #include <linux/device.h>
12 #include <linux/module.h>
13 #include <linux/version.h>
14 #include <linux/netdevice.h>
15 #include <linux/etherdevice.h> /* eth_type_trans */
16 #include <linux/ethtool.h>
17 #include <linux/skbuff.h>
18 #include <linux/kthread.h>
19 #include <linux/delay.h>
20
21 #include <rte_kni_common.h>
22 #include <kni_fifo.h>
23
24 #include "compat.h"
25 #include "kni_dev.h"
26
27 #define WD_TIMEOUT 5 /*jiffies */
28
29 #define KNI_WAIT_RESPONSE_TIMEOUT 300 /* 3 seconds */
30
31 /* typedef for rx function */
32 typedef void (*kni_net_rx_t)(struct kni_dev *kni);
33
34 static void kni_net_rx_normal(struct kni_dev *kni);
35
36 /* kni rx function pointer, with default to normal rx */
37 static kni_net_rx_t kni_net_rx_func = kni_net_rx_normal;
38
39 #ifdef HAVE_IOVA_TO_KVA_MAPPING_SUPPORT
40 /* iova to kernel virtual address */
41 static inline void *
42 iova2kva(struct kni_dev *kni, void *iova)
43 {
44         return phys_to_virt(iova_to_phys(kni->usr_tsk, (unsigned long)iova));
45 }
46
47 static inline void *
48 iova2data_kva(struct kni_dev *kni, struct rte_kni_mbuf *m)
49 {
50         return phys_to_virt(iova_to_phys(kni->usr_tsk, m->buf_physaddr) +
51                             m->data_off);
52 }
53 #endif
54
55 /* physical address to kernel virtual address */
56 static void *
57 pa2kva(void *pa)
58 {
59         return phys_to_virt((unsigned long)pa);
60 }
61
62 /* physical address to virtual address */
63 static void *
64 pa2va(void *pa, struct rte_kni_mbuf *m)
65 {
66         void *va;
67
68         va = (void *)((unsigned long)pa +
69                         (unsigned long)m->buf_addr -
70                         (unsigned long)m->buf_physaddr);
71         return va;
72 }
73
74 /* mbuf data kernel virtual address from mbuf kernel virtual address */
75 static void *
76 kva2data_kva(struct rte_kni_mbuf *m)
77 {
78         return phys_to_virt(m->buf_physaddr + m->data_off);
79 }
80
81 static inline void *
82 get_kva(struct kni_dev *kni, void *pa)
83 {
84 #ifdef HAVE_IOVA_TO_KVA_MAPPING_SUPPORT
85         if (kni->iova_mode == 1)
86                 return iova2kva(kni, pa);
87 #endif
88         return pa2kva(pa);
89 }
90
91 static inline void *
92 get_data_kva(struct kni_dev *kni, void *pkt_kva)
93 {
94 #ifdef HAVE_IOVA_TO_KVA_MAPPING_SUPPORT
95         if (kni->iova_mode == 1)
96                 return iova2data_kva(kni, pkt_kva);
97 #endif
98         return kva2data_kva(pkt_kva);
99 }
100
101 /*
102  * It can be called to process the request.
103  */
104 static int
105 kni_net_process_request(struct kni_dev *kni, struct rte_kni_request *req)
106 {
107         int ret = -1;
108         void *resp_va;
109         uint32_t num;
110         int ret_val;
111
112         if (!kni || !req) {
113                 pr_err("No kni instance or request\n");
114                 return -EINVAL;
115         }
116
117         mutex_lock(&kni->sync_lock);
118
119         /* Construct data */
120         memcpy(kni->sync_kva, req, sizeof(struct rte_kni_request));
121         num = kni_fifo_put(kni->req_q, &kni->sync_va, 1);
122         if (num < 1) {
123                 pr_err("Cannot send to req_q\n");
124                 ret = -EBUSY;
125                 goto fail;
126         }
127
128         ret_val = wait_event_interruptible_timeout(kni->wq,
129                         kni_fifo_count(kni->resp_q), 3 * HZ);
130         if (signal_pending(current) || ret_val <= 0) {
131                 ret = -ETIME;
132                 goto fail;
133         }
134         num = kni_fifo_get(kni->resp_q, (void **)&resp_va, 1);
135         if (num != 1 || resp_va != kni->sync_va) {
136                 /* This should never happen */
137                 pr_err("No data in resp_q\n");
138                 ret = -ENODATA;
139                 goto fail;
140         }
141
142         memcpy(req, kni->sync_kva, sizeof(struct rte_kni_request));
143         ret = 0;
144
145 fail:
146         mutex_unlock(&kni->sync_lock);
147         return ret;
148 }
149
150 /*
151  * Open and close
152  */
153 static int
154 kni_net_open(struct net_device *dev)
155 {
156         int ret;
157         struct rte_kni_request req;
158         struct kni_dev *kni = netdev_priv(dev);
159
160         netif_start_queue(dev);
161         if (kni_dflt_carrier == 1)
162                 netif_carrier_on(dev);
163         else
164                 netif_carrier_off(dev);
165
166         memset(&req, 0, sizeof(req));
167         req.req_id = RTE_KNI_REQ_CFG_NETWORK_IF;
168
169         /* Setting if_up to non-zero means up */
170         req.if_up = 1;
171         ret = kni_net_process_request(kni, &req);
172
173         return (ret == 0) ? req.result : ret;
174 }
175
176 static int
177 kni_net_release(struct net_device *dev)
178 {
179         int ret;
180         struct rte_kni_request req;
181         struct kni_dev *kni = netdev_priv(dev);
182
183         netif_stop_queue(dev); /* can't transmit any more */
184         netif_carrier_off(dev);
185
186         memset(&req, 0, sizeof(req));
187         req.req_id = RTE_KNI_REQ_CFG_NETWORK_IF;
188
189         /* Setting if_up to 0 means down */
190         req.if_up = 0;
191         ret = kni_net_process_request(kni, &req);
192
193         return (ret == 0) ? req.result : ret;
194 }
195
196 static void
197 kni_fifo_trans_pa2va(struct kni_dev *kni,
198         struct rte_kni_fifo *src_pa, struct rte_kni_fifo *dst_va)
199 {
200         uint32_t ret, i, num_dst, num_rx;
201         struct rte_kni_mbuf *kva, *prev_kva;
202         int nb_segs;
203         int kva_nb_segs;
204
205         do {
206                 num_dst = kni_fifo_free_count(dst_va);
207                 if (num_dst == 0)
208                         return;
209
210                 num_rx = min_t(uint32_t, num_dst, MBUF_BURST_SZ);
211
212                 num_rx = kni_fifo_get(src_pa, kni->pa, num_rx);
213                 if (num_rx == 0)
214                         return;
215
216                 for (i = 0; i < num_rx; i++) {
217                         kva = get_kva(kni, kni->pa[i]);
218                         kni->va[i] = pa2va(kni->pa[i], kva);
219
220                         kva_nb_segs = kva->nb_segs;
221                         for (nb_segs = 0; nb_segs < kva_nb_segs; nb_segs++) {
222                                 if (!kva->next)
223                                         break;
224
225                                 prev_kva = kva;
226                                 kva = pa2kva(kva->next);
227                                 /* Convert physical address to virtual address */
228                                 prev_kva->next = pa2va(prev_kva->next, kva);
229                         }
230                 }
231
232                 ret = kni_fifo_put(dst_va, kni->va, num_rx);
233                 if (ret != num_rx) {
234                         /* Failing should not happen */
235                         pr_err("Fail to enqueue entries into dst_va\n");
236                         return;
237                 }
238         } while (1);
239 }
240
241 /* Try to release mbufs when kni release */
242 void kni_net_release_fifo_phy(struct kni_dev *kni)
243 {
244         /* release rx_q first, because it can't release in userspace */
245         kni_fifo_trans_pa2va(kni, kni->rx_q, kni->free_q);
246         /* release alloc_q for speeding up kni release in userspace */
247         kni_fifo_trans_pa2va(kni, kni->alloc_q, kni->free_q);
248 }
249
250 /*
251  * Configuration changes (passed on by ifconfig)
252  */
253 static int
254 kni_net_config(struct net_device *dev, struct ifmap *map)
255 {
256         if (dev->flags & IFF_UP) /* can't act on a running interface */
257                 return -EBUSY;
258
259         /* ignore other fields */
260         return 0;
261 }
262
263 /*
264  * Transmit a packet (called by the kernel)
265  */
266 static int
267 kni_net_tx(struct sk_buff *skb, struct net_device *dev)
268 {
269         int len = 0;
270         uint32_t ret;
271         struct kni_dev *kni = netdev_priv(dev);
272         struct rte_kni_mbuf *pkt_kva = NULL;
273         void *pkt_pa = NULL;
274         void *pkt_va = NULL;
275
276         /* save the timestamp */
277 #ifdef HAVE_TRANS_START_HELPER
278         netif_trans_update(dev);
279 #else
280         dev->trans_start = jiffies;
281 #endif
282
283         /* Check if the length of skb is less than mbuf size */
284         if (skb->len > kni->mbuf_size)
285                 goto drop;
286
287         /**
288          * Check if it has at least one free entry in tx_q and
289          * one entry in alloc_q.
290          */
291         if (kni_fifo_free_count(kni->tx_q) == 0 ||
292                         kni_fifo_count(kni->alloc_q) == 0) {
293                 /**
294                  * If no free entry in tx_q or no entry in alloc_q,
295                  * drops skb and goes out.
296                  */
297                 goto drop;
298         }
299
300         /* dequeue a mbuf from alloc_q */
301         ret = kni_fifo_get(kni->alloc_q, &pkt_pa, 1);
302         if (likely(ret == 1)) {
303                 void *data_kva;
304
305                 pkt_kva = get_kva(kni, pkt_pa);
306                 data_kva = get_data_kva(kni, pkt_kva);
307                 pkt_va = pa2va(pkt_pa, pkt_kva);
308
309                 len = skb->len;
310                 memcpy(data_kva, skb->data, len);
311                 if (unlikely(len < ETH_ZLEN)) {
312                         memset(data_kva + len, 0, ETH_ZLEN - len);
313                         len = ETH_ZLEN;
314                 }
315                 pkt_kva->pkt_len = len;
316                 pkt_kva->data_len = len;
317
318                 /* enqueue mbuf into tx_q */
319                 ret = kni_fifo_put(kni->tx_q, &pkt_va, 1);
320                 if (unlikely(ret != 1)) {
321                         /* Failing should not happen */
322                         pr_err("Fail to enqueue mbuf into tx_q\n");
323                         goto drop;
324                 }
325         } else {
326                 /* Failing should not happen */
327                 pr_err("Fail to dequeue mbuf from alloc_q\n");
328                 goto drop;
329         }
330
331         /* Free skb and update statistics */
332         dev_kfree_skb(skb);
333         dev->stats.tx_bytes += len;
334         dev->stats.tx_packets++;
335
336         return NETDEV_TX_OK;
337
338 drop:
339         /* Free skb and update statistics */
340         dev_kfree_skb(skb);
341         dev->stats.tx_dropped++;
342
343         return NETDEV_TX_OK;
344 }
345
346 /*
347  * RX: normal working mode
348  */
349 static void
350 kni_net_rx_normal(struct kni_dev *kni)
351 {
352         uint32_t ret;
353         uint32_t len;
354         uint32_t i, num_rx, num_fq;
355         struct rte_kni_mbuf *kva, *prev_kva;
356         void *data_kva;
357         struct sk_buff *skb;
358         struct net_device *dev = kni->net_dev;
359
360         /* Get the number of free entries in free_q */
361         num_fq = kni_fifo_free_count(kni->free_q);
362         if (num_fq == 0) {
363                 /* No room on the free_q, bail out */
364                 return;
365         }
366
367         /* Calculate the number of entries to dequeue from rx_q */
368         num_rx = min_t(uint32_t, num_fq, MBUF_BURST_SZ);
369
370         /* Burst dequeue from rx_q */
371         num_rx = kni_fifo_get(kni->rx_q, kni->pa, num_rx);
372         if (num_rx == 0)
373                 return;
374
375         /* Transfer received packets to netif */
376         for (i = 0; i < num_rx; i++) {
377                 kva = get_kva(kni, kni->pa[i]);
378                 len = kva->pkt_len;
379                 data_kva = get_data_kva(kni, kva);
380                 kni->va[i] = pa2va(kni->pa[i], kva);
381
382                 skb = netdev_alloc_skb(dev, len);
383                 if (!skb) {
384                         /* Update statistics */
385                         dev->stats.rx_dropped++;
386                         continue;
387                 }
388
389                 if (kva->nb_segs == 1) {
390                         memcpy(skb_put(skb, len), data_kva, len);
391                 } else {
392                         int nb_segs;
393                         int kva_nb_segs = kva->nb_segs;
394
395                         for (nb_segs = 0; nb_segs < kva_nb_segs; nb_segs++) {
396                                 memcpy(skb_put(skb, kva->data_len),
397                                         data_kva, kva->data_len);
398
399                                 if (!kva->next)
400                                         break;
401
402                                 prev_kva = kva;
403                                 kva = pa2kva(kva->next);
404                                 data_kva = kva2data_kva(kva);
405                                 /* Convert physical address to virtual address */
406                                 prev_kva->next = pa2va(prev_kva->next, kva);
407                         }
408                 }
409
410                 skb->protocol = eth_type_trans(skb, dev);
411                 skb->ip_summed = CHECKSUM_UNNECESSARY;
412
413                 /* Call netif interface */
414                 netif_rx_ni(skb);
415
416                 /* Update statistics */
417                 dev->stats.rx_bytes += len;
418                 dev->stats.rx_packets++;
419         }
420
421         /* Burst enqueue mbufs into free_q */
422         ret = kni_fifo_put(kni->free_q, kni->va, num_rx);
423         if (ret != num_rx)
424                 /* Failing should not happen */
425                 pr_err("Fail to enqueue entries into free_q\n");
426 }
427
428 /*
429  * RX: loopback with enqueue/dequeue fifos.
430  */
431 static void
432 kni_net_rx_lo_fifo(struct kni_dev *kni)
433 {
434         uint32_t ret;
435         uint32_t len;
436         uint32_t i, num, num_rq, num_tq, num_aq, num_fq;
437         struct rte_kni_mbuf *kva, *next_kva;
438         void *data_kva;
439         struct rte_kni_mbuf *alloc_kva;
440         void *alloc_data_kva;
441         struct net_device *dev = kni->net_dev;
442
443         /* Get the number of entries in rx_q */
444         num_rq = kni_fifo_count(kni->rx_q);
445
446         /* Get the number of free entries in tx_q */
447         num_tq = kni_fifo_free_count(kni->tx_q);
448
449         /* Get the number of entries in alloc_q */
450         num_aq = kni_fifo_count(kni->alloc_q);
451
452         /* Get the number of free entries in free_q */
453         num_fq = kni_fifo_free_count(kni->free_q);
454
455         /* Calculate the number of entries to be dequeued from rx_q */
456         num = min(num_rq, num_tq);
457         num = min(num, num_aq);
458         num = min(num, num_fq);
459         num = min_t(uint32_t, num, MBUF_BURST_SZ);
460
461         /* Return if no entry to dequeue from rx_q */
462         if (num == 0)
463                 return;
464
465         /* Burst dequeue from rx_q */
466         ret = kni_fifo_get(kni->rx_q, kni->pa, num);
467         if (ret == 0)
468                 return; /* Failing should not happen */
469
470         /* Dequeue entries from alloc_q */
471         ret = kni_fifo_get(kni->alloc_q, kni->alloc_pa, num);
472         if (ret) {
473                 num = ret;
474                 /* Copy mbufs */
475                 for (i = 0; i < num; i++) {
476                         kva = get_kva(kni, kni->pa[i]);
477                         len = kva->data_len;
478                         data_kva = get_data_kva(kni, kva);
479                         kni->va[i] = pa2va(kni->pa[i], kva);
480
481                         while (kva->next) {
482                                 next_kva = pa2kva(kva->next);
483                                 /* Convert physical address to virtual address */
484                                 kva->next = pa2va(kva->next, next_kva);
485                                 kva = next_kva;
486                         }
487
488                         alloc_kva = get_kva(kni, kni->alloc_pa[i]);
489                         alloc_data_kva = get_data_kva(kni, alloc_kva);
490                         kni->alloc_va[i] = pa2va(kni->alloc_pa[i], alloc_kva);
491
492                         memcpy(alloc_data_kva, data_kva, len);
493                         alloc_kva->pkt_len = len;
494                         alloc_kva->data_len = len;
495
496                         dev->stats.tx_bytes += len;
497                         dev->stats.rx_bytes += len;
498                 }
499
500                 /* Burst enqueue mbufs into tx_q */
501                 ret = kni_fifo_put(kni->tx_q, kni->alloc_va, num);
502                 if (ret != num)
503                         /* Failing should not happen */
504                         pr_err("Fail to enqueue mbufs into tx_q\n");
505         }
506
507         /* Burst enqueue mbufs into free_q */
508         ret = kni_fifo_put(kni->free_q, kni->va, num);
509         if (ret != num)
510                 /* Failing should not happen */
511                 pr_err("Fail to enqueue mbufs into free_q\n");
512
513         /**
514          * Update statistic, and enqueue/dequeue failure is impossible,
515          * as all queues are checked at first.
516          */
517         dev->stats.tx_packets += num;
518         dev->stats.rx_packets += num;
519 }
520
521 /*
522  * RX: loopback with enqueue/dequeue fifos and sk buffer copies.
523  */
524 static void
525 kni_net_rx_lo_fifo_skb(struct kni_dev *kni)
526 {
527         uint32_t ret;
528         uint32_t len;
529         uint32_t i, num_rq, num_fq, num;
530         struct rte_kni_mbuf *kva, *prev_kva;
531         void *data_kva;
532         struct sk_buff *skb;
533         struct net_device *dev = kni->net_dev;
534
535         /* Get the number of entries in rx_q */
536         num_rq = kni_fifo_count(kni->rx_q);
537
538         /* Get the number of free entries in free_q */
539         num_fq = kni_fifo_free_count(kni->free_q);
540
541         /* Calculate the number of entries to dequeue from rx_q */
542         num = min(num_rq, num_fq);
543         num = min_t(uint32_t, num, MBUF_BURST_SZ);
544
545         /* Return if no entry to dequeue from rx_q */
546         if (num == 0)
547                 return;
548
549         /* Burst dequeue mbufs from rx_q */
550         ret = kni_fifo_get(kni->rx_q, kni->pa, num);
551         if (ret == 0)
552                 return;
553
554         /* Copy mbufs to sk buffer and then call tx interface */
555         for (i = 0; i < num; i++) {
556                 kva = get_kva(kni, kni->pa[i]);
557                 len = kva->pkt_len;
558                 data_kva = get_data_kva(kni, kva);
559                 kni->va[i] = pa2va(kni->pa[i], kva);
560
561                 skb = netdev_alloc_skb(dev, len);
562                 if (skb) {
563                         memcpy(skb_put(skb, len), data_kva, len);
564                         skb->ip_summed = CHECKSUM_UNNECESSARY;
565                         dev_kfree_skb(skb);
566                 }
567
568                 /* Simulate real usage, allocate/copy skb twice */
569                 skb = netdev_alloc_skb(dev, len);
570                 if (skb == NULL) {
571                         dev->stats.rx_dropped++;
572                         continue;
573                 }
574
575                 if (kva->nb_segs == 1) {
576                         memcpy(skb_put(skb, len), data_kva, len);
577                 } else {
578                         int nb_segs;
579                         int kva_nb_segs = kva->nb_segs;
580
581                         for (nb_segs = 0; nb_segs < kva_nb_segs; nb_segs++) {
582                                 memcpy(skb_put(skb, kva->data_len),
583                                         data_kva, kva->data_len);
584
585                                 if (!kva->next)
586                                         break;
587
588                                 prev_kva = kva;
589                                 kva = get_kva(kni, kva->next);
590                                 data_kva = get_data_kva(kni, kva);
591                                 /* Convert physical address to virtual address */
592                                 prev_kva->next = pa2va(prev_kva->next, kva);
593                         }
594                 }
595
596                 skb->ip_summed = CHECKSUM_UNNECESSARY;
597
598                 dev->stats.rx_bytes += len;
599                 dev->stats.rx_packets++;
600
601                 /* call tx interface */
602                 kni_net_tx(skb, dev);
603         }
604
605         /* enqueue all the mbufs from rx_q into free_q */
606         ret = kni_fifo_put(kni->free_q, kni->va, num);
607         if (ret != num)
608                 /* Failing should not happen */
609                 pr_err("Fail to enqueue mbufs into free_q\n");
610 }
611
612 /* rx interface */
613 void
614 kni_net_rx(struct kni_dev *kni)
615 {
616         /**
617          * It doesn't need to check if it is NULL pointer,
618          * as it has a default value
619          */
620         (*kni_net_rx_func)(kni);
621 }
622
623 /*
624  * Deal with a transmit timeout.
625  */
626 #ifdef HAVE_TX_TIMEOUT_TXQUEUE
627 static void
628 kni_net_tx_timeout(struct net_device *dev, unsigned int txqueue)
629 #else
630 static void
631 kni_net_tx_timeout(struct net_device *dev)
632 #endif
633 {
634         pr_debug("Transmit timeout at %ld, latency %ld\n", jiffies,
635                         jiffies - dev_trans_start(dev));
636
637         dev->stats.tx_errors++;
638         netif_wake_queue(dev);
639 }
640
641 static int
642 kni_net_change_mtu(struct net_device *dev, int new_mtu)
643 {
644         int ret;
645         struct rte_kni_request req;
646         struct kni_dev *kni = netdev_priv(dev);
647
648         pr_debug("kni_net_change_mtu new mtu %d to be set\n", new_mtu);
649
650         memset(&req, 0, sizeof(req));
651         req.req_id = RTE_KNI_REQ_CHANGE_MTU;
652         req.new_mtu = new_mtu;
653         ret = kni_net_process_request(kni, &req);
654         if (ret == 0 && req.result == 0)
655                 dev->mtu = new_mtu;
656
657         return (ret == 0) ? req.result : ret;
658 }
659
660 static void
661 kni_net_change_rx_flags(struct net_device *netdev, int flags)
662 {
663         struct rte_kni_request req;
664         struct kni_dev *kni = netdev_priv(netdev);
665
666         memset(&req, 0, sizeof(req));
667
668         if (flags & IFF_ALLMULTI) {
669                 req.req_id = RTE_KNI_REQ_CHANGE_ALLMULTI;
670
671                 if (netdev->flags & IFF_ALLMULTI)
672                         req.allmulti = 1;
673                 else
674                         req.allmulti = 0;
675         }
676
677         if (flags & IFF_PROMISC) {
678                 req.req_id = RTE_KNI_REQ_CHANGE_PROMISC;
679
680                 if (netdev->flags & IFF_PROMISC)
681                         req.promiscusity = 1;
682                 else
683                         req.promiscusity = 0;
684         }
685
686         kni_net_process_request(kni, &req);
687 }
688
689 /*
690  * Checks if the user space application provided the resp message
691  */
692 void
693 kni_net_poll_resp(struct kni_dev *kni)
694 {
695         if (kni_fifo_count(kni->resp_q))
696                 wake_up_interruptible(&kni->wq);
697 }
698
699 /*
700  *  Fill the eth header
701  */
702 static int
703 kni_net_header(struct sk_buff *skb, struct net_device *dev,
704                 unsigned short type, const void *daddr,
705                 const void *saddr, uint32_t len)
706 {
707         struct ethhdr *eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
708
709         memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
710         memcpy(eth->h_dest,   daddr ? daddr : dev->dev_addr, dev->addr_len);
711         eth->h_proto = htons(type);
712
713         return dev->hard_header_len;
714 }
715
716 /*
717  * Re-fill the eth header
718  */
719 #ifdef HAVE_REBUILD_HEADER
720 static int
721 kni_net_rebuild_header(struct sk_buff *skb)
722 {
723         struct net_device *dev = skb->dev;
724         struct ethhdr *eth = (struct ethhdr *) skb->data;
725
726         memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
727         memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
728
729         return 0;
730 }
731 #endif /* < 4.1.0  */
732
733 /**
734  * kni_net_set_mac - Change the Ethernet Address of the KNI NIC
735  * @netdev: network interface device structure
736  * @p: pointer to an address structure
737  *
738  * Returns 0 on success, negative on failure
739  **/
740 static int
741 kni_net_set_mac(struct net_device *netdev, void *p)
742 {
743         int ret;
744         struct rte_kni_request req;
745         struct kni_dev *kni;
746         struct sockaddr *addr = p;
747
748         memset(&req, 0, sizeof(req));
749         req.req_id = RTE_KNI_REQ_CHANGE_MAC_ADDR;
750
751         if (!is_valid_ether_addr((unsigned char *)(addr->sa_data)))
752                 return -EADDRNOTAVAIL;
753
754         memcpy(req.mac_addr, addr->sa_data, netdev->addr_len);
755         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
756
757         kni = netdev_priv(netdev);
758         ret = kni_net_process_request(kni, &req);
759
760         return (ret == 0 ? req.result : ret);
761 }
762
763 #ifdef HAVE_CHANGE_CARRIER_CB
764 static int
765 kni_net_change_carrier(struct net_device *dev, bool new_carrier)
766 {
767         if (new_carrier)
768                 netif_carrier_on(dev);
769         else
770                 netif_carrier_off(dev);
771         return 0;
772 }
773 #endif
774
775 static const struct header_ops kni_net_header_ops = {
776         .create  = kni_net_header,
777         .parse   = eth_header_parse,
778 #ifdef HAVE_REBUILD_HEADER
779         .rebuild = kni_net_rebuild_header,
780 #endif /* < 4.1.0  */
781         .cache   = NULL,  /* disable caching */
782 };
783
784 static const struct net_device_ops kni_net_netdev_ops = {
785         .ndo_open = kni_net_open,
786         .ndo_stop = kni_net_release,
787         .ndo_set_config = kni_net_config,
788         .ndo_change_rx_flags = kni_net_change_rx_flags,
789         .ndo_start_xmit = kni_net_tx,
790         .ndo_change_mtu = kni_net_change_mtu,
791         .ndo_tx_timeout = kni_net_tx_timeout,
792         .ndo_set_mac_address = kni_net_set_mac,
793 #ifdef HAVE_CHANGE_CARRIER_CB
794         .ndo_change_carrier = kni_net_change_carrier,
795 #endif
796 };
797
798 static void kni_get_drvinfo(struct net_device *dev,
799                             struct ethtool_drvinfo *info)
800 {
801         strlcpy(info->version, KNI_VERSION, sizeof(info->version));
802         strlcpy(info->driver, "kni", sizeof(info->driver));
803 }
804
805 static const struct ethtool_ops kni_net_ethtool_ops = {
806         .get_drvinfo    = kni_get_drvinfo,
807         .get_link       = ethtool_op_get_link,
808 };
809
810 void
811 kni_net_init(struct net_device *dev)
812 {
813         struct kni_dev *kni = netdev_priv(dev);
814
815         init_waitqueue_head(&kni->wq);
816         mutex_init(&kni->sync_lock);
817
818         ether_setup(dev); /* assign some of the fields */
819         dev->netdev_ops      = &kni_net_netdev_ops;
820         dev->header_ops      = &kni_net_header_ops;
821         dev->ethtool_ops     = &kni_net_ethtool_ops;
822         dev->watchdog_timeo = WD_TIMEOUT;
823 }
824
825 void
826 kni_net_config_lo_mode(char *lo_str)
827 {
828         if (!lo_str) {
829                 pr_debug("loopback disabled");
830                 return;
831         }
832
833         if (!strcmp(lo_str, "lo_mode_none"))
834                 pr_debug("loopback disabled");
835         else if (!strcmp(lo_str, "lo_mode_fifo")) {
836                 pr_debug("loopback mode=lo_mode_fifo enabled");
837                 kni_net_rx_func = kni_net_rx_lo_fifo;
838         } else if (!strcmp(lo_str, "lo_mode_fifo_skb")) {
839                 pr_debug("loopback mode=lo_mode_fifo_skb enabled");
840                 kni_net_rx_func = kni_net_rx_lo_fifo_skb;
841         } else {
842                 pr_debug("Unknown loopback parameter, disabled");
843         }
844 }