NAME

       stenotype - dump raw packets to disk

SYNOPSIS

       stenotype [-qv?] [--aiops=NUM] [--blocks=NUM] [--count=NUM]
                 [--dir=STRING] [--fanout_id=NUM] [--fanout_type=NUM]
                 [--fileage_sec=NUM] [--filesize_mb=NUM] [--filter=STRING]
                 [--gid=NUM] [--iface=STRING] [--index_nicelevel=NUM] [--no_index]
                 [--no_watchdogs] [--preallocate_file_mb=NUM] [--seccomp=STRING]
                 [--threads=NUM] [--uid=NUM] [--help] [--usage]

DESCRIPTION

       Stenotype  is a mechanism for quickly dumping raw packets to disk. It aims to have a simple interface (no
       file rotation: that's left as an exercise for the reader) while being very powerful.

       stenotype uses a NIC->disk pipeline specifically designed to  provide  as  fast  an  output  to  disk  as
       possible while just using the kernel's built-in mechanisms.

       1.  NIC  ->  RAM:  stenotype  uses MMAP'd AF_PACKET with 1MB blocks and a high timeout to offload writing
           packets and deciding their layout to the kernel. The kernel packs all the packets it  can  into  1MB,
           then  lets the userspace process know there's a block available in the MMAP'd ring buffer. Nicely, it
           guarantees no overruns (packets crossing the 1MB boundary) and good alignment to memory pages.

       2.  RAM -> Disk: Since the kernel already gave us a single 1MB block of packets that's nicely aligned, we
           can  O_DIRECT  write  it straight to disk. This avoids any additional copying or kernel buffering. To
           keep sequential reads going strong, we do all disk  IO  asynchronously  via  io_submit  (which  works
           specifically  for O_DIRECT files... joy!). Since the data is being written to disk asynchronously, we
           use the time it's writing to disk to do our own in-memory processing and indexing.

       There are N (flag-specified) async IO operations available... once we've used up all N,  we  block  on  a
       used one finishing, then reuse it. The whole pipeline consists of:

              •  kernel gives userspace a 1MB block of packets

              •  userspace iterates over packets in block, updates any indexes

              •  userspace starts async IO operation to write block to disk

              •  after  N  async  IO operations are submitted, we synchronously wait for the least recent one to
                 finish.

              •  when an async IO operation finishes, we release the 1MB block back to the kernel to write  more
                 packets.

OPTIONS

       --aiops=NUM
              Max number of async IO operations

       --blocks=NUM
              Total number of blocks to use, each is 1MB

       --count=NUM
              Total number of packets to read, -1 to read forever

       --dir=STRING
              Directory to store packet files in

       --fanout_id=NUM
              If fanning out across processes, set this

       --fanout_type=NUM
              TPACKET_V3 fanout type to fanout packets

       --fileage_sec=NUM
              Files older than this many secs are rotated

       --filesize_mb=NUM
              Max file size in MB before file is rotated

       --filter=STRING
              BPF  compiled  filter used to filter which packets will be captured. This has to be a compiled BPF
              in hexadecimal, which can be obtained from a human readable filter expression using  the  provided
              compile_bpf.sh script.

       --gid=NUM
              Drop privileges to this group

       --iface=STRING
              Interface to read packets from

       --index_nicelevel=NUM
              Nice level of indexing threads

       --no_index
              Do not compute or write indexes

       --no_watchdogs
              Don't start any watchdogs

       --preallocate_file_mb=NUM
              When creating new files, preallocate to this many MB

       -q     Quiet logging.  Each -q counteracts one -v

       --seccomp=STRING
              Seccomp style, one of 'none', 'trace', 'kill'.

       --threads=NUM
              Number of parallel threads to read packets with

       --uid=NUM
              Drop privileges to this user

       -v     Verbose logging, may be given multiple times

       -?, --help
              Give this help list

       --usage
              Give a short usage message