// swap_testing2.c

// Built via (c++ was clang++ 4.0 in my case):
//
// cc -g -std=c11 -Wpedantic -o swaptesting2 swap_testing2.c
// -O0 and -O2 also gets the problem.

#include <unistd.h>     // for fork(), sleep(.)
#include <sys/types.h>  // for pid_t
#include <sys/wait.h>   // for wait(.)

#include <signal.h>     // for raise(.), SIGABRT

extern void test_setup(void);         // Sets up the memory byte patterns.
extern void test_check(void);         // Tests the memory byte patterns.
extern void partial_test_check(void); // Tests just [0] of dyn_regions[0]

int main(void) {
    test_setup();
    test_check(); // Before fork() [passes]

    pid_t pid = fork();
    int wait_status = 0;;

    // After fork; before waitsleep/swap-out.

    //if (0==pid) partial_test_check();
                     // Even the above is sufficient by
                     // itself to prevent failure for
                     // region_size 1u through
                     // 4u*1024u!
                     // But 4u*1024u+1u and above fail
                     // with this access to memory.
                     // The failing test is of
                     // (*dyn_regions[0]).array[4096u].
                     // This test never fails here.

    if (0<pid) partial_test_check(); // This never prevents
                                     // later failures (and
                                     // never fails here).

    if (0<pid) { wait(&wait_status); }

    if (-1!=wait_status && 0<=pid) {
        if (0==pid) {
            sleep(60);

            // During this manually force this process to
            // swap out. I use something like:

            // stress -m 1 --vm-bytes 1800M

            // in another shell and ^C'ing it after top
            // shows the swapped status desired. 1800M
            // just happened to work on the Pine64+ 2GB
            // that I was using. I watch with top -PCwaopid .
        }

        test_check(); // After wait/sleep [fails for small-enough region_sizes]

        // raise(SIGABRT);
    }
}

// The memory and test code follows.

#include <stddef.h>     // for size_t, NULL
#include <stdlib.h>     // for malloc(.), free(.)

#define region_size (14u*1024u)
                        // Bad dyn_regions patterns, parent and child
                        // processes:
                        //     256u,  2u*1024u,  4u*1024u, 8u*1024u,
                        // 9u*1024u, 12u*1024u, 14u*1024u
                        // (but see the partial_test_check() call
                        //  notes above).

                        // Works:
                        // 14u*1024u+1u, 15u*1024u, 16u*1024u,
                        // 32u*1024u, 256u*1024u*1024u
#define num_regions (256u*1024u*1024u/region_size)

typedef volatile unsigned char value_type;

struct region_struct { value_type array[region_size]; };
typedef struct region_struct region;

static region * volatile dyn_regions[num_regions] = {NULL,};

static value_type value(size_t v) { return (value_type)((v&0xFEu)|0x1u); }
                  // value now avoids the zero value since the failures
                  // are zeros.

void test_setup(void) {
    for(size_t i=0u; i<num_regions; i++) {
        dyn_regions[i] = malloc(sizeof(region));
        if (!dyn_regions[i]) raise(SIGABRT);

        for(size_t j=0u; j<region_size; j++) {
            (*dyn_regions[i]).array[j] = value(j);
        }
    }
}

void partial_test_check(void) {
    if (value(0u)!=(*dyn_regions[0u]).array[0]) raise(SIGABRT);
}

static volatile size_t first_failure_idx = 0u;
static volatile size_t first_failure_pos = 0u;
static volatile size_t after_bad_idx   = 0u;
static volatile size_t after_bad_pos   = 0u;

void test_check(void) {
    first_failure_idx = first_failure_pos = 0u;
    while (first_failure_idx < num_regions) {
        while (  first_failure_pos < region_size
              && (  value(first_failure_pos)
                 == (*dyn_regions[first_failure_idx]).array[first_failure_pos]
                 )
              ) {
            first_failure_pos++;
        }

        if (region_size != first_failure_pos) break;

        first_failure_idx++;
        first_failure_pos = 0u;
    }

    if (num_regions == first_failure_idx) return;

    after_bad_idx = first_failure_idx;
    after_bad_pos = first_failure_pos;

    while (after_bad_idx < num_regions) {
        while (  after_bad_pos < region_size
              && (  value(after_bad_pos)
                 != (*dyn_regions[after_bad_idx]).array[after_bad_pos]
                 )
              ) {
            after_bad_pos++;
        }

        if(region_size != after_bad_pos) break;

        after_bad_idx++;
        after_bad_pos = 0u;
    }

    raise(SIGABRT);
}