lib/librte_eal/linuxapp/kni/kni_net.c

   1 /*-
   2  * GPL LICENSE SUMMARY
   3  *
   4  *   Copyright(c) 2010-2013 Intel Corporation. All rights reserved.
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of version 2 of the GNU General Public License as
   8  *   published by the Free Software Foundation.
   9  *
  10  *   This program is distributed in the hope that it will be useful, but
  11  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *   General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18  *   The full GNU General Public License is included in this distribution
  19  *   in the file called LICENSE.GPL.
  20  *
  21  *   Contact Information:
  22  *   Intel Corporation
  23  */
  24
  25 /*
  26  * This code is inspired from the book "Linux Device Drivers" by
  27  * Alessandro Rubini and Jonathan Corbet, published by O'Reilly & Associates
  28  */
  29
  30 #include <linux/device.h>
  31 #include <linux/module.h>
  32 #include <linux/version.h>
  33 #include <linux/netdevice.h>
  34 #include <linux/etherdevice.h> /* eth_type_trans */
  35 #include <linux/skbuff.h>
  36 #include <linux/kthread.h>
  37 #include <linux/delay.h>
  38
  39 #include <rte_config.h>
  40 #include <exec-env/rte_kni_common.h>
  41 #include "kni_dev.h"
  42
  43 #define WD_TIMEOUT 5 /*jiffies */
  44
  45 #define MBUF_BURST_SZ 32
  46
  47 #define KNI_WAIT_RESPONSE_TIMEOUT 300 /* 3 seconds */
  48
  49 /* typedef for rx function */
  50 typedef void (*kni_net_rx_t)(struct kni_dev *kni);
  51
  52 static int kni_net_tx(struct sk_buff *skb, struct net_device *dev);
  53 static void kni_net_rx_normal(struct kni_dev *kni);
  54 static void kni_net_rx_lo_fifo(struct kni_dev *kni);
  55 static void kni_net_rx_lo_fifo_skb(struct kni_dev *kni);
  56 static int kni_net_process_request(struct kni_dev *kni,
  57                         struct rte_kni_request *req);
  58
  59 /* kni rx function pointer, with default to normal rx */
  60 static kni_net_rx_t kni_net_rx_func = kni_net_rx_normal;
  61
  62
  63 /**
  64  * Adds num elements into the fifo. Return the number actually written
  65  */
  66 static inline unsigned
  67 kni_fifo_put(struct rte_kni_fifo *fifo, void **data, unsigned num)
  68 {
  69         unsigned i = 0;
  70         unsigned fifo_write = fifo->write;
  71         unsigned fifo_read = fifo->read;
  72         unsigned new_write = fifo_write;
  73
  74         for (i = 0; i < num; i++) {
  75                 new_write = (new_write + 1) & (fifo->len - 1);
  76
  77                 if (new_write == fifo_read)
  78                         break;
  79                 fifo->buffer[fifo_write] = data[i];
  80                 fifo_write = new_write;
  81         }
  82         fifo->write = fifo_write;
  83         return i;
  84 }
  85
  86 /**
  87  * Get up to num elements from the fifo. Return the number actully read
  88  */
  89 static inline unsigned
  90 kni_fifo_get(struct rte_kni_fifo *fifo, void **data, unsigned num)
  91 {
  92         unsigned i = 0;
  93         unsigned new_read = fifo->read;
  94         unsigned fifo_write = fifo->write;
  95         for (i = 0; i < num; i++) {
  96                 if (new_read == fifo_write)
  97                         break;
  98
  99                 data[i] = fifo->buffer[new_read];
 100                 new_read = (new_read + 1) & (fifo->len - 1);
 101         }
 102         fifo->read = new_read;
 103         return i;
 104 }
 105
 106 /**
 107  * Get the num of elements in the fifo
 108  */
 109 static inline unsigned
 110 kni_fifo_count(struct rte_kni_fifo *fifo)
 111 {
 112         return (fifo->len + fifo->write - fifo->read) &( fifo->len - 1);
 113 }
 114
 115 /**
 116  * Get the num of available lements in the fifo
 117  */
 118 static inline unsigned
 119 kni_fifo_free_count(struct rte_kni_fifo *fifo)
 120 {
 121         return (fifo->read - fifo->write - 1) & (fifo->len - 1);
 122 }
 123
 124 /*
 125  * Open and close
 126  */
 127 static int
 128 kni_net_open(struct net_device *dev)
 129 {
 130         int ret;
 131         struct rte_kni_request req;
 132         struct kni_dev *kni = netdev_priv(dev);
 133
 134         if (kni->lad_dev)
 135                 memcpy(dev->dev_addr, kni->lad_dev->dev_addr, ETH_ALEN);
 136         else
 137                 /*
 138                  * Generate random mac address. eth_random_addr() is the newer
 139                  * version of generating mac address in linux kernel.
 140                  */
 141                 random_ether_addr(dev->dev_addr);
 142
 143         netif_start_queue(dev);
 144
 145         memset(&req, 0, sizeof(req));
 146         req.req_id = RTE_KNI_REQ_CFG_NETWORK_IF;
 147
 148         /* Setting if_up to non-zero means up */
 149         req.if_up = 1;
 150         ret = kni_net_process_request(kni, &req);
 151
 152         return (ret == 0 ? req.result : ret);
 153 }
 154
 155 static int
 156 kni_net_release(struct net_device *dev)
 157 {
 158         int ret;
 159         struct rte_kni_request req;
 160         struct kni_dev *kni = netdev_priv(dev);
 161
 162         netif_stop_queue(dev); /* can't transmit any more */
 163
 164         memset(&req, 0, sizeof(req));
 165         req.req_id = RTE_KNI_REQ_CFG_NETWORK_IF;
 166
 167         /* Setting if_up to 0 means down */
 168         req.if_up = 0;
 169         ret = kni_net_process_request(kni, &req);
 170
 171         return (ret == 0 ? req.result : ret);
 172 }
 173
 174 /*
 175  * Configuration changes (passed on by ifconfig)
 176  */
 177 static int
 178 kni_net_config(struct net_device *dev, struct ifmap *map)
 179 {
 180         if (dev->flags & IFF_UP) /* can't act on a running interface */
 181                 return -EBUSY;
 182
 183         /* ignore other fields */
 184         return 0;
 185 }
 186
 187 /*
 188  * RX: normal working mode
 189  */
 190 static void
 191 kni_net_rx_normal(struct kni_dev *kni)
 192 {
 193         unsigned ret;
 194         uint32_t len;
 195         unsigned i, num, num_rq, num_fq;
 196         struct rte_kni_mbuf *kva;
 197         struct rte_kni_mbuf *va[MBUF_BURST_SZ];
 198         void * data_kva;
 199
 200         struct sk_buff *skb;
 201         struct net_device *dev = kni->net_dev;
 202
 203         /* Get the number of entries in rx_q */
 204         num_rq = kni_fifo_count(kni->rx_q);
 205
 206         /* Get the number of free entries in free_q */
 207         num_fq = kni_fifo_free_count(kni->free_q);
 208
 209         /* Calculate the number of entries to dequeue in rx_q */
 210         num = min(num_rq, num_fq);
 211         num = min(num, (unsigned)MBUF_BURST_SZ);
 212
 213         /* Return if no entry in rx_q and no free entry in free_q */
 214         if (num == 0)
 215                 return;
 216
 217         /* Burst dequeue from rx_q */
 218         ret = kni_fifo_get(kni->rx_q, (void **)va, num);
 219         if (ret == 0)
 220                 return; /* Failing should not happen */
 221
 222         /* Transfer received packets to netif */
 223         for (i = 0; i < num; i++) {
 224                 kva = (void *)va[i] - kni->mbuf_va + kni->mbuf_kva;
 225                 len = kva->data_len;
 226                 data_kva = kva->data - kni->mbuf_va + kni->mbuf_kva;
 227
 228                 skb = dev_alloc_skb(len + 2);
 229                 if (!skb) {
 230                         KNI_ERR("Out of mem, dropping pkts\n");
 231                         /* Update statistics */
 232                         kni->stats.rx_dropped++;
 233                 }
 234                 else {
 235                         /* Align IP on 16B boundary */
 236                         skb_reserve(skb, 2);
 237                         memcpy(skb_put(skb, len), data_kva, len);
 238                         skb->dev = dev;
 239                         skb->protocol = eth_type_trans(skb, dev);
 240                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 241
 242                         /* Call netif interface */
 243                         netif_receive_skb(skb);
 244
 245                         /* Update statistics */
 246                         kni->stats.rx_bytes += len;
 247                         kni->stats.rx_packets++;
 248                 }
 249         }
 250
 251         /* Burst enqueue mbufs into free_q */
 252         ret = kni_fifo_put(kni->free_q, (void **)va, num);
 253         if (ret != num)
 254                 /* Failing should not happen */
 255                 KNI_ERR("Fail to enqueue entries into free_q\n");
 256 }
 257
 258 /*
 259  * RX: loopback with enqueue/dequeue fifos.
 260  */
 261 static void
 262 kni_net_rx_lo_fifo(struct kni_dev *kni)
 263 {
 264         unsigned ret;
 265         uint32_t len;
 266         unsigned i, num, num_rq, num_tq, num_aq, num_fq;
 267         struct rte_kni_mbuf *kva;
 268         struct rte_kni_mbuf *va[MBUF_BURST_SZ];
 269         void * data_kva;
 270
 271         struct rte_kni_mbuf *alloc_kva;
 272         struct rte_kni_mbuf *alloc_va[MBUF_BURST_SZ];
 273         void *alloc_data_kva;
 274
 275         /* Get the number of entries in rx_q */
 276         num_rq = kni_fifo_count(kni->rx_q);
 277
 278         /* Get the number of free entrie in tx_q */
 279         num_tq = kni_fifo_free_count(kni->tx_q);
 280
 281         /* Get the number of entries in alloc_q */
 282         num_aq = kni_fifo_count(kni->alloc_q);
 283
 284         /* Get the number of free entries in free_q */
 285         num_fq = kni_fifo_free_count(kni->free_q);
 286
 287         /* Calculate the number of entries to be dequeued from rx_q */
 288         num = min(num_rq, num_tq);
 289         num = min(num, num_aq);
 290         num = min(num, num_fq);
 291         num = min(num, (unsigned)MBUF_BURST_SZ);
 292
 293         /* Return if no entry to dequeue from rx_q */
 294         if (num == 0)
 295                 return;
 296
 297         /* Burst dequeue from rx_q */
 298         ret = kni_fifo_get(kni->rx_q, (void **)va, num);
 299         if (ret == 0)
 300                 return; /* Failing should not happen */
 301
 302         /* Dequeue entries from alloc_q */
 303         ret = kni_fifo_get(kni->alloc_q, (void **)alloc_va, num);
 304         if (ret) {
 305                 num = ret;
 306                 /* Copy mbufs */
 307                 for (i = 0; i < num; i++) {
 308                         kva = (void *)va[i] - kni->mbuf_va + kni->mbuf_kva;
 309                         len = kva->pkt_len;
 310                         data_kva = kva->data - kni->mbuf_va +
 311                                                 kni->mbuf_kva;
 312
 313                         alloc_kva = (void *)alloc_va[i] - kni->mbuf_va +
 314                                                         kni->mbuf_kva;
 315                         alloc_data_kva = alloc_kva->data - kni->mbuf_va +
 316                                                                 kni->mbuf_kva;
 317                         memcpy(alloc_data_kva, data_kva, len);
 318                         alloc_kva->pkt_len = len;
 319                         alloc_kva->data_len = len;
 320
 321                         kni->stats.tx_bytes += len;
 322                         kni->stats.rx_bytes += len;
 323                 }
 324
 325                 /* Burst enqueue mbufs into tx_q */
 326                 ret = kni_fifo_put(kni->tx_q, (void **)alloc_va, num);
 327                 if (ret != num)
 328                         /* Failing should not happen */
 329                         KNI_ERR("Fail to enqueue mbufs into tx_q\n");
 330         }
 331
 332         /* Burst enqueue mbufs into free_q */
 333         ret = kni_fifo_put(kni->free_q, (void **)va, num);
 334         if (ret != num)
 335                 /* Failing should not happen */
 336                 KNI_ERR("Fail to enqueue mbufs into free_q\n");
 337
 338         /**
 339          * Update statistic, and enqueue/dequeue failure is impossible,
 340          * as all queues are checked at first.
 341          */
 342         kni->stats.tx_packets += num;
 343         kni->stats.rx_packets += num;
 344 }
 345
 346 /*
 347  * RX: loopback with enqueue/dequeue fifos and sk buffer copies.
 348  */
 349 static void
 350 kni_net_rx_lo_fifo_skb(struct kni_dev *kni)
 351 {
 352         unsigned ret;
 353         uint32_t len;
 354         unsigned i, num_rq, num_fq, num;
 355         struct rte_kni_mbuf *kva;
 356         struct rte_kni_mbuf *va[MBUF_BURST_SZ];
 357         void * data_kva;
 358
 359         struct sk_buff *skb;
 360         struct net_device *dev = kni->net_dev;
 361
 362         /* Get the number of entries in rx_q */
 363         num_rq = kni_fifo_count(kni->rx_q);
 364
 365         /* Get the number of free entries in free_q */
 366         num_fq = kni_fifo_free_count(kni->free_q);
 367
 368         /* Calculate the number of entries to dequeue from rx_q */
 369         num = min(num_rq, num_fq);
 370         num = min(num, (unsigned)MBUF_BURST_SZ);
 371
 372         /* Return if no entry to dequeue from rx_q */
 373         if (num == 0)
 374                 return;
 375
 376         /* Burst dequeue mbufs from rx_q */
 377         ret = kni_fifo_get(kni->rx_q, (void **)va, num);
 378         if (ret == 0)
 379                 return;
 380
 381         /* Copy mbufs to sk buffer and then call tx interface */
 382         for (i = 0; i < num; i++) {
 383                 kva = (void *)va[i] - kni->mbuf_va + kni->mbuf_kva;
 384                 len = kva->data_len;
 385                 data_kva = kva->data - kni->mbuf_va + kni->mbuf_kva;
 386
 387                 skb = dev_alloc_skb(len + 2);
 388                 if (skb == NULL)
 389                         KNI_ERR("Out of mem, dropping pkts\n");
 390                 else {
 391                         /* Align IP on 16B boundary */
 392                         skb_reserve(skb, 2);
 393                         memcpy(skb_put(skb, len), data_kva, len);
 394                         skb->dev = dev;
 395                         skb->protocol = eth_type_trans(skb, dev);
 396                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 397                         dev_kfree_skb(skb);
 398                 }
 399
 400                 /* Simulate real usage, allocate/copy skb twice */
 401                 skb = dev_alloc_skb(len + 2);
 402                 if (skb == NULL) {
 403                         KNI_ERR("Out of mem, dropping pkts\n");
 404                         kni->stats.rx_dropped++;
 405                 }
 406                 else {
 407                         /* Align IP on 16B boundary */
 408                         skb_reserve(skb, 2);
 409                         memcpy(skb_put(skb, len), data_kva, len);
 410                         skb->dev = dev;
 411                         skb->protocol = eth_type_trans(skb, dev);
 412                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 413
 414                         kni->stats.rx_bytes += len;
 415                         kni->stats.rx_packets++;
 416
 417                         /* call tx interface */
 418                         kni_net_tx(skb, dev);
 419                 }
 420         }
 421
 422         /* enqueue all the mbufs from rx_q into free_q */
 423         ret = kni_fifo_put(kni->free_q, (void **)&va, num);
 424         if (ret != num)
 425                 /* Failing should not happen */
 426                 KNI_ERR("Fail to enqueue mbufs into free_q\n");
 427 }
 428
 429 /* rx interface */
 430 void
 431 kni_net_rx(struct kni_dev *kni)
 432 {
 433         /**
 434          * It doesn't need to check if it is NULL pointer,
 435          * as it has a default value
 436          */
 437         (*kni_net_rx_func)(kni);
 438 }
 439
 440 /*
 441  * Transmit a packet (called by the kernel)
 442  */
 443 static int
 444 kni_net_tx(struct sk_buff *skb, struct net_device *dev)
 445 {
 446         int len = 0;
 447         unsigned ret;
 448         struct kni_dev *kni = netdev_priv(dev);
 449         struct rte_kni_mbuf *pkt_kva = NULL;
 450         struct rte_kni_mbuf *pkt_va = NULL;
 451
 452         dev->trans_start = jiffies; /* save the timestamp */
 453
 454         /* Check if the length of skb is less than mbuf size */
 455         if (skb->len > kni->mbuf_size)
 456                 goto drop;
 457
 458         /**
 459          * Check if it has at least one free entry in tx_q and
 460          * one entry in alloc_q.
 461          */
 462         if (kni_fifo_free_count(kni->tx_q) == 0 ||
 463                         kni_fifo_count(kni->alloc_q) == 0) {
 464                 /**
 465                  * If no free entry in tx_q or no entry in alloc_q,
 466                  * drops skb and goes out.
 467                  */
 468                 goto drop;
 469         }
 470
 471         /* dequeue a mbuf from alloc_q */
 472         ret = kni_fifo_get(kni->alloc_q, (void **)&pkt_va, 1);
 473         if (likely(ret == 1)) {
 474                 void *data_kva;
 475
 476                 pkt_kva = (void *)pkt_va - kni->mbuf_va + kni->mbuf_kva;
 477                 data_kva = pkt_kva->data - kni->mbuf_va + kni->mbuf_kva;
 478
 479                 len = skb->len;
 480                 memcpy(data_kva, skb->data, len);
 481                 if (unlikely(len < ETH_ZLEN)) {
 482                         memset(data_kva + len, 0, ETH_ZLEN - len);
 483                         len = ETH_ZLEN;
 484                 }
 485                 pkt_kva->pkt_len = len;
 486                 pkt_kva->data_len = len;
 487
 488                 /* enqueue mbuf into tx_q */
 489                 ret = kni_fifo_put(kni->tx_q, (void **)&pkt_va, 1);
 490                 if (unlikely(ret != 1)) {
 491                         /* Failing should not happen */
 492                         KNI_ERR("Fail to enqueue mbuf into tx_q\n");
 493                         goto drop;
 494                 }
 495         } else {
 496                 /* Failing should not happen */
 497                 KNI_ERR("Fail to dequeue mbuf from alloc_q\n");
 498                 goto drop;
 499         }
 500
 501         /* Free skb and update statistics */
 502         dev_kfree_skb(skb);
 503         kni->stats.tx_bytes += len;
 504         kni->stats.tx_packets++;
 505
 506         return NETDEV_TX_OK;
 507
 508 drop:
 509         /* Free skb and update statistics */
 510         dev_kfree_skb(skb);
 511         kni->stats.tx_dropped++;
 512
 513         return NETDEV_TX_OK;
 514 }
 515
 516 /*
 517  * Deal with a transmit timeout.
 518  */
 519 static void
 520 kni_net_tx_timeout (struct net_device *dev)
 521 {
 522         struct kni_dev *kni = netdev_priv(dev);
 523
 524         KNI_DBG("Transmit timeout at %ld, latency %ld\n", jiffies,
 525                         jiffies - dev->trans_start);
 526
 527         kni->stats.tx_errors++;
 528         netif_wake_queue(dev);
 529         return;
 530 }
 531
 532 /*
 533  * Ioctl commands
 534  */
 535 static int
 536 kni_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 537 {
 538         KNI_DBG("kni_net_ioctl %d\n",
 539                 ((struct kni_dev *)netdev_priv(dev))->group_id);
 540
 541         return 0;
 542 }
 543
 544 static int
 545 kni_net_change_mtu(struct net_device *dev, int new_mtu)
 546 {
 547         int ret;
 548         struct rte_kni_request req;
 549         struct kni_dev *kni = netdev_priv(dev);
 550
 551         KNI_DBG("kni_net_change_mtu new mtu %d to be set\n", new_mtu);
 552
 553         memset(&req, 0, sizeof(req));
 554         req.req_id = RTE_KNI_REQ_CHANGE_MTU;
 555         req.new_mtu = new_mtu;
 556         ret = kni_net_process_request(kni, &req);
 557         if (ret == 0 && req.result == 0)
 558                 dev->mtu = new_mtu;
 559
 560         return (ret == 0 ? req.result : ret);
 561 }
 562
 563 /*
 564  * Checks if the user space application provided the resp message
 565  */
 566 void
 567 kni_net_poll_resp(struct kni_dev *kni)
 568 {
 569         if (kni_fifo_count(kni->resp_q))
 570                 wake_up_interruptible(&kni->wq);
 571 }
 572
 573 /*
 574  * It can be called to process the request.
 575  */
 576 static int
 577 kni_net_process_request(struct kni_dev *kni, struct rte_kni_request *req)
 578 {
 579         int ret = -1;
 580         void *resp_va;
 581         unsigned num;
 582         int ret_val;
 583
 584         if (!kni || !req) {
 585                 KNI_ERR("No kni instance or request\n");
 586                 return -EINVAL;
 587         }
 588
 589         mutex_lock(&kni->sync_lock);
 590
 591         /* Construct data */
 592         memcpy(kni->sync_kva, req, sizeof(struct rte_kni_request));
 593         num = kni_fifo_put(kni->req_q, &kni->sync_va, 1);
 594         if (num < 1) {
 595                 KNI_ERR("Cannot send to req_q\n");
 596                 ret = -EBUSY;
 597                 goto fail;
 598         }
 599
 600         ret_val = wait_event_interruptible_timeout(kni->wq,
 601                         kni_fifo_count(kni->resp_q), 3 * HZ);
 602         if (signal_pending(current) || ret_val <= 0) {
 603                 ret = -ETIME;
 604                 goto fail;
 605         }
 606         num = kni_fifo_get(kni->resp_q, (void **)&resp_va, 1);
 607         if (num != 1 || resp_va != kni->sync_va) {
 608                 /* This should never happen */
 609                 KNI_ERR("No data in resp_q\n");
 610                 ret = -ENODATA;
 611                 goto fail;
 612         }
 613
 614         memcpy(req, kni->sync_kva, sizeof(struct rte_kni_request));
 615         ret = 0;
 616
 617 fail:
 618         mutex_unlock(&kni->sync_lock);
 619         return ret;
 620 }
 621
 622 /*
 623  * Return statistics to the caller
 624  */
 625 static struct net_device_stats *
 626 kni_net_stats(struct net_device *dev)
 627 {
 628         struct kni_dev *kni = netdev_priv(dev);
 629         return &kni->stats;
 630 }
 631
 632 /*
 633  *  Fill the eth header
 634  */
 635 static int
 636 kni_net_header(struct sk_buff *skb, struct net_device *dev,
 637                 unsigned short type, const void *daddr,
 638                 const void *saddr, unsigned int len)
 639 {
 640         struct ethhdr *eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
 641
 642         memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
 643         memcpy(eth->h_dest,   daddr ? daddr : dev->dev_addr, dev->addr_len);
 644         eth->h_proto = htons(type);
 645
 646         return (dev->hard_header_len);
 647 }
 648
 649
 650 /*
 651  * Re-fill the eth header
 652  */
 653 static int
 654 kni_net_rebuild_header(struct sk_buff *skb)
 655 {
 656         struct net_device *dev = skb->dev;
 657         struct ethhdr *eth = (struct ethhdr *) skb->data;
 658
 659         memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
 660         memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
 661
 662         return 0;
 663 }
 664
 665
 666 static const struct header_ops kni_net_header_ops = {
 667         .create  = kni_net_header,
 668         .rebuild = kni_net_rebuild_header,
 669         .cache   = NULL,  /* disable caching */
 670 };
 671
 672 static const struct net_device_ops kni_net_netdev_ops = {
 673         .ndo_open = kni_net_open,
 674         .ndo_stop = kni_net_release,
 675         .ndo_set_config = kni_net_config,
 676         .ndo_start_xmit = kni_net_tx,
 677         .ndo_change_mtu = kni_net_change_mtu,
 678         .ndo_do_ioctl = kni_net_ioctl,
 679         .ndo_get_stats = kni_net_stats,
 680         .ndo_tx_timeout = kni_net_tx_timeout,
 681 };
 682
 683 void
 684 kni_net_init(struct net_device *dev)
 685 {
 686         struct kni_dev *kni = netdev_priv(dev);
 687
 688         KNI_DBG("kni_net_init\n");
 689
 690         init_waitqueue_head(&kni->wq);
 691         mutex_init(&kni->sync_lock);
 692
 693         ether_setup(dev); /* assign some of the fields */
 694         dev->netdev_ops      = &kni_net_netdev_ops;
 695         dev->header_ops      = &kni_net_header_ops;
 696         dev->watchdog_timeo = WD_TIMEOUT;
 697 }
 698
 699 void
 700 kni_net_config_lo_mode(char *lo_str)
 701 {
 702         if (!lo_str) {
 703                 KNI_PRINT("loopback disabled");
 704                 return;
 705         }
 706
 707         if (!strcmp(lo_str, "lo_mode_none"))
 708                 KNI_PRINT("loopback disabled");
 709         else if (!strcmp(lo_str, "lo_mode_fifo")) {
 710                 KNI_PRINT("loopback mode=lo_mode_fifo enabled");
 711                 kni_net_rx_func = kni_net_rx_lo_fifo;
 712         } else if (!strcmp(lo_str, "lo_mode_fifo_skb")) {
 713                 KNI_PRINT("loopback mode=lo_mode_fifo_skb enabled");
 714                 kni_net_rx_func = kni_net_rx_lo_fifo_skb;
 715         } else
 716                 KNI_PRINT("Incognizant parameter, loopback disabled");
 717 }