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