/* -*- mode:C; c-file-style: "bsd" -*- */
/*
*
* Copyright (c) 2014 NORDUnet A/S
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* 3. Neither the name of the NORDUnet nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Author: Fredrik Thulin <fredrik@thulin.net>
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
/* XXX should runtime check if this is a little-endian system already */
#define SWAP_UINT32(x) (((x) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | ((x) << 24))
#define INPUT_BLOCK_SIZE 1024
#define SYNC_BYTE 0xf0
#define NUM_SYNC_BYTES 16
enum {
mode_random = 0,
mode_random_VN,
mode_deltas,
};
const char *usage =
"This program parses the output of MODE_DELTAS in the STM32 code.\n"
"\n"
"Usage: delta16 [options] [infile] [outfile]\n"
"\n"
"Options:\n"
" -V von Neumann de-biased random bytes output\n"
" -D counter delta output\n"
" -v verbose\n"
" -d debug\n"
" -f force overwriting of existing output file\n"
""
"\n"
;
const char *optstring = "VDvfd";
int
parse_args(int argc, char **argv,
int *mode,
char **infile,
char **outfile,
int *verbose,
int *force,
int *debug,
int *exit_code)
{
int c, V = 0, D = 0;
while((c = getopt(argc, argv, optstring)) != -1) {
switch (c) {
case 'V':
V = 1;
break;
case 'D':
D = 1;
break;
case 'v':
*verbose = 1;
break;
case 'f':
*force = 1;
break;
case 'd':
*debug = 1;
break;
default:
fputs(usage, stderr);
*exit_code = 0;
return 0;
}
}
*mode = mode_random;
if (V && D) {
fprintf(stderr, "Options -V and -D can't be combined\n");
return 0;
}
if (V) {
*mode = mode_random_VN;
}
if (D) {
*mode = mode_deltas;
}
*infile = "-";
*outfile = "-";
if (optind < argc) {
*infile = argv[optind++];
}
if (optind < argc) {
*outfile = argv[optind++];
}
return 1;
}
int
find_input_sync_position(FILE *in, const int verbose)
{
int pos = 0;
int match = 0;
uint8_t ch;
while (pos++ < 4096) {
if (! fread(&ch, 1, 1, in)) {
return 0;
}
if (ch == SYNC_BYTE) {
match++;
if (match == NUM_SYNC_BYTES) {
return pos;
}
} else {
match = 0;
}
}
return -1;
}
int
fill_input_buffer(FILE *in, uint8_t *buf, size_t bufsize, int verbose, unsigned long *skipped_bytes)
{
int i;
unsigned long pos = 0, old_pos = 0;
old_pos = ftell(in);
if ((i = fread(buf, 1, bufsize, in)) != INPUT_BLOCK_SIZE) {
if (verbose) {
fprintf(stderr, "Short read, %d bytes, at position %ld / %lx\n", i, old_pos, old_pos);
}
return 2;
}
/* Expect next sync marker to immediately follow this one */
if ((i = find_input_sync_position(in, verbose)) > NUM_SYNC_BYTES) {
/*
fprintf(stderr, "SYNC: buf[0] from pos %ld / %lx was 0x%2x - sync found at + %d (now at %ld / %lx)\n",
old_pos, old_pos, buf[0], i, ftell(in), ftell(in));
*/
if (i < 0) {
fprintf(stderr, "Sync completely lost from position %ld / %lx\n", old_pos, old_pos);
return 0;
}
if (fseek(in, 0 - INPUT_BLOCK_SIZE, SEEK_CUR) < 0) {
fprintf(stderr, "Failed seeking backwards when looking for sync from position %ld / %lx\n", old_pos, old_pos);
return 0;
}
i = find_input_sync_position(in, verbose);
pos = ftell(in);
if (i < INPUT_BLOCK_SIZE - 1) {
fprintf(stderr, "Short block (%d bytes, < %d) at position %ld / %lx. Resynced at %ld / 0x%lx.\n",
i, INPUT_BLOCK_SIZE, old_pos, old_pos, pos, pos);
} else {
if (verbose) {
fprintf(stderr, "Sync lost, skipping %ld bytes from position %ld / 0x%lx. Resynced at %ld / 0x%lx.\n",
pos - old_pos,
old_pos, old_pos,
pos, pos);
}
*skipped_bytes += pos - old_pos;
return -1;
}
}
return 1;
}
inline void
output_deltas(FILE *out, uint32_t raw, unsigned long *write_count, int debug)
{
uint32_t first, second;
static uint32_t last = 0, num = 0;
first = (raw & 0xffff0000) >> 16;
second = (raw & 0x0000ffff);
if (last > first) {
/* Next batch of timer values start here */
last = 0;
num = 0;
}
/* Need to skip the first output of each batch - it's delta value is unknown */
if (num) {
fprintf(out, "%02d %04x %02x\n", num++, first, first - last);
*write_count += 1;
} else {
num++;
}
fprintf(out, "%02d %04x %02x\n", num++, second, second - first);
*write_count += 1;
last = second;
}
inline void
output_random(FILE *out, uint32_t raw, unsigned long *write_count, int debug)
{
uint32_t first, second;
static uint32_t num = 0, bits = 0, old_bits;
first = (raw & 0xffff0000) >> 16;
second = (raw & 0x0000ffff);
old_bits = bits;
bits <<= 1; bits += (first & 1);
bits <<= 1; bits += (second & 1);
num += 2;
if (debug) {
fprintf(stderr, "raw 0x%08x -> first 0x%04x second 0x%04x bits 0x%x |= %d |= %d -> 0x%x (%d bits)\n",
raw, first, second, old_bits, (first & 1), (second & 1), bits, num);
}
if (num == 32) {
if (debug) {
fprintf(stderr, "write %02x %02x %02x %02x\n",
(bits & 0xff000000) >> 24,
(bits & 0xff0000) >> 16,
(bits & 0xff00) >> 8,
bits & 0xff
);
}
fprintf(out, "%c%c%c%c",
(bits & 0xff000000) >> 24,
(bits & 0xff0000) >> 16,
(bits & 0xff00) >> 8,
bits & 0xff
);
*write_count += 4;
bits = 0;
num = 0;
}
}
inline void
output_random_VN(FILE *out, uint32_t raw, unsigned long *write_count, int debug)
{
uint32_t first, second;
static uint32_t num = 0, bits = 0, old_bits;
first = (raw & 0xffff0000) >> 16;
second = (raw & 0x0000ffff);
/* Discard both values unless their LSB is actually different.
This is the Von Neumann extractor. */
if ((first & 1) != (second & 1)) {
old_bits = bits;
bits <<= 1; bits += (first & 1);
num++;
if (debug) {
fprintf(stderr, "raw 0x%08x -> first 0x%04x second 0x%04x bits 0x%x |= %d (skip second %d)-> 0x%x (%d bits)\n",
raw, first, second, old_bits, (first & 1), (second & 1), bits, num);
}
} else if (debug) {
fprintf(stderr, "raw 0x%08x -> first 0x%04x second 0x%04x\n",
raw, first, second);
}
if (num == 32) {
fprintf(out, "%c%c%c%c",
(bits & 0xff000000) >> 24,
(bits & 0xff0000) >> 16,
(bits & 0xff00) >> 8,
bits & 0xff
);
*write_count += 4;
num = 0;
bits = 0;
}
}
int
process_data(FILE *in, FILE *out,
const int verbose,
const int debug,
const int mode,
unsigned long *skipped_bytes
)
{
unsigned long blocks = 0, skipped_blocks = 0, write_count = 0;
uint32_t i, raw = 0;
uint32_t *buf32, *buf32_end;
uint8_t buf[INPUT_BLOCK_SIZE];
if (skipped_bytes) {
skipped_blocks = 1;
}
while (1) {
if ((i = fill_input_buffer(in, buf, sizeof(buf), verbose, skipped_bytes)) != 1) {
if (i == -1) {
skipped_blocks += 1;
continue;
}
if (i == 2) {
/* short read - EOF */
unsigned long counters = (blocks * INPUT_BLOCK_SIZE / 2);
fprintf(stderr, "------ delta16 ------\n");
fprintf(stderr, "Skipped %ld blocks (%ld bytes total) because of loss of sync.\n",
skipped_blocks, *skipped_bytes);
fprintf(stderr, "Processed %ld * %d = %ld bytes (%ld MB). %ld counter values.\n",
blocks, INPUT_BLOCK_SIZE,
blocks * INPUT_BLOCK_SIZE,
blocks * INPUT_BLOCK_SIZE / 1024 / 1024,
counters
);
if (mode != mode_deltas) {
fprintf(stderr, "Output count is %ld bytes (%ld MB), %.3f counters per output value.\n",
write_count,
write_count / 1024 / 1024,
counters / (double) write_count);
}
fprintf(stderr, "------ delta16 ------\n\n");
return 1;
}
}
buf32 = (uint32_t *) buf;
buf32_end = &buf32[INPUT_BLOCK_SIZE / sizeof(buf32[0])];
while (buf32 < buf32_end) {
/* fprintf(stderr, "Read %d @%p\n", i, &buf32); */
raw = *buf32++;
switch (mode)
{
case mode_deltas:
output_deltas(out, raw, &write_count, debug);
break;;
case mode_random:
output_random(out, raw, &write_count, debug);
break;;
case mode_random_VN:
output_random_VN(out, raw, &write_count, debug);
break;;
default:
fprintf(stderr, "Mode %d output not implemented, aborting\n", mode);
return 0;
}
}
blocks++;
if (verbose && ! (blocks % 100000) && blocks) {
fprintf(stderr, "Processed %ld blocks (file position %ld / 0x%lx / %ld MB)\n",
blocks, ftell(in), ftell(in), ftell(in) / 1024 / 1024);
}
};
/* NOT REACHED */
return 0;
}
int
main(int argc, char **argv)
{
int mode, debug = 0, verbose = 0, force = 0, exit_code = 1;
unsigned long skipped_bytes = 0;
char *infile, *outfile;
FILE *in, *out;
if (! parse_args(argc, argv,
&mode,
&infile,
&outfile,
&verbose,
&force,
&debug,
&exit_code
))
goto err;
if (! strcmp(infile, "-")) {
in = stdin;
} else {
if (verbose) {
fprintf(stderr, "Opening input file '%s' for reading\n", infile);
}
if (! (in = fopen(infile, "rb"))) {
fprintf(stderr, "Failed opening input file '%s' for reading: %s\n", infile, strerror(errno));
goto err;
}
}
if ((skipped_bytes = find_input_sync_position(in, verbose)) < 0) {
fprintf(stderr, "Could not find sync sequence in input\n");
goto err;
}
if (verbose) {
fprintf(stderr, "Initial sync found at position %ld / 0x%lx\n", skipped_bytes, skipped_bytes);
}
if (! strcmp(outfile, "-")) {
out = stdout;
} else {
if (! force) {
/* Check that file does not already exist */
if (access(outfile, F_OK) == F_OK) {
fprintf(stderr, "Refusing to overwrite existing output file without -f (force)\n");
goto err;
}
}
if (verbose) {
fprintf(stderr, "Opening output file '%s' for writing\n", outfile);
}
if (! (out = fopen(outfile, "wb"))) {
fprintf(stderr, "Failed opening output file '%s' for writing: %s\n", outfile, strerror(errno));
goto err;
}
}
if (! process_data(in, out, verbose, debug, mode, &skipped_bytes)) {
fprintf(stderr, "Failed processing data\n");
goto err;
}
exit_code = 0;
err:
exit(exit_code);
}
