ring.h

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2009, 2010 Daniel Borkmann.
   4  * Subject to the GPL, version 2.
   5  */
   6
   7 #ifndef RING_H
   8 #define RING_H
   9
  10 /*
  11  * "I love the smell of 10GbE in the morning. Smells like ... victory."
  12  *     - W. Richard Stevens, "Secret Teachings of the UNIX Environment"
  13  */
  14
  15 #include <stdio.h>
  16 #include <stdint.h>
  17 #include <linux/if_packet.h>
  18 #include <linux/socket.h>
  19 #include <linux/sockios.h>
  20 #include <sys/ioctl.h>
  21 #include <string.h>
  22 #include <poll.h>
  23 #include <sys/poll.h>
  24
  25 #include "xutils.h"
  26 #include "built_in.h"
  27 #include "die.h"
  28 #include "dev.h"
  29
  30 union tpacket_uhdr {
  31         struct tpacket_hdr  *h1;
  32         struct tpacket2_hdr *h2;
  33         struct tpacket3_hdr *h3;
  34         void *raw;
  35 };
  36
  37 struct frame_map {
  38         struct tpacket2_hdr tp_h __aligned_tpacket;
  39         struct sockaddr_ll s_ll __align_tpacket(sizeof(struct tpacket2_hdr));
  40 };
  41
  42 struct block_desc {
  43         uint32_t version;
  44         uint32_t offset_to_priv;
  45         struct tpacket_hdr_v1 h1;
  46 };
  47
  48 struct ring {
  49         struct iovec *frames;
  50         uint8_t *mm_space;
  51         size_t mm_len;
  52         struct sockaddr_ll s_ll;
  53         union {
  54                 struct tpacket_req layout;
  55                 struct tpacket_req3 layout3;
  56                 uint8_t raw;
  57         };
  58 };
  59
  60 static inline void next_rnd_slot(unsigned int *it, struct ring *ring)
  61 {
  62         *it = rand() % ring->layout.tp_frame_nr;
  63 }
  64
  65 static inline unsigned int ring_size(char *ifname, unsigned int size)
  66 {
  67         if (size > 0)
  68                 return size;
  69
  70         /*
  71          * Device bitrate in bytes times two as ring size.
  72          *    Fallback => ~    64,00 MB
  73          *     10 MBit => ~     2,38 MB
  74          *     54 MBit => ~    12,88 MB
  75          *    100 MBit => ~    23,84 MB
  76          *    300 MBit => ~    71,52 MB
  77          *  1.000 MBit => ~   238,42 MB
  78          * 10.000 MBit => ~ 2.384.18 MB
  79          */
  80         size = device_bitrate(ifname);
  81         size = (size * 1000000) / 8;
  82         size = size * 2;
  83         if (size == 0)
  84                 size = 1 << 26;
  85
  86         return round_up_cacheline(size);
  87 }
  88
  89 static inline unsigned int ring_frame_size(struct ring *ring)
  90 {
  91         return ring->layout.tp_frame_size;
  92 }
  93
  94 static inline void ring_verify_layout(struct ring *ring)
  95 {
  96         bug_on(ring->layout.tp_block_size  < ring->layout.tp_frame_size);
  97         bug_on((ring->layout.tp_block_size % ring->layout.tp_frame_size) != 0);
  98         bug_on((ring->layout.tp_block_size % getpagesize()) != 0);
  99 }
 100
 101 static inline void tpacket_hdr_clone(struct tpacket2_hdr *thdrd,
 102                                      struct tpacket2_hdr *thdrs)
 103 {
 104         thdrd->tp_sec = thdrs->tp_sec;
 105         thdrd->tp_nsec = thdrs->tp_nsec;
 106         thdrd->tp_snaplen = thdrs->tp_snaplen;
 107         thdrd->tp_len = thdrs->tp_len;
 108 }
 109
 110 static inline void prepare_polling(int sock, struct pollfd *pfd)
 111 {
 112         memset(pfd, 0, sizeof(*pfd));
 113         pfd->fd = sock;
 114         pfd->revents = 0;
 115         pfd->events = POLLIN | POLLRDNORM | POLLERR;
 116 }
 117
 118 static inline void __set_sockopt_tpacket(int sock, int val)
 119 {
 120         int ret = setsockopt(sock, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
 121         if (ret)
 122                 panic("Cannot set tpacketv2!\n");
 123 }
 124
 125 static inline int __get_sockopt_tpacket(int sock)
 126 {
 127         int val, ret;
 128         socklen_t len = sizeof(val);
 129
 130         ret = getsockopt(sock, SOL_PACKET, PACKET_VERSION, &val, &len);
 131         if (ret)
 132                 panic("Cannot get tpacket version!\n");
 133
 134         return val;
 135 }
 136
 137 static inline void set_sockopt_tpacket_v2(int sock)
 138 {
 139         __set_sockopt_tpacket(sock, TPACKET_V2);
 140 }
 141
 142 static inline void set_sockopt_tpacket_v3(int sock)
 143 {
 144         __set_sockopt_tpacket(sock, TPACKET_V3);
 145 }
 146
 147 static inline int get_sockopt_tpacket(int sock)
 148 {
 149         return __get_sockopt_tpacket(sock);
 150 }
 151
 152 extern void mmap_ring_generic(int sock, struct ring *ring);
 153 extern void alloc_ring_frames_generic(struct ring *ring, int num, size_t size);
 154 extern void bind_ring_generic(int sock, struct ring *ring, int ifindex);
 155
 156 #endif /* RING_H */