// swap_testing.c

// Built via (c++ was clang++ 4.0 in my case):
//
// cc -g -std=c11 -Wpedantic swap_testing.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(.)

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 each region
                                      // (gbl_region and dyn_region).

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_region).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]
    }
}

// The memory and test code follows.

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

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

#define region_size (4u*1024u+1u)
                        // Bad dyn_region pattern, 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

typedef volatile unsigned char value_type;

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

static region            gbl_region;
static region * volatile dyn_region = 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) {
    dyn_region = malloc(sizeof(region));
    if (!dyn_region) raise(SIGABRT);

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

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

static volatile bool gbl_failed = false; // Until potentially disproved
static volatile size_t gbl_pos = 0u;

static volatile bool dyn_failed = false; // Until potentially disproved
static volatile size_t dyn_pos = 0u;

void test_check(void) {
    gbl_pos = 0u;
    while (!gbl_failed && gbl_pos<region_size) {
        gbl_failed = (value(gbl_pos) != gbl_region.array[gbl_pos]);
        gbl_pos++;
    }

    dyn_pos = 0u;
    while (!dyn_failed && dyn_pos<region_size) {
        dyn_failed = (value(dyn_pos) != (*dyn_region).array[dyn_pos]);
        // Note: When the memory pattern fails this case is that
        //       records the failure.
        dyn_pos++;
    }

    if (gbl_failed) raise(SIGABRT);
    if (dyn_failed) raise(SIGABRT); // lldb reports this line for the __raise call.
                                    // when it fails (both parent and child processes).
}