tools/testing/selftests/powerpc/mm/tlbie_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /*
   4  * Copyright 2019, Nick Piggin, Gautham R. Shenoy, Aneesh Kumar K.V, IBM Corp.
   5  */
   6
   7 /*
   8  *
   9  * Test tlbie/mtpidr race. We have 4 threads doing flush/load/compare/store
  10  * sequence in a loop. The same threads also rung a context switch task
  11  * that does sched_yield() in loop.
  12  *
  13  * The snapshot thread mark the mmap area PROT_READ in between, make a copy
  14  * and copy it back to the original area. This helps us to detect if any
  15  * store continued to happen after we marked the memory PROT_READ.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <stdio.h>
  20 #include <sys/mman.h>
  21 #include <sys/types.h>
  22 #include <sys/wait.h>
  23 #include <sys/ipc.h>
  24 #include <sys/shm.h>
  25 #include <sys/stat.h>
  26 #include <sys/time.h>
  27 #include <linux/futex.h>
  28 #include <unistd.h>
  29 #include <asm/unistd.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <fcntl.h>
  33 #include <sched.h>
  34 #include <time.h>
  35 #include <stdarg.h>
  36 #include <sched.h>
  37 #include <pthread.h>
  38 #include <signal.h>
  39 #include <sys/prctl.h>
  40
  41 static inline void dcbf(volatile unsigned int *addr)
  42 {
  43         __asm__ __volatile__ ("dcbf %y0; sync" : : "Z"(*(unsigned char *)addr) : "memory");
  44 }
  45
  46 static void err_msg(char *msg)
  47 {
  48
  49         time_t now;
  50         time(&now);
  51         printf("=================================\n");
  52         printf("    Error: %s\n", msg);
  53         printf("    %s", ctime(&now));
  54         printf("=================================\n");
  55         exit(1);
  56 }
  57
  58 static char *map1;
  59 static char *map2;
  60 static pid_t rim_process_pid;
  61
  62 /*
  63  * A "rim-sequence" is defined to be the sequence of the following
  64  * operations performed on a memory word:
  65  *      1) FLUSH the contents of that word.
  66  *      2) LOAD the contents of that word.
  67  *      3) COMPARE the contents of that word with the content that was
  68  *                 previously stored at that word
  69  *      4) STORE new content into that word.
  70  *
  71  * The threads in this test that perform the rim-sequence are termed
  72  * as rim_threads.
  73  */
  74
  75 /*
  76  * A "corruption" is defined to be the failed COMPARE operation in a
  77  * rim-sequence.
  78  *
  79  * A rim_thread that detects a corruption informs about it to all the
  80  * other rim_threads, and the mem_snapshot thread.
  81  */
  82 static volatile unsigned int corruption_found;
  83
  84 /*
  85  * This defines the maximum number of rim_threads in this test.
  86  *
  87  * The THREAD_ID_BITS denote the number of bits required
  88  * to represent the thread_ids [0..MAX_THREADS - 1].
  89  * We are being a bit paranoid here and set it to 8 bits,
  90  * though 6 bits suffice.
  91  *
  92  */
  93 #define MAX_THREADS             64
  94 #define THREAD_ID_BITS          8
  95 #define THREAD_ID_MASK          ((1 << THREAD_ID_BITS) - 1)
  96 static unsigned int rim_thread_ids[MAX_THREADS];
  97 static pthread_t rim_threads[MAX_THREADS];
  98
  99
 100 /*
 101  * Each rim_thread works on an exclusive "chunk" of size
 102  * RIM_CHUNK_SIZE.
 103  *
 104  * The ith rim_thread works on the ith chunk.
 105  *
 106  * The ith chunk begins at
 107  * map1 + (i * RIM_CHUNK_SIZE)
 108  */
 109 #define RIM_CHUNK_SIZE          1024
 110 #define BITS_PER_BYTE           8
 111 #define WORD_SIZE               (sizeof(unsigned int))
 112 #define WORD_BITS               (WORD_SIZE * BITS_PER_BYTE)
 113 #define WORDS_PER_CHUNK         (RIM_CHUNK_SIZE/WORD_SIZE)
 114
 115 static inline char *compute_chunk_start_addr(unsigned int thread_id)
 116 {
 117         char *chunk_start;
 118
 119         chunk_start = (char *)((unsigned long)map1 +
 120                                (thread_id * RIM_CHUNK_SIZE));
 121
 122         return chunk_start;
 123 }
 124
 125 /*
 126  * The "word-offset" of a word-aligned address inside a chunk, is
 127  * defined to be the number of words that precede the address in that
 128  * chunk.
 129  *
 130  * WORD_OFFSET_BITS denote the number of bits required to represent
 131  * the word-offsets of all the word-aligned addresses of a chunk.
 132  */
 133 #define WORD_OFFSET_BITS        (__builtin_ctz(WORDS_PER_CHUNK))
 134 #define WORD_OFFSET_MASK        ((1 << WORD_OFFSET_BITS) - 1)
 135
 136 static inline unsigned int compute_word_offset(char *start, unsigned int *addr)
 137 {
 138         unsigned int delta_bytes, ret;
 139         delta_bytes = (unsigned long)addr - (unsigned long)start;
 140
 141         ret = delta_bytes/WORD_SIZE;
 142
 143         return ret;
 144 }
 145
 146 /*
 147  * A "sweep" is defined to be the sequential execution of the
 148  * rim-sequence by a rim_thread on its chunk one word at a time,
 149  * starting from the first word of its chunk and ending with the last
 150  * word of its chunk.
 151  *
 152  * Each sweep of a rim_thread is uniquely identified by a sweep_id.
 153  * SWEEP_ID_BITS denote the number of bits required to represent
 154  * the sweep_ids of rim_threads.
 155  *
 156  * As to why SWEEP_ID_BITS are computed as a function of THREAD_ID_BITS,
 157  * WORD_OFFSET_BITS, and WORD_BITS, see the "store-pattern" below.
 158  */
 159 #define SWEEP_ID_BITS           (WORD_BITS - (THREAD_ID_BITS + WORD_OFFSET_BITS))
 160 #define SWEEP_ID_MASK           ((1 << SWEEP_ID_BITS) - 1)
 161
 162 /*
 163  * A "store-pattern" is the word-pattern that is stored into a word
 164  * location in the 4)STORE step of the rim-sequence.
 165  *
 166  * In the store-pattern, we shall encode:
 167  *
 168  *      - The thread-id of the rim_thread performing the store
 169  *        (The most significant THREAD_ID_BITS)
 170  *
 171  *      - The word-offset of the address into which the store is being
 172  *        performed (The next WORD_OFFSET_BITS)
 173  *
 174  *      - The sweep_id of the current sweep in which the store is
 175  *        being performed. (The lower SWEEP_ID_BITS)
 176  *
 177  * Store Pattern: 32 bits
 178  * |------------------|--------------------|---------------------------------|
 179  * |    Thread id     |  Word offset       |         sweep_id                |
 180  * |------------------|--------------------|---------------------------------|
 181  *    THREAD_ID_BITS     WORD_OFFSET_BITS          SWEEP_ID_BITS
 182  *
 183  * In the store pattern, the (Thread-id + Word-offset) uniquely identify the
 184  * address to which the store is being performed i.e,
 185  *    address == map1 +
 186  *              (Thread-id * RIM_CHUNK_SIZE) + (Word-offset * WORD_SIZE)
 187  *
 188  * And the sweep_id in the store pattern identifies the time when the
 189  * store was performed by the rim_thread.
 190  *
 191  * We shall use this property in the 3)COMPARE step of the
 192  * rim-sequence.
 193  */
 194 #define SWEEP_ID_SHIFT  0
 195 #define WORD_OFFSET_SHIFT       (SWEEP_ID_BITS)
 196 #define THREAD_ID_SHIFT         (WORD_OFFSET_BITS + SWEEP_ID_BITS)
 197
 198 /*
 199  * Compute the store pattern for a given thread with id @tid, at
 200  * location @addr in the sweep identified by @sweep_id
 201  */
 202 static inline unsigned int compute_store_pattern(unsigned int tid,
 203                                                  unsigned int *addr,
 204                                                  unsigned int sweep_id)
 205 {
 206         unsigned int ret = 0;
 207         char *start = compute_chunk_start_addr(tid);
 208         unsigned int word_offset = compute_word_offset(start, addr);
 209
 210         ret += (tid & THREAD_ID_MASK) << THREAD_ID_SHIFT;
 211         ret += (word_offset & WORD_OFFSET_MASK) << WORD_OFFSET_SHIFT;
 212         ret += (sweep_id & SWEEP_ID_MASK) << SWEEP_ID_SHIFT;
 213         return ret;
 214 }
 215
 216 /* Extract the thread-id from the given store-pattern */
 217 static inline unsigned int extract_tid(unsigned int pattern)
 218 {
 219         unsigned int ret;
 220
 221         ret = (pattern >> THREAD_ID_SHIFT) & THREAD_ID_MASK;
 222         return ret;
 223 }
 224
 225 /* Extract the word-offset from the given store-pattern */
 226 static inline unsigned int extract_word_offset(unsigned int pattern)
 227 {
 228         unsigned int ret;
 229
 230         ret = (pattern >> WORD_OFFSET_SHIFT) & WORD_OFFSET_MASK;
 231
 232         return ret;
 233 }
 234
 235 /* Extract the sweep-id from the given store-pattern */
 236 static inline unsigned int extract_sweep_id(unsigned int pattern)
 237
 238 {
 239         unsigned int ret;
 240
 241         ret = (pattern >> SWEEP_ID_SHIFT) & SWEEP_ID_MASK;
 242
 243         return ret;
 244 }
 245
 246 /************************************************************
 247  *                                                          *
 248  *          Logging the output of the verification          *
 249  *                                                          *
 250  ************************************************************/
 251 #define LOGDIR_NAME_SIZE 100
 252 static char logdir[LOGDIR_NAME_SIZE];
 253
 254 static FILE *fp[MAX_THREADS];
 255 static const char logfilename[] ="Thread-%02d-Chunk";
 256
 257 static inline void start_verification_log(unsigned int tid,
 258                                           unsigned int *addr,
 259                                           unsigned int cur_sweep_id,
 260                                           unsigned int prev_sweep_id)
 261 {
 262         FILE *f;
 263         char logfile[30];
 264         char path[LOGDIR_NAME_SIZE + 30];
 265         char separator[2] = "/";
 266         char *chunk_start = compute_chunk_start_addr(tid);
 267         unsigned int size = RIM_CHUNK_SIZE;
 268
 269         sprintf(logfile, logfilename, tid);
 270         strcpy(path, logdir);
 271         strcat(path, separator);
 272         strcat(path, logfile);
 273         f = fopen(path, "w");
 274
 275         if (!f) {
 276                 err_msg("Unable to create logfile\n");
 277         }
 278
 279         fp[tid] = f;
 280
 281         fprintf(f, "----------------------------------------------------------\n");
 282         fprintf(f, "PID                = %d\n", rim_process_pid);
 283         fprintf(f, "Thread id          = %02d\n", tid);
 284         fprintf(f, "Chunk Start Addr   = 0x%016lx\n", (unsigned long)chunk_start);
 285         fprintf(f, "Chunk Size         = %d\n", size);
 286         fprintf(f, "Next Store Addr    = 0x%016lx\n", (unsigned long)addr);
 287         fprintf(f, "Current sweep-id   = 0x%08x\n", cur_sweep_id);
 288         fprintf(f, "Previous sweep-id  = 0x%08x\n", prev_sweep_id);
 289         fprintf(f, "----------------------------------------------------------\n");
 290 }
 291
 292 static inline void log_anamoly(unsigned int tid, unsigned int *addr,
 293                                unsigned int expected, unsigned int observed)
 294 {
 295         FILE *f = fp[tid];
 296
 297         fprintf(f, "Thread %02d: Addr 0x%lx: Expected 0x%x, Observed 0x%x\n",
 298                 tid, (unsigned long)addr, expected, observed);
 299         fprintf(f, "Thread %02d: Expected Thread id   = %02d\n", tid, extract_tid(expected));
 300         fprintf(f, "Thread %02d: Observed Thread id   = %02d\n", tid, extract_tid(observed));
 301         fprintf(f, "Thread %02d: Expected Word offset = %03d\n", tid, extract_word_offset(expected));
 302         fprintf(f, "Thread %02d: Observed Word offset = %03d\n", tid, extract_word_offset(observed));
 303         fprintf(f, "Thread %02d: Expected sweep-id    = 0x%x\n", tid, extract_sweep_id(expected));
 304         fprintf(f, "Thread %02d: Observed sweep-id    = 0x%x\n", tid, extract_sweep_id(observed));
 305         fprintf(f, "----------------------------------------------------------\n");
 306 }
 307
 308 static inline void end_verification_log(unsigned int tid, unsigned nr_anamolies)
 309 {
 310         FILE *f = fp[tid];
 311         char logfile[30];
 312         char path[LOGDIR_NAME_SIZE + 30];
 313         char separator[] = "/";
 314
 315         fclose(f);
 316
 317         if (nr_anamolies == 0) {
 318                 remove(path);
 319                 return;
 320         }
 321
 322         sprintf(logfile, logfilename, tid);
 323         strcpy(path, logdir);
 324         strcat(path, separator);
 325         strcat(path, logfile);
 326
 327         printf("Thread %02d chunk has %d corrupted words. For details check %s\n",
 328                 tid, nr_anamolies, path);
 329 }
 330
 331 /*
 332  * When a COMPARE step of a rim-sequence fails, the rim_thread informs
 333  * everyone else via the shared_memory pointed to by
 334  * corruption_found variable. On seeing this, every thread verifies the
 335  * content of its chunk as follows.
 336  *
 337  * Suppose a thread identified with @tid was about to store (but not
 338  * yet stored) to @next_store_addr in its current sweep identified
 339  * @cur_sweep_id. Let @prev_sweep_id indicate the previous sweep_id.
 340  *
 341  * This implies that for all the addresses @addr < @next_store_addr,
 342  * Thread @tid has already performed a store as part of its current
 343  * sweep. Hence we expect the content of such @addr to be:
 344  *    |-------------------------------------------------|
 345  *    | tid   | word_offset(addr) |    cur_sweep_id     |
 346  *    |-------------------------------------------------|
 347  *
 348  * Since Thread @tid is yet to perform stores on address
 349  * @next_store_addr and above, we expect the content of such an
 350  * address @addr to be:
 351  *    |-------------------------------------------------|
 352  *    | tid   | word_offset(addr) |    prev_sweep_id    |
 353  *    |-------------------------------------------------|
 354  *
 355  * The verifier function @verify_chunk does this verification and logs
 356  * any anamolies that it finds.
 357  */
 358 static void verify_chunk(unsigned int tid, unsigned int *next_store_addr,
 359                   unsigned int cur_sweep_id,
 360                   unsigned int prev_sweep_id)
 361 {
 362         unsigned int *iter_ptr;
 363         unsigned int size = RIM_CHUNK_SIZE;
 364         unsigned int expected;
 365         unsigned int observed;
 366         char *chunk_start = compute_chunk_start_addr(tid);
 367
 368         int nr_anamolies = 0;
 369
 370         start_verification_log(tid, next_store_addr,
 371                                cur_sweep_id, prev_sweep_id);
 372
 373         for (iter_ptr = (unsigned int *)chunk_start;
 374              (unsigned long)iter_ptr < (unsigned long)chunk_start + size;
 375              iter_ptr++) {
 376                 unsigned int expected_sweep_id;
 377
 378                 if (iter_ptr < next_store_addr) {
 379                         expected_sweep_id = cur_sweep_id;
 380                 } else {
 381                         expected_sweep_id = prev_sweep_id;
 382                 }
 383
 384                 expected = compute_store_pattern(tid, iter_ptr, expected_sweep_id);
 385
 386                 dcbf((volatile unsigned int*)iter_ptr); //Flush before reading
 387                 observed = *iter_ptr;
 388
 389                 if (observed != expected) {
 390                         nr_anamolies++;
 391                         log_anamoly(tid, iter_ptr, expected, observed);
 392                 }
 393         }
 394
 395         end_verification_log(tid, nr_anamolies);
 396 }
 397
 398 static void set_pthread_cpu(pthread_t th, int cpu)
 399 {
 400         cpu_set_t run_cpu_mask;
 401         struct sched_param param;
 402
 403         CPU_ZERO(&run_cpu_mask);
 404         CPU_SET(cpu, &run_cpu_mask);
 405         pthread_setaffinity_np(th, sizeof(cpu_set_t), &run_cpu_mask);
 406
 407         param.sched_priority = 1;
 408         if (0 && sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
 409                 /* haven't reproduced with this setting, it kills random preemption which may be a factor */
 410                 fprintf(stderr, "could not set SCHED_FIFO, run as root?\n");
 411         }
 412 }
 413
 414 static void set_mycpu(int cpu)
 415 {
 416         cpu_set_t run_cpu_mask;
 417         struct sched_param param;
 418
 419         CPU_ZERO(&run_cpu_mask);
 420         CPU_SET(cpu, &run_cpu_mask);
 421         sched_setaffinity(0, sizeof(cpu_set_t), &run_cpu_mask);
 422
 423         param.sched_priority = 1;
 424         if (0 && sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
 425                 fprintf(stderr, "could not set SCHED_FIFO, run as root?\n");
 426         }
 427 }
 428
 429 static volatile int segv_wait;
 430
 431 static void segv_handler(int signo, siginfo_t *info, void *extra)
 432 {
 433         while (segv_wait) {
 434                 sched_yield();
 435         }
 436
 437 }
 438
 439 static void set_segv_handler(void)
 440 {
 441         struct sigaction sa;
 442
 443         sa.sa_flags = SA_SIGINFO;
 444         sa.sa_sigaction = segv_handler;
 445
 446         if (sigaction(SIGSEGV, &sa, NULL) == -1) {
 447                 perror("sigaction");
 448                 exit(EXIT_FAILURE);
 449         }
 450 }
 451
 452 int timeout = 0;
 453 /*
 454  * This function is executed by every rim_thread.
 455  *
 456  * This function performs sweeps over the exclusive chunks of the
 457  * rim_threads executing the rim-sequence one word at a time.
 458  */
 459 static void *rim_fn(void *arg)
 460 {
 461         unsigned int tid = *((unsigned int *)arg);
 462
 463         int size = RIM_CHUNK_SIZE;
 464         char *chunk_start = compute_chunk_start_addr(tid);
 465
 466         unsigned int prev_sweep_id;
 467         unsigned int cur_sweep_id = 0;
 468
 469         /* word access */
 470         unsigned int pattern = cur_sweep_id;
 471         unsigned int *pattern_ptr = &pattern;
 472         unsigned int *w_ptr, read_data;
 473
 474         set_segv_handler();
 475
 476         /*
 477          * Let us initialize the chunk:
 478          *
 479          * Each word-aligned address addr in the chunk,
 480          * is initialized to :
 481          *    |-------------------------------------------------|
 482          *    | tid   | word_offset(addr) |         0           |
 483          *    |-------------------------------------------------|
 484          */
 485         for (w_ptr = (unsigned int *)chunk_start;
 486              (unsigned long)w_ptr < (unsigned long)(chunk_start) + size;
 487              w_ptr++) {
 488
 489                 *pattern_ptr = compute_store_pattern(tid, w_ptr, cur_sweep_id);
 490                 *w_ptr = *pattern_ptr;
 491         }
 492
 493         while (!corruption_found && !timeout) {
 494                 prev_sweep_id = cur_sweep_id;
 495                 cur_sweep_id = cur_sweep_id + 1;
 496
 497                 for (w_ptr = (unsigned int *)chunk_start;
 498                      (unsigned long)w_ptr < (unsigned long)(chunk_start) + size;
 499                      w_ptr++)  {
 500                         unsigned int old_pattern;
 501
 502                         /*
 503                          * Compute the pattern that we would have
 504                          * stored at this location in the previous
 505                          * sweep.
 506                          */
 507                         old_pattern = compute_store_pattern(tid, w_ptr, prev_sweep_id);
 508
 509                         /*
 510                          * FLUSH:Ensure that we flush the contents of
 511                          *       the cache before loading
 512                          */
 513                         dcbf((volatile unsigned int*)w_ptr); //Flush
 514
 515                         /* LOAD: Read the value */
 516                         read_data = *w_ptr; //Load
 517
 518                         /*
 519                          * COMPARE: Is it the same as what we had stored
 520                          *          in the previous sweep ? It better be!
 521                          */
 522                         if (read_data != old_pattern) {
 523                                 /* No it isn't! Tell everyone */
 524                                 corruption_found = 1;
 525                         }
 526
 527                         /*
 528                          * Before performing a store, let us check if
 529                          * any rim_thread has found a corruption.
 530                          */
 531                         if (corruption_found || timeout) {
 532                                 /*
 533                                  * Yes. Someone (including us!) has found
 534                                  * a corruption :(
 535                                  *
 536                                  * Let us verify that our chunk is
 537                                  * correct.
 538                                  */
 539                                 /* But first, let us allow the dust to settle down! */
 540                                 verify_chunk(tid, w_ptr, cur_sweep_id, prev_sweep_id);
 541
 542                                 return 0;
 543                         }
 544
 545                         /*
 546                          * Compute the new pattern that we are going
 547                          * to write to this location
 548                          */
 549                         *pattern_ptr = compute_store_pattern(tid, w_ptr, cur_sweep_id);
 550
 551                         /*
 552                          * STORE: Now let us write this pattern into
 553                          *        the location
 554                          */
 555                         *w_ptr = *pattern_ptr;
 556                 }
 557         }
 558
 559         return NULL;
 560 }
 561
 562
 563 static unsigned long start_cpu = 0;
 564 static unsigned long nrthreads = 4;
 565
 566 static pthread_t mem_snapshot_thread;
 567
 568 static void *mem_snapshot_fn(void *arg)
 569 {
 570         int page_size = getpagesize();
 571         size_t size = page_size;
 572         void *tmp = malloc(size);
 573
 574         while (!corruption_found && !timeout) {
 575                 /* Stop memory migration once corruption is found */
 576                 segv_wait = 1;
 577
 578                 mprotect(map1, size, PROT_READ);
 579
 580                 /*
 581                  * Load from the working alias (map1). Loading from map2
 582                  * also fails.
 583                  */
 584                 memcpy(tmp, map1, size);
 585
 586                 /*
 587                  * Stores must go via map2 which has write permissions, but
 588                  * the corrupted data tends to be seen in the snapshot buffer,
 589                  * so corruption does not appear to be introduced at the
 590                  * copy-back via map2 alias here.
 591                  */
 592                 memcpy(map2, tmp, size);
 593                 /*
 594                  * Before releasing other threads, must ensure the copy
 595                  * back to
 596                  */
 597                 asm volatile("sync" ::: "memory");
 598                 mprotect(map1, size, PROT_READ|PROT_WRITE);
 599                 asm volatile("sync" ::: "memory");
 600                 segv_wait = 0;
 601
 602                 usleep(1); /* This value makes a big difference */
 603         }
 604
 605         return 0;
 606 }
 607
 608 void alrm_sighandler(int sig)
 609 {
 610         timeout = 1;
 611 }
 612
 613 int main(int argc, char *argv[])
 614 {
 615         int c;
 616         int page_size = getpagesize();
 617         time_t now;
 618         int i, dir_error;
 619         pthread_attr_t attr;
 620         key_t shm_key = (key_t) getpid();
 621         int shmid, run_time = 20 * 60;
 622         struct sigaction sa_alrm;
 623
 624         snprintf(logdir, LOGDIR_NAME_SIZE,
 625                  "/tmp/logdir-%u", (unsigned int)getpid());
 626         while ((c = getopt(argc, argv, "r:hn:l:t:")) != -1) {
 627                 switch(c) {
 628                 case 'r':
 629                         start_cpu = strtoul(optarg, NULL, 10);
 630                         break;
 631                 case 'h':
 632                         printf("%s [-r <start_cpu>] [-n <nrthreads>] [-l <logdir>] [-t <timeout>]\n", argv[0]);
 633                         exit(0);
 634                         break;
 635                 case 'n':
 636                         nrthreads = strtoul(optarg, NULL, 10);
 637                         break;
 638                 case 'l':
 639                         strncpy(logdir, optarg, LOGDIR_NAME_SIZE);
 640                         break;
 641                 case 't':
 642                         run_time = strtoul(optarg, NULL, 10);
 643                         break;
 644                 default:
 645                         printf("invalid option\n");
 646                         exit(0);
 647                         break;
 648                 }
 649         }
 650
 651         if (nrthreads > MAX_THREADS)
 652                 nrthreads = MAX_THREADS;
 653
 654         shmid = shmget(shm_key, page_size, IPC_CREAT|0666);
 655         if (shmid < 0) {
 656                 err_msg("Failed shmget\n");
 657         }
 658
 659         map1 = shmat(shmid, NULL, 0);
 660         if (map1 == (void *) -1) {
 661                 err_msg("Failed shmat");
 662         }
 663
 664         map2 = shmat(shmid, NULL, 0);
 665         if (map2 == (void *) -1) {
 666                 err_msg("Failed shmat");
 667         }
 668
 669         dir_error = mkdir(logdir, 0755);
 670
 671         if (dir_error) {
 672                 err_msg("Failed mkdir");
 673         }
 674
 675         printf("start_cpu list:%lu\n", start_cpu);
 676         printf("number of worker threads:%lu + 1 snapshot thread\n", nrthreads);
 677         printf("Allocated address:0x%016lx + secondary map:0x%016lx\n", (unsigned long)map1, (unsigned long)map2);
 678         printf("logdir at : %s\n", logdir);
 679         printf("Timeout: %d seconds\n", run_time);
 680
 681         time(&now);
 682         printf("=================================\n");
 683         printf("     Starting Test\n");
 684         printf("     %s", ctime(&now));
 685         printf("=================================\n");
 686
 687         for (i = 0; i < nrthreads; i++) {
 688                 if (1 && !fork()) {
 689                         prctl(PR_SET_PDEATHSIG, SIGKILL);
 690                         set_mycpu(start_cpu + i);
 691                         for (;;)
 692                                 sched_yield();
 693                         exit(0);
 694                 }
 695         }
 696
 697
 698         sa_alrm.sa_handler = &alrm_sighandler;
 699         sigemptyset(&sa_alrm.sa_mask);
 700         sa_alrm.sa_flags = 0;
 701
 702         if (sigaction(SIGALRM, &sa_alrm, 0) == -1) {
 703                 err_msg("Failed signal handler registration\n");
 704         }
 705
 706         alarm(run_time);
 707
 708         pthread_attr_init(&attr);
 709         for (i = 0; i < nrthreads; i++) {
 710                 rim_thread_ids[i] = i;
 711                 pthread_create(&rim_threads[i], &attr, rim_fn, &rim_thread_ids[i]);
 712                 set_pthread_cpu(rim_threads[i], start_cpu + i);
 713         }
 714
 715         pthread_create(&mem_snapshot_thread, &attr, mem_snapshot_fn, map1);
 716         set_pthread_cpu(mem_snapshot_thread, start_cpu + i);
 717
 718
 719         pthread_join(mem_snapshot_thread, NULL);
 720         for (i = 0; i < nrthreads; i++) {
 721                 pthread_join(rim_threads[i], NULL);
 722         }
 723
 724         if (!timeout) {
 725                 time(&now);
 726                 printf("=================================\n");
 727                 printf("      Data Corruption Detected\n");
 728                 printf("      %s", ctime(&now));
 729                 printf("      See logfiles in %s\n", logdir);
 730                 printf("=================================\n");
 731                 return 1;
 732         }
 733         return 0;
 734 }