From fc66207b5913bfafe45bde6d597e9902163ca147 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 2 Feb 2019 08:01:01 +1100 Subject: [PATCH] Add script/mmap-ring-buffer.c --- script/mmap-ring-buffer.c | 129 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 script/mmap-ring-buffer.c diff --git a/script/mmap-ring-buffer.c b/script/mmap-ring-buffer.c new file mode 100644 index 00000000..91fa02b8 --- /dev/null +++ b/script/mmap-ring-buffer.c @@ -0,0 +1,129 @@ +// Copyright 2019 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// ---------------- + +// This program demonstrates mmap'ing a ring-buffer's N bytes of physical +// memory three times, to be a contiguous block of 3*N bytes. The three +// pointers (base + 0*N + i), (base + 1*N + i) and (base + 2*N + i), which are +// different addresses in virtual memory, all alias the same physical address. +// +// Reading or writing a chunk of length M <= N is therefore a simple memcpy, +// without having to explicitly wrap around the ring-buffer boundaries. +// +// This is similar to the technique discussed in +// https://lo.calho.st/quick-hacks/employing-black-magic-in-the-linux-page-table/ +// +// This program differs from that web page's discussion by mapping the physical +// memory three times, not just two. This lets us read or write, implicitly +// wrapping, both forwards (after the middle mapping's end) and backwards +// (before the middle mapping's start). That web page only considers forwards +// reads or writes. Backwards reads are useful when decoding a Lempel-Ziv style +// compression format, copying from history (recently decoded bytes). +// +// Its output should be: +// +// middle[-8] == 0x00 == 0x00 == middle[131064] +// middle[-7] == 0x00 == 0x00 == middle[131065] +// middle[-6] == 0x00 == 0x00 == middle[131066] +// middle[-5] == 0x00 == 0x00 == middle[131067] +// middle[-4] == 0x00 == 0x00 == middle[131068] +// middle[-3] == 0x00 == 0x00 == middle[131069] +// middle[-2] == 0x20 == 0x20 == middle[131070] +// middle[-1] == 0x21 == 0x21 == middle[131071] +// middle[ 0] == 0x22 == 0x22 == middle[131072] +// middle[ 1] == 0x23 == 0x23 == middle[131073] +// middle[ 2] == 0x12 == 0x12 == middle[131074] +// middle[ 3] == 0x13 == 0x13 == middle[131075] +// middle[ 4] == 0x30 == 0x30 == middle[131076] +// middle[ 5] == 0x31 == 0x31 == middle[131077] +// middle[ 6] == 0x32 == 0x32 == middle[131078] +// middle[ 7] == 0x17 == 0x17 == middle[131079] + +#include +#include +#include +#include +#include + +// We should be able to do: +// +// #include +// +// but for some reason, this hits "No such file or directory" on Ubuntu 18.04 +// (linux 4.15, glibc 2.27). Instead, we explicitly declare this function +// signature, copy/pasted from "man memfd_create". +int memfd_create(const char* name, unsigned int flags); + +#define N (128 * 1024) + +void* make_ring_buffer() { + int page_size = getpagesize(); + if ((N < page_size) || (page_size <= 0) || ((N % page_size) != 0)) { + return NULL; + } + + int memfd = memfd_create("ring", 0); + if (memfd == -1) { + return NULL; + } + if (ftruncate(memfd, N) == -1) { + return NULL; + } + + // Have the kernel find a contiguous range of unused address space. + void* base = mmap(NULL, 3 * N, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); + if (base == MAP_FAILED) { + return NULL; + } + + // Map that "ring" file 3 times, filling that range exactly. + for (int i = 0; i < 3; i++) { + void* p = mmap(base + (i * N), N, PROT_READ | PROT_WRITE, + MAP_FIXED | MAP_SHARED, memfd, 0); + if (p == MAP_FAILED) { + return NULL; + } + } + + close(memfd); + return base; +} + +int main(int argc, char** argv) { + uint8_t* base = make_ring_buffer(); + if (!base) { + fprintf(stderr, "could not make ring buffer\n"); + return 1; + } + + for (int i = 0; i < 8; i++) { + base[i] = 0x10 + i; + } + + memcpy(base + N - 2, "\x20\x21\x22\x23", 4); + + base[(0 * N) + 4] = 0x30; + base[(1 * N) + 5] = 0x31; + base[(2 * N) + 6] = 0x32; + + uint8_t* middle = base + N; + for (int i = -8; i < 8; i++) { + int j = N + i; + printf("middle[%2d] == 0x%02X == 0x%02X == middle[%6d]\n", i, + middle[i], middle[j], j); + } + + return 0; +}