Attachment 180808 Details for Bug 217138 – C source for showing fork/swap memory corruption failure

C source for showing fork/swap memory corruption failure

file_217138.txt (text/plain), 3.12 KB, created by Mark Millard on 2017-03-14 08:23:26 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mark Millard

Created: 2017-03-14 08:23:26 UTC

Size: 3.12 KB

patch

obsolete

>// 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.
>
>int main(void)
>{
>    test_setup();
>    test_check(); // This test passes.
>
>    pid_t pid = fork();
>    int wait_status = 0;;
>
>    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.
>        }
>
>        test_check();
>    }
>}
>
>// 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 (14u*1024u)
>                        // Bad dyn_region pattern, parent and child
>                        // processes:
>                        //  256u, 4u*1024u, 8u*1024u, 9u*1024u,
>                        // 12u*1024u, 14u*1024u
>
>                        // 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; }
>
>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);
>    }
>}
>
>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).
>}

Actions: View

Attachments on bug 217138: 180808 | 180836 | 181044 | 181258 | 181498