drivers/net/kineto_gan.c

   1 /*
   2  *      kineto_gan.c
   3  *
   4  * Linux loadable kernel module to implement a virtual ethernet interfacesupport the Kineto GAN client.
   5  */
   6 #include <linux/module.h>
   7 #include <linux/kernel.h>
   8 #include <linux/string.h>
   9 #include <linux/delay.h>
  10 #include <linux/errno.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/init.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/ip.h>          /* struct iphdr */
  16 #include <linux/tcp.h>         /* struct tcphdr */
  17
  18 #include <linux/skbuff.h>
  19 #include <linux/wakelock.h>
  20 #include <linux/net.h>
  21 #include    <linux/socket.h>
  22
  23
  24 #include <linux/init.h>
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 /* For socket etc */
  28 #include <linux/net.h>
  29 #include <net/sock.h>
  30 #include <linux/tcp.h>
  31 #include <linux/in.h>
  32 #include <linux/uaccess.h>
  33 #include <linux/file.h>
  34 #include <linux/socket.h>
  35 #include <linux/smp_lock.h>
  36 #include <linux/slab.h>
  37 #include <linux/kthread.h>
  38
  39 #include <linux/if_arp.h>
  40
  41 #define MODULE_NAME "gannet"
  42
  43 #define KINETO_VIF_LINK_PORT    13010
  44 #define KINETO_PS_PORT_2        13001
  45
  46 struct gannet_private {
  47     struct net_device_stats stats;
  48     struct sockaddr_in tx_addr;
  49     struct sockaddr_in rx_addr;
  50     struct socket *tx_sock;
  51     struct socket *rx_sock;
  52 };
  53
  54 struct gannet_thread {
  55     struct task_struct *thread;
  56     struct net_device *dev;
  57     struct gannet_private *priv;
  58 };
  59 static struct gannet_thread *gthread;
  60 static struct net_device *gdev;
  61 static int gthreadquit;
  62
  63 static int count_this_packet(void *_hdr, int len)
  64 {
  65     struct ethhdr *hdr = _hdr;
  66
  67     if (len >= ETH_HLEN && hdr->h_proto == htons(ETH_P_ARP))
  68         return 0;
  69
  70     return 1;
  71 }
  72
  73 static int gannet_open(struct net_device *dev)
  74 {
  75     printk(KERN_DEBUG "gannet_open()\n");
  76     netif_start_queue(dev);
  77     return 0;
  78 }
  79
  80 static int gannet_stop(struct net_device *dev)
  81 {
  82     printk(KERN_DEBUG "gannet_stop()\n");
  83     netif_stop_queue(dev);
  84     return 0;
  85 }
  86
  87
  88 static int ksocket_sendto(struct socket *sock,
  89               struct sockaddr_in *addr,
  90               unsigned char *buf,
  91               int len)
  92 {
  93     struct msghdr msg;
  94     struct iovec iov;
  95     mm_segment_t oldfs;
  96     int size = 0;
  97
  98     if (sock->sk == NULL)
  99         return 0;
 100
 101     iov.iov_base = buf;
 102     iov.iov_len = len;
 103
 104     msg.msg_flags = 0;
 105     msg.msg_name = addr;
 106     msg.msg_namelen  = sizeof(struct sockaddr_in);
 107     msg.msg_control = NULL;
 108     msg.msg_controllen = 0;
 109     msg.msg_iov = &iov;
 110     msg.msg_iovlen = 1;
 111     msg.msg_control = NULL;
 112
 113     oldfs = get_fs();
 114     set_fs(KERNEL_DS);
 115     size = sock_sendmsg(sock, &msg, len);
 116     set_fs(oldfs);
 117
 118     return size;
 119 }
 120
 121 static int gannet_xmit(struct sk_buff *skb, struct net_device *dev)
 122 {
 123     /* write skb->data of skb->len to udp socket */
 124     struct gannet_private *p = netdev_priv(dev);
 125     char *data;
 126     int len;
 127
 128
 129     /*
 130     if(skb->protocol != ETH_P_IP)
 131     {
 132         pr_info("dropping packet, not IP");
 133         dev_kfree_skb_irq(skb);
 134         return NET_XMIT_DROP;
 135     }
 136     */
 137     if (NULL == ipip_hdr(skb)) {
 138         printk(KERN_WARNING "dropping packet, no IP header\n");
 139         dev_kfree_skb_irq(skb);
 140         return NET_XMIT_DROP;
 141     }
 142
 143     data = skb->data;
 144     len = skb->len;
 145
 146     if (len < (sizeof(struct ethhdr) + sizeof(struct iphdr))) {
 147         printk(KERN_WARNING "gannet: Packet too short (%i bytes)\n",
 148                                     len);
 149              return 0;
 150     }
 151
 152     /* Remove ethernet header */
 153     data += 14;
 154     len -= 14;
 155
 156     if (len != ksocket_sendto(p->tx_sock, &p->tx_addr, data, len)) {
 157         printk(KERN_ERR "gannet sendto() failed, dropping packet\n");
 158     } else {
 159         if (count_this_packet(data, len)) {
 160                 p->stats.tx_packets++;
 161                 p->stats.tx_bytes += len;
 162         }
 163     }
 164
 165     dev_kfree_skb_irq(skb);
 166     return 0;
 167 }
 168
 169 static struct net_device_stats *gannet_get_stats(struct net_device *dev)
 170 {
 171     struct gannet_private *p = netdev_priv(dev);
 172     return &p->stats;
 173 }
 174
 175 static void gannet_set_multicast_list(struct net_device *dev)
 176 {
 177 }
 178
 179 static void gannet_tx_timeout(struct net_device *dev)
 180 {
 181     printk(KERN_DEBUG "gannet_tx_timeout()\n");
 182 }
 183
 184 static int ksocket_receive(struct socket *sock,
 185                struct sockaddr_in *addr,
 186                unsigned char *buf,
 187                int len)
 188 {
 189         struct msghdr msg;
 190         struct iovec iov;
 191         mm_segment_t oldfs;
 192         int size = 0;
 193
 194     if (sock->sk == NULL)
 195         return 0;
 196
 197         iov.iov_base = buf;
 198         iov.iov_len = len;
 199
 200         msg.msg_flags = 0;
 201         msg.msg_name = addr;
 202         msg.msg_namelen  = sizeof(struct sockaddr_in);
 203         msg.msg_control = NULL;
 204         msg.msg_controllen = 0;
 205         msg.msg_iov = &iov;
 206         msg.msg_iovlen = 1;
 207         msg.msg_control = NULL;
 208
 209         oldfs = get_fs();
 210         set_fs(KERNEL_DS);
 211         size = sock_recvmsg(sock, &msg, len, msg.msg_flags);
 212         set_fs(oldfs);
 213
 214         return size;
 215 }
 216
 217
 218
 219 static void rx(unsigned char *buf, int len)
 220 {
 221     struct sk_buff *skb;
 222     void *ptr = 0;
 223     int sz;
 224     int r;
 225
 226     sz = len;
 227
 228     if (sz > 1514) {
 229         printk(KERN_ERR MODULE_NAME " discarding %d len\n", sz);
 230         ptr = 0;
 231     } else {
 232         skb = dev_alloc_skb(sz + 14 + NET_IP_ALIGN);
 233         if (skb == NULL) {
 234                 printk(KERN_ERR MODULE_NAME " cannot allocate skb\n");
 235         } else {
 236                 skb_reserve(skb, NET_IP_ALIGN);
 237
 238                 ptr = skb_put(skb, 14); /* ethernet hdr */
 239                 memcpy(&((unsigned char *)ptr)[6],
 240                         gthread->dev->dev_addr,
 241                         6);
 242
 243                 ptr = skb_put(skb, sz);
 244                 memcpy(ptr, buf, sz);
 245
 246                 skb->dev = gthread->dev;
 247                 skb->protocol = eth_type_trans(skb, gthread->dev);
 248                 skb->protocol = htons(ETH_P_IP);
 249                 skb->ip_summed = CHECKSUM_NONE; /* check it */
 250
 251                 skb->pkt_type = PACKET_HOST;
 252
 253                 if (count_this_packet(ptr, skb->len)) {
 254                         gthread->priv->stats.rx_packets++;
 255                         gthread->priv->stats.rx_bytes += skb->len;
 256                 }
 257                 r = netif_rx(skb);
 258         }
 259     }
 260 }
 261
 262
 263 static void gannet_recvloop(void)
 264 {
 265     int size;
 266     int bufsize = 1600;
 267     unsigned char buf[bufsize+1];
 268
 269     /* kernel thread initialization */
 270     lock_kernel();
 271
 272     current->flags |= PF_NOFREEZE;
 273
 274     /* daemonize (take care with signals, after daemonize they are disabled) */
 275     daemonize(MODULE_NAME);
 276     allow_signal(SIGKILL);
 277     unlock_kernel();
 278
 279
 280     /* main loop */
 281     while (!gthreadquit) {
 282         memset(&buf, 0, bufsize+1);
 283         size = ksocket_receive(gthread->priv->rx_sock,
 284                        &gthread->priv->rx_addr,
 285                        buf,
 286                        bufsize);
 287
 288         if (signal_pending(current))
 289                 break;
 290
 291         if (size < 0) {
 292                 printk(KERN_ERR MODULE_NAME": error getting datagram, "
 293                        "sock_recvmsg error = %d\n", size);
 294         } else {
 295                 /* send to kernel */
 296                 rx(buf, size);
 297         }
 298     }
 299
 300     printk(KERN_INFO "gannet thread exit\n");
 301 }
 302
 303
 304
 305 static const struct net_device_ops gannet_netdev_ops = {
 306     .ndo_open = gannet_open,
 307     .ndo_stop = gannet_stop,
 308     .ndo_start_xmit = gannet_xmit,
 309     .ndo_get_stats = gannet_get_stats,
 310     .ndo_set_multicast_list = gannet_set_multicast_list,
 311     .ndo_tx_timeout = gannet_tx_timeout,
 312     .ndo_change_mtu = NULL,
 313 };
 314
 315 static void __init gannet_setup(struct net_device *dev)
 316 {
 317     printk(KERN_INFO "gannet_setup\n");
 318
 319     ether_setup(dev);
 320
 321     dev->mtu = 1320;
 322 /*
 323     dev->open = gannet_open;
 324     dev->stop = gannet_stop;
 325     dev->hard_start_xmit = gannet_xmit;
 326     dev->get_stats = gannet_get_stats;
 327     dev->set_multicast_list = gannet_set_multicast_list;
 328     dev->tx_timeout = gannet_tx_timeout;
 329  */
 330     dev->netdev_ops = &gannet_netdev_ops;
 331     /* The minimum time (in jiffies) that should pass before the networking
 332      * layer decides that a transmission timeout has occurred and calls the
 333      * driver's tx_time-out function.
 334      */
 335     dev->watchdog_timeo = 200;
 336
 337     /* keep the default flags, just add NOARP */
 338     dev->flags           |= IFF_NOARP;
 339
 340     random_ether_addr(dev->dev_addr);
 341
 342     netif_start_queue(dev);
 343 }
 344
 345 static int __init gannet_init(void)
 346 {
 347     int ret;
 348     struct net_device *dev;
 349     struct gannet_private *p;
 350
 351     dev = alloc_netdev(sizeof(struct gannet_private),
 352                 "gannet%d",
 353                 gannet_setup);
 354     if (NULL == dev)
 355         return -ENOMEM;
 356
 357     ret = register_netdev(dev);
 358     if (ret) {
 359         printk(KERN_ERR "gannet failed to register netdev\n");
 360         free_netdev(dev);
 361         return ret;
 362     }
 363
 364     gdev = dev;
 365     p = netdev_priv(dev);
 366
 367     /* Create tx socket */
 368     ret = sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &p->tx_sock);
 369     if (ret < 0) {
 370         printk(KERN_ERR "gannet tx socket() failed, failing init.\n");
 371         unregister_netdev(dev);
 372         free_netdev(dev);
 373         return -EIO; /* I/O error */
 374     }
 375     memset(&p->tx_addr, 0, sizeof(p->tx_addr));
 376     p->tx_addr.sin_family = AF_INET;
 377     p->tx_addr.sin_port = htons(KINETO_PS_PORT_2);
 378     p->tx_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 379
 380     /* Create rx socket */
 381     ret = sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &p->rx_sock);
 382     if (ret < 0) {
 383         printk(KERN_ERR "gannet rx socket() failed, failing init.\n");
 384         sock_release(p->tx_sock);
 385         unregister_netdev(dev);
 386         free_netdev(dev);
 387         return -EIO; /* I/O error? There's nothing more applicable. */
 388     }
 389     memset(&p->rx_addr, 0, sizeof(p->rx_addr));
 390     p->rx_addr.sin_family = AF_INET;
 391     p->rx_addr.sin_port = htons(KINETO_VIF_LINK_PORT);
 392     p->rx_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* INADDR_LOOPBACK
 393                                                         for security? */
 394
 395     /* Bind rx socket */
 396     ret = p->rx_sock->ops->bind(p->rx_sock,
 397                     (struct sockaddr *)&p->rx_addr,
 398                     sizeof(struct sockaddr));
 399     if (ret < 0) {
 400         printk(KERN_ERR "gannet rx socket() bind failed.\n");
 401         sock_release(p->tx_sock);
 402         sock_release(p->rx_sock);
 403         unregister_netdev(dev);
 404         free_netdev(dev);
 405         return -EIO; /* I/O error */
 406     }
 407
 408
 409     /* Create kernel thread for rx loop */
 410     gthread = kmalloc(sizeof(struct gannet_thread), GFP_KERNEL);
 411     memset(gthread, 0, sizeof(struct gannet_thread));
 412
 413     /* Store ref to private info */
 414     gthread->dev = dev;
 415     gthread->priv = p;
 416
 417     printk(KERN_INFO "gannet starting kernel thread\n");
 418     gthread->thread = kthread_run((void *)gannet_recvloop,
 419                       NULL,
 420                       MODULE_NAME);
 421     if (IS_ERR(gthread->thread)) {
 422         printk(KERN_ERR MODULE_NAME": unable to start kernel thread\n");
 423             sock_release(p->tx_sock);
 424             sock_release(p->rx_sock);
 425             free_netdev(dev);
 426             kfree(gthread);
 427             gthread = NULL;
 428             return -ENOMEM;
 429     }
 430     printk(KERN_INFO "gannet initialized OK\n");
 431
 432     return 0;
 433 }
 434
 435 static void __exit gannet_exit(void)
 436 {
 437     gthreadquit = 1;
 438     if (NULL != gdev) {
 439         struct gannet_private *p = netdev_priv(gdev);
 440
 441         sock_release(p->rx_sock);
 442         sock_release(p->tx_sock);
 443         unregister_netdev(gdev);
 444         free_netdev(gdev);
 445     }
 446 }
 447
 448 module_init(gannet_init);
 449 module_exit(gannet_exit);
 450
 451 MODULE_DESCRIPTION("Kineto GAN Virtual Ethernet Device");
 452 MODULE_ALIAS("gannet");
 453 MODULE_LICENSE("Proprietary");
 454 MODULE_AUTHOR("Jon Read <jread@kineto.com>");
 455 MODULE_VERSION("1.0");