src/pcap_mmap.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2011 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14 #include <sys/mman.h>
  15
  16 #include "pcap.h"
  17 #include "xio.h"
  18 #include "xsys.h"
  19 #include "locking.h"
  20 #include "built_in.h"
  21
  22 #define DEFAULT_SLOTS     1000
  23
  24 #define PAGE_SIZE         (getpagesize())
  25 #define PAGE_MASK         (~(PAGE_SIZE - 1))
  26 #define PAGE_ALIGN(addr)  (((addr) + PAGE_SIZE - 1) & PAGE_MASK)
  27
  28 static struct spinlock lock;
  29 static off_t map_size = 0;
  30 static char *pstart, *pcurr;
  31 static int jumbo_frames = 0;
  32
  33 static inline off_t get_map_size(void)
  34 {
  35         int allocsz = jumbo_frames ? 16 : 3;
  36         return PAGE_ALIGN(sizeof(struct pcap_filehdr) +
  37                           (PAGE_SIZE * allocsz) * DEFAULT_SLOTS);
  38 }
  39
  40 static int pcap_mmap_pull_file_header(int fd, uint32_t *linktype)
  41 {
  42         ssize_t ret;
  43         struct pcap_filehdr hdr;
  44
  45         ret = read(fd, &hdr, sizeof(hdr));
  46         if (unlikely(ret != sizeof(hdr)))
  47                 return -EIO;
  48
  49         pcap_validate_header(&hdr);
  50
  51         *linktype = hdr.linktype;
  52
  53         return 0;
  54 }
  55
  56 static int pcap_mmap_push_file_header(int fd, uint32_t linktype)
  57 {
  58         ssize_t ret;
  59         struct pcap_filehdr hdr;
  60
  61         fmemset(&hdr, 0, sizeof(hdr));
  62         pcap_prepare_header(&hdr, linktype, 0, PCAP_DEFAULT_SNAPSHOT_LEN);
  63
  64         ret = write_or_die(fd, &hdr, sizeof(hdr));
  65         if (unlikely(ret != sizeof(hdr))) {
  66                 whine("Failed to write pkt file header!\n");
  67                 return -EIO;
  68         }
  69
  70         return 0;
  71 }
  72
  73 static int pcap_mmap_prepare_writing_pcap(int fd)
  74 {
  75         int ret;
  76         off_t pos;
  77         struct stat sb;
  78
  79         set_ioprio_be();
  80
  81         spinlock_lock(&lock);
  82
  83         map_size = get_map_size();
  84
  85         ret = fstat(fd, &sb);
  86         if (ret < 0)
  87                 panic("Cannot fstat pcap file!\n");
  88         if (!S_ISREG (sb.st_mode))
  89                 panic("pcap dump file is not a regular file!\n");
  90
  91         pos = lseek(fd, map_size, SEEK_SET);
  92         if (pos < 0)
  93                 panic("Cannot lseek pcap file!\n");
  94
  95         ret = write_or_die(fd, "", 1);
  96         if (ret != 1)
  97                 panic("Cannot write file!\n");
  98
  99         pstart = mmap(0, map_size, PROT_WRITE, MAP_SHARED
 100                       /*| MAP_HUGETLB*/, fd, 0);
 101         if (pstart == MAP_FAILED)
 102                 panic("mmap of file failed!");
 103
 104         ret = madvise(pstart, map_size, MADV_SEQUENTIAL);
 105         if (ret < 0)
 106                 panic("Failed to give kernel mmap advise!\n");
 107
 108         pcurr = pstart + sizeof(struct pcap_filehdr);
 109
 110         spinlock_unlock(&lock);
 111
 112         return 0;
 113 }
 114
 115 static ssize_t pcap_mmap_write_pcap_pkt(int fd, struct pcap_pkthdr *hdr,
 116                                         uint8_t *packet, size_t len)
 117 {
 118         int ret;
 119         off_t pos;
 120
 121         spinlock_lock(&lock);
 122
 123         if ((off_t) (pcurr - pstart) + sizeof(*hdr) + len > map_size) {
 124                 off_t map_size_old = map_size;
 125                 off_t offset = (pcurr - pstart);
 126
 127                 map_size = PAGE_ALIGN(map_size_old * 10 / 8);
 128
 129                 pos = lseek(fd, map_size, SEEK_SET);
 130                 if (pos < 0)
 131                         panic("Cannot lseek pcap file!\n");
 132
 133                 ret = write_or_die(fd, "", 1);
 134                 if (ret != 1)
 135                         panic("Cannot write file!\n");
 136
 137                 pstart = mremap(pstart, map_size_old, map_size, MREMAP_MAYMOVE);
 138                 if (pstart == MAP_FAILED)
 139                         panic("mmap of file failed!");
 140
 141                 ret = madvise(pstart, map_size, MADV_SEQUENTIAL);
 142                 if (ret < 0)
 143                         panic("Failed to give kernel mmap advise!\n");
 144
 145                 pcurr = pstart + offset;
 146         }
 147
 148         fmemcpy(pcurr, hdr, sizeof(*hdr));
 149         pcurr += sizeof(*hdr);
 150
 151         fmemcpy(pcurr, packet, len);
 152         pcurr += len;
 153
 154         spinlock_unlock(&lock);
 155
 156         return sizeof(*hdr) + len;
 157 }
 158
 159 static int pcap_mmap_prepare_reading_pcap(int fd)
 160 {
 161         int ret;
 162         struct stat sb;
 163
 164         set_ioprio_be();
 165
 166         spinlock_lock(&lock);
 167
 168         ret = fstat(fd, &sb);
 169         if (ret < 0)
 170                 panic("Cannot fstat pcap file!\n");
 171
 172         if (!S_ISREG (sb.st_mode))
 173                 panic("pcap dump file is not a regular file!\n");
 174
 175         map_size = sb.st_size;
 176
 177         pstart = mmap(0, map_size, PROT_READ, MAP_SHARED | MAP_LOCKED
 178                       /*| MAP_HUGETLB*/, fd, 0);
 179         if (pstart == MAP_FAILED)
 180                 panic("mmap of file failed!");
 181
 182         ret = madvise(pstart, map_size, MADV_SEQUENTIAL);
 183         if (ret < 0)
 184                 panic("Failed to give kernel mmap advise!\n");
 185
 186         pcurr = pstart + sizeof(struct pcap_filehdr);
 187
 188         spinlock_unlock(&lock);
 189
 190         return 0;
 191 }
 192
 193 static ssize_t pcap_mmap_read_pcap_pkt(int fd, struct pcap_pkthdr *hdr,
 194                                        uint8_t *packet, size_t len)
 195 {
 196         ssize_t ret;
 197         spinlock_lock(&lock);
 198
 199         if (unlikely((off_t) (pcurr + sizeof(*hdr) - pstart) > map_size)) {
 200                 spinlock_unlock(&lock);
 201                 return -ENOMEM;
 202         }
 203
 204         fmemcpy(hdr, pcurr, sizeof(*hdr));
 205         pcurr += sizeof(*hdr);
 206
 207         if (unlikely((off_t) (pcurr + hdr->caplen - pstart) > map_size)) {
 208                 ret = -ENOMEM;
 209                 goto out_err;
 210         }
 211
 212         if (unlikely(hdr->caplen == 0 || hdr->caplen > len)) {
 213                 ret = -EINVAL; /* Bogus packet */
 214                 goto out_err;
 215         }
 216
 217         fmemcpy(packet, pcurr, hdr->caplen);
 218         pcurr += hdr->caplen;
 219
 220         spinlock_unlock(&lock);
 221
 222         return sizeof(*hdr) + hdr->caplen;
 223
 224 out_err:
 225         spinlock_unlock(&lock);
 226         return ret;
 227 }
 228
 229 static void pcap_mmap_fsync_pcap(int fd)
 230 {
 231         spinlock_lock(&lock);
 232
 233         msync(pstart, (off_t) (pcurr - pstart), MS_ASYNC);
 234
 235         spinlock_unlock(&lock);
 236 }
 237
 238 static void pcap_mmap_prepare_close_pcap(int fd, enum pcap_mode mode)
 239 {
 240         spinlock_lock(&lock);
 241
 242         int ret = munmap(pstart, map_size);
 243         if (ret < 0)
 244                 panic("Cannot unmap the pcap file!\n");
 245
 246         if (mode == PCAP_MODE_WRITE) {
 247                 ret = ftruncate(fd, (off_t) (pcurr - pstart));
 248                 if (ret)
 249                         panic("Cannot truncate the pcap file!\n");
 250         }
 251
 252         spinlock_unlock(&lock);
 253 }
 254
 255 struct pcap_file_ops pcap_mmap_ops __read_mostly = {
 256         .name = "mmap",
 257         .pull_file_header = pcap_mmap_pull_file_header,
 258         .push_file_header = pcap_mmap_push_file_header,
 259         .prepare_writing_pcap = pcap_mmap_prepare_writing_pcap,
 260         .write_pcap_pkt = pcap_mmap_write_pcap_pkt,
 261         .prepare_reading_pcap = pcap_mmap_prepare_reading_pcap,
 262         .read_pcap_pkt = pcap_mmap_read_pcap_pkt,
 263         .fsync_pcap = pcap_mmap_fsync_pcap,
 264         .prepare_close_pcap = pcap_mmap_prepare_close_pcap,
 265 };
 266
 267 int init_pcap_mmap(int jumbo_support)
 268 {
 269         spinlock_init(&lock);
 270
 271         jumbo_frames = jumbo_support;
 272
 273         return pcap_ops_group_register(&pcap_mmap_ops, PCAP_OPS_MMAP);
 274 }
 275
 276 void cleanup_pcap_mmap(void)
 277 {
 278         spinlock_destroy(&lock);
 279
 280         pcap_ops_group_unregister(PCAP_OPS_MMAP);
 281 }
 282