diff --git a/chacha.h b/chacha.h index 6cfb50c..81d070f 100644 --- a/chacha.h +++ b/chacha.h @@ -1,14 +1,11 @@ #ifndef CHACHA_H #define CHACHA_H -#include +#include "util.h" #define CHACHA_KEY_SIZE 32 #define CHACHA_IV_SIZE 8 -typedef uint8_t u8; -typedef uint32_t u32; - typedef struct { u32 input[16]; } chacha_ctx; diff --git a/malloc.c b/malloc.c index 3cd6c64..8346438 100644 --- a/malloc.c +++ b/malloc.c @@ -2,7 +2,6 @@ #include #include #include -#include #include #include @@ -23,8 +22,8 @@ static_assert(sizeof(void *) == 8, "64-bit only"); static_assert(!WRITE_AFTER_FREE_CHECK || ZERO_ON_FREE, "WRITE_AFTER_FREE_CHECK depends on ZERO_ON_FREE"); -// either sizeof(uint64_t) or 0 -static const size_t canary_size = SLAB_CANARY ? sizeof(uint64_t) : 0; +// either sizeof(u64) or 0 +static const size_t canary_size = SLAB_CANARY ? sizeof(u64) : 0; #define CACHELINE_SIZE 64 @@ -41,16 +40,16 @@ static union { }; struct slab_metadata { - uint64_t bitmap; + u64 bitmap; struct slab_metadata *next; struct slab_metadata *prev; - uint64_t canary_value; + u64 canary_value; }; static const size_t min_align = 16; static const size_t max_slab_size_class = 16384; -static const uint16_t size_classes[] = { +static const u16 size_classes[] = { /* 0 */ 0, /* 16 */ 16, 32, 48, 64, 80, 96, 112, 128, /* 32 */ 160, 192, 224, 256, @@ -62,7 +61,7 @@ static const uint16_t size_classes[] = { /* 2048 */ 10240, 12288, 14336, 16384 }; -static const uint16_t size_class_slots[] = { +static const u16 size_class_slots[] = { /* 0 */ 256, /* 16 */ 256, 128, 85, 64, 51, 42, 36, 64, /* 32 */ 51, 64, 54, 64, @@ -208,7 +207,7 @@ static bool get_slot(struct slab_metadata *metadata, size_t index) { return (metadata->bitmap >> index) & 1UL; } -static uint64_t get_mask(size_t slots) { +static u64 get_mask(size_t slots) { return slots < 64 ? ~0UL << slots : 0; } @@ -217,14 +216,14 @@ static size_t get_free_slot(struct random_state *rng, size_t slots, struct slab_ slots = 64; } - uint64_t masked = metadata->bitmap | get_mask(slots); + u64 masked = metadata->bitmap | get_mask(slots); if (masked == ~0UL) { fatal_error("no zero bits"); } if (SLOT_RANDOMIZE) { // randomize start location for linear search (uniform random choice is too slow) - uint64_t random_split = ~(~0UL << get_random_u16_uniform(rng, slots)); + u64 random_split = ~(~0UL << get_random_u16_uniform(rng, slots)); size_t slot = ffzl(masked | random_split); if (slot) { @@ -240,7 +239,7 @@ static bool has_free_slots(size_t slots, struct slab_metadata *metadata) { slots = 64; } - uint64_t masked = metadata->bitmap | get_mask(slots); + u64 masked = metadata->bitmap | get_mask(slots); return masked != ~0UL; } @@ -267,14 +266,14 @@ static void write_after_free_check(char *p, size_t size) { return; } - for (size_t i = 0; i < size; i += sizeof(uint64_t)) { - if (*(uint64_t *)(p + i)) { + for (size_t i = 0; i < size; i += sizeof(u64)) { + if (*(u64 *)(p + i)) { fatal_error("detected write after free"); } } } -static const uint64_t canary_mask = __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ? +static const u64 canary_mask = __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ? 0xffffffffffffff00UL : 0x00ffffffffffffffUL; @@ -441,7 +440,7 @@ static inline void deallocate_small(void *p, size_t *expected_size) { } if (canary_size) { - uint64_t canary_value; + u64 canary_value; memcpy(&canary_value, (char *)p + size - canary_size, canary_size); if (unlikely(canary_value != metadata->canary_value)) { fatal_error("canary corrupted"); diff --git a/pages.c b/pages.c index eb29256..baddde8 100644 --- a/pages.c +++ b/pages.c @@ -1,5 +1,4 @@ #include -#include #include "memory.h" #include "pages.h" diff --git a/random.c b/random.c index b966ab2..75559f8 100644 --- a/random.c +++ b/random.c @@ -36,7 +36,7 @@ static void get_random_seed(void *buf, size_t size) { } void random_state_init(struct random_state *state) { - uint8_t rnd[CHACHA_KEY_SIZE + CHACHA_IV_SIZE]; + u8 rnd[CHACHA_KEY_SIZE + CHACHA_IV_SIZE]; get_random_seed(rnd, sizeof(rnd)); chacha_keysetup(&state->ctx, rnd); chacha_ivsetup(&state->ctx, rnd + CHACHA_KEY_SIZE); @@ -55,8 +55,8 @@ static void refill(struct random_state *state) { } } -uint16_t get_random_u16(struct random_state *state) { - uint16_t value; +u16 get_random_u16(struct random_state *state) { + u16 value; size_t remaining = RANDOM_CACHE_SIZE - state->index; if (remaining < sizeof(value)) { refill(state); @@ -67,23 +67,23 @@ uint16_t get_random_u16(struct random_state *state) { } // See Fast Random Integer Generation in an Interval by Daniel Lemire -uint16_t get_random_u16_uniform(struct random_state *state, uint16_t bound) { - uint32_t random = get_random_u16(state); - uint32_t multiresult = random * bound; - uint16_t leftover = multiresult; +u16 get_random_u16_uniform(struct random_state *state, u16 bound) { + u32 random = get_random_u16(state); + u32 multiresult = random * bound; + u16 leftover = multiresult; if (leftover < bound) { - uint16_t threshold = -bound % bound; + u16 threshold = -bound % bound; while (leftover < threshold) { random = get_random_u16(state); multiresult = random * bound; - leftover = (uint16_t)multiresult; + leftover = (u16)multiresult; } } return multiresult >> 16; } -uint64_t get_random_u64(struct random_state *state) { - uint64_t value; +u64 get_random_u64(struct random_state *state) { + u64 value; size_t remaining = RANDOM_CACHE_SIZE - state->index; if (remaining < sizeof(value)) { refill(state); @@ -94,12 +94,12 @@ uint64_t get_random_u64(struct random_state *state) { } // See Fast Random Integer Generation in an Interval by Daniel Lemire -uint64_t get_random_u64_uniform(struct random_state *state, uint64_t bound) { - unsigned __int128 random = get_random_u64(state); - unsigned __int128 multiresult = random * bound; - uint64_t leftover = multiresult; +u64 get_random_u64_uniform(struct random_state *state, u64 bound) { + u128 random = get_random_u64(state); + u128 multiresult = random * bound; + u64 leftover = multiresult; if (leftover < bound) { - uint64_t threshold = -bound % bound; + u64 threshold = -bound % bound; while (leftover < threshold) { random = get_random_u64(state); multiresult = random * bound; diff --git a/random.h b/random.h index 5c2d326..30672d4 100644 --- a/random.h +++ b/random.h @@ -1,9 +1,8 @@ #ifndef RANDOM_H #define RANDOM_H -#include - #include "chacha.h" +#include "util.h" #define RANDOM_CACHE_SIZE 256ULL #define RANDOM_RESEED_SIZE 256ULL * 1024 @@ -12,13 +11,13 @@ struct random_state { size_t index; size_t reseed; chacha_ctx ctx; - uint8_t cache[RANDOM_CACHE_SIZE]; + u8 cache[RANDOM_CACHE_SIZE]; }; void random_state_init(struct random_state *state); -uint16_t get_random_u16(struct random_state *state); -uint16_t get_random_u16_uniform(struct random_state *state, uint16_t bound); -uint64_t get_random_u64(struct random_state *state); -uint64_t get_random_u64_uniform(struct random_state *state, uint64_t bound); +u16 get_random_u16(struct random_state *state); +u16 get_random_u16_uniform(struct random_state *state, u16 bound); +u64 get_random_u64(struct random_state *state); +u64 get_random_u64_uniform(struct random_state *state, u64 bound); #endif diff --git a/util.h b/util.h index a9e8932..c6951d6 100644 --- a/util.h +++ b/util.h @@ -1,6 +1,7 @@ #ifndef UTIL_H #define UTIL_H +#include #include #define likely(x) __builtin_expect(!!(x), 1) @@ -19,4 +20,10 @@ static inline int ffzl(long x) { COLD noreturn void fatal_error(const char *s); +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; +typedef unsigned __int128 u128; + #endif