src/ring.h

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2009, 2010 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #ifndef RING_H
   9 #define RING_H
  10
  11 /*
  12  * "I love the smell of 10GbE in the morning. Smells like ... victory."
  13  *     - W. Richard Stevens, "Secret Teachings of the UNIX Environment"
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdint.h>
  18 #include <linux/if_packet.h>
  19 #include <string.h>
  20 #include <poll.h>
  21 #include <sys/poll.h>
  22
  23 #include "xsys.h"
  24 #include "built_in.h"
  25 #include "mtrand.h"
  26 #include "die.h"
  27
  28 #ifndef PACKET_FANOUT
  29 # define PACKET_FANOUT                  18
  30 # define PACKET_FANOUT_POLICY_HASH      0
  31 # define PACKET_FANOUT_POLICY_LB        1
  32 # define PACKET_FANOUT_POLICY_DEFAULT   PACKET_FANOUT_HASH
  33 #endif
  34
  35 struct frame_map {
  36         struct tpacket_hdr tp_h __aligned_tpacket;
  37         struct sockaddr_ll s_ll __aligned_tpacket;
  38 };
  39
  40 struct ring {
  41         struct iovec *frames __cacheline_aligned;
  42         uint8_t *mm_space __cacheline_aligned;
  43         size_t mm_len;
  44         struct tpacket_req layout;
  45         struct sockaddr_ll s_ll;
  46 };
  47
  48 static inline void next_slot(unsigned int *it, struct ring *ring)
  49 {
  50         (*it)++;
  51         atomic_cmp_swp(it, ring->layout.tp_frame_nr, 0);
  52 }
  53
  54 static inline void next_slot_prerd(unsigned int *it, struct ring *ring)
  55 {
  56         (*it)++;
  57         atomic_cmp_swp(it, ring->layout.tp_frame_nr, 0);
  58         prefetch_rd_hi(ring->frames[*it].iov_base);
  59 }
  60
  61 static inline void next_slot_prewr(unsigned int *it, struct ring *ring)
  62 {
  63         (*it)++;
  64         atomic_cmp_swp(it, ring->layout.tp_frame_nr, 0);
  65         prefetch_wr_hi(ring->frames[*it].iov_base);
  66 }
  67
  68 static inline void next_rnd_slot(unsigned int *it, struct ring *ring)
  69 {
  70         *it = mt_rand_int32() % ring->layout.tp_frame_nr;
  71 }
  72
  73 #define RING_SIZE_FALLBACK (1 << 26)
  74
  75 static inline unsigned int ring_size(char *ifname, unsigned int size)
  76 {
  77         if (size > 0)
  78                 return size;
  79
  80         /*
  81          * Device bitrate in bytes times two as ring size.
  82          *    Fallback => ~    64,00 MB
  83          *     10 MBit => ~     2,38 MB
  84          *     54 MBit => ~    12,88 MB
  85          *    100 MBit => ~    23,84 MB
  86          *    300 MBit => ~    71,52 MB
  87          *  1.000 MBit => ~   238,42 MB
  88          * 10.000 MBit => ~ 2.384.18 MB
  89          */
  90         size = device_bitrate(ifname);
  91         size = (size * 1000000) / 8;
  92         size = size * 2;
  93         if (size == 0)
  94                 size = RING_SIZE_FALLBACK;
  95         return round_up_cacheline(size);
  96 }
  97
  98 enum ring_mode {
  99         RING_MODE_EGRESS,
 100         RING_MODE_INGRESS,
 101 };
 102
 103 static inline unsigned int ring_frame_size(struct ring *ring)
 104 {
 105         return ring->layout.tp_frame_size;
 106 }
 107
 108 static inline void tpacket_hdr_clone(struct tpacket_hdr *thdrd,
 109                                      struct tpacket_hdr *thdrs)
 110 {
 111         thdrd->tp_sec = thdrs->tp_sec;
 112         thdrd->tp_usec = thdrs->tp_usec;
 113         thdrd->tp_snaplen = thdrs->tp_snaplen;
 114         thdrd->tp_len = thdrs->tp_len;
 115 }
 116
 117 #ifndef POLLRDNORM
 118 # define POLLRDNORM     0x0040
 119 #endif
 120 #ifndef POLLWRNORM
 121 # define POLLWRNORM     0x0100
 122 #endif
 123 #ifndef POLLRDHUP
 124 # define POLLRDHUP      0x2000
 125 #endif
 126
 127 #define POLL_NEXT_PKT   0
 128 #define POLL_MOVE_OUT   1
 129
 130 static inline void prepare_polling(int sock, struct pollfd *pfd)
 131 {
 132         memset(pfd, 0, sizeof(*pfd));
 133         pfd->fd = sock;
 134         pfd->revents = 0;
 135         pfd->events = POLLIN | POLLRDNORM | POLLERR;
 136 }
 137
 138 static inline void set_sockopt_fanout(int sock, unsigned int fanout_id,
 139                                       unsigned int fanout_type)
 140 {
 141         unsigned int fanout_arg = (fanout_id | (fanout_type << 16));
 142         int ret = setsockopt(sock, SOL_PACKET, PACKET_FANOUT, &fanout_arg,
 143                              sizeof(fanout_arg));
 144         if (ret)
 145                 panic("No packet fanout support!\n");
 146 }
 147
 148 #endif /* RING_H */