/*
 * Copyright (c) 2009-2012, Redis Ltd.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the name of Redis nor the names of its contributors may be used
 *     to endorse or promote products derived from this software without
 *     specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <termios.h>
#include <sys/ioctl.h>
#if defined(__sun)
#include <stropts.h>
#endif
#include "config.h"
#include "serverassert.h"

#if (ULONG_MAX == 4294967295UL)
#define MEMTEST_32BIT
#elif (ULONG_MAX == 18446744073709551615ULL)
#define MEMTEST_64BIT
#else
#error "ULONG_MAX value not supported."
#endif

#ifdef MEMTEST_32BIT
#define ULONG_ONEZERO 0xaaaaaaaaUL
#define ULONG_ZEROONE 0x55555555UL
#else
#define ULONG_ONEZERO 0xaaaaaaaaaaaaaaaaUL
#define ULONG_ZEROONE 0x5555555555555555UL
#endif

#if defined(__has_attribute)
#if __has_attribute(no_sanitize)
#define NO_SANITIZE(sanitizer) __attribute__((no_sanitize(sanitizer)))
#endif
#endif

#if !defined(NO_SANITIZE)
#define NO_SANITIZE(sanitizer)
#endif

static struct winsize ws;
size_t progress_printed; /* Printed chars in screen-wide progress bar. */
size_t progress_full;    /* How many chars to write to fill the progress bar. */

void memtest_progress_start(char *title, int pass) {
    int j;

    printf("\x1b[H\x1b[2J"); /* Cursor home, clear screen. */
    /* Fill with dots. */
    for (j = 0; j < ws.ws_col * (ws.ws_row - 2); j++) printf(".");
    printf("Please keep the test running several minutes per GB of memory.\n");
    printf("Also check http://www.memtest86.com/ and http://pyropus.ca/software/memtester/");
    printf("\x1b[H\x1b[2K");          /* Cursor home, clear current line.  */
    printf("%s [%d]\n", title, pass); /* Print title. */
    progress_printed = 0;
    progress_full = (size_t)ws.ws_col * (ws.ws_row - 3);
    fflush(stdout);
}

void memtest_progress_end(void) {
    printf("\x1b[H\x1b[2J"); /* Cursor home, clear screen. */
}

void memtest_progress_step(size_t curr, size_t size, char c) {
    size_t chars = ((unsigned long long)curr * progress_full) / size, j;

    for (j = 0; j < chars - progress_printed; j++) printf("%c", c);
    progress_printed = chars;
    fflush(stdout);
}

/* Test that addressing is fine. Every location is populated with its own
 * address, and finally verified. This test is very fast but may detect
 * ASAP big issues with the memory subsystem. */
int memtest_addressing(unsigned long *l, size_t bytes, int interactive) {
    unsigned long words = bytes / sizeof(unsigned long);
    unsigned long j, *p;

    /* Fill */
    p = l;
    for (j = 0; j < words; j++) {
        *p = (unsigned long)p;
        p++;
        if ((j & 0xffff) == 0 && interactive) memtest_progress_step(j, words * 2, 'A');
    }
    /* Test */
    p = l;
    for (j = 0; j < words; j++) {
        if (*p != (unsigned long)p) {
            if (interactive) {
                printf("\n*** MEMORY ADDRESSING ERROR: %p contains %lu\n", (void *)p, *p);
                exit(1);
            }
            return 1;
        }
        p++;
        if ((j & 0xffff) == 0 && interactive) memtest_progress_step(j + words, words * 2, 'A');
    }
    return 0;
}

/* Fill words stepping a single page at every write, so we continue to
 * touch all the pages in the smallest amount of time reducing the
 * effectiveness of caches, and making it hard for the OS to transfer
 * pages on the swap.
 *
 * In this test we can't call rand() since the system may be completely
 * unable to handle library calls, so we have to resort to our own
 * PRNG that only uses local state. We use an xorshift* PRNG. */
#define xorshift64star_next()                         \
    do {                                              \
        rseed ^= rseed >> 12;                         \
        rseed ^= rseed << 25;                         \
        rseed ^= rseed >> 27;                         \
        rout = rseed * UINT64_C(2685821657736338717); \
    } while (0)

void memtest_fill_random(unsigned long *l, size_t bytes, int interactive) {
    unsigned long step = 4096 / sizeof(unsigned long);
    unsigned long words = bytes / sizeof(unsigned long) / 2;
    unsigned long iwords = words / step; /* words per iteration */
    unsigned long off, w, *l1, *l2;
    uint64_t rseed = UINT64_C(0xd13133de9afdb566); /* Just a random seed. */
    uint64_t rout = 0;

    assert((bytes & 4095) == 0);
    for (off = 0; off < step; off++) {
        l1 = l + off;
        l2 = l1 + words;
        for (w = 0; w < iwords; w++) {
            xorshift64star_next();
            *l1 = *l2 = (unsigned long)rout;
            l1 += step;
            l2 += step;
            if ((w & 0xffff) == 0 && interactive) memtest_progress_step(w + iwords * off, words, 'R');
        }
    }
}

/* Like memtest_fill_random() but uses the two specified values to fill
 * memory, in an alternated way (v1|v2|v1|v2|...) */
void memtest_fill_value(unsigned long *l, size_t bytes, unsigned long v1, unsigned long v2, char sym, int interactive) {
    unsigned long step = 4096 / sizeof(unsigned long);
    unsigned long words = bytes / sizeof(unsigned long) / 2;
    unsigned long iwords = words / step; /* words per iteration */
    unsigned long off, w, *l1, *l2, v;

    assert((bytes & 4095) == 0);
    for (off = 0; off < step; off++) {
        l1 = l + off;
        l2 = l1 + words;
        v = (off & 1) ? v2 : v1;
        for (w = 0; w < iwords; w++) {
#ifdef MEMTEST_32BIT
            *l1 = *l2 = ((unsigned long)v) | (((unsigned long)v) << 16);
#else
            *l1 = *l2 = ((unsigned long)v) | (((unsigned long)v) << 16) | (((unsigned long)v) << 32) |
                        (((unsigned long)v) << 48);
#endif
            l1 += step;
            l2 += step;
            if ((w & 0xffff) == 0 && interactive) memtest_progress_step(w + iwords * off, words, sym);
        }
    }
}

int memtest_compare(unsigned long *l, size_t bytes, int interactive) {
    unsigned long words = bytes / sizeof(unsigned long) / 2;
    unsigned long w, *l1, *l2;

    assert((bytes & 4095) == 0);
    l1 = l;
    l2 = l1 + words;
    for (w = 0; w < words; w++) {
        if (*l1 != *l2) {
            if (interactive) {
                printf("\n*** MEMORY ERROR DETECTED: %p != %p (%lu vs %lu)\n", (void *)l1, (void *)l2, *l1, *l2);
                exit(1);
            }
            return 1;
        }
        l1++;
        l2++;
        if ((w & 0xffff) == 0 && interactive) memtest_progress_step(w, words, '=');
    }
    return 0;
}

int memtest_compare_times(unsigned long *m, size_t bytes, int pass, int times, int interactive) {
    int j;
    int errors = 0;

    for (j = 0; j < times; j++) {
        if (interactive) memtest_progress_start("Compare", pass);
        errors += memtest_compare(m, bytes, interactive);
        if (interactive) memtest_progress_end();
    }
    return errors;
}

/* Test the specified memory. The number of bytes must be multiple of 4096.
 * If interactive is true the program exists with an error and prints
 * ASCII arts to show progresses. Instead when interactive is 0, it can
 * be used as an API call, and returns 1 if memory errors were found or
 * 0 if there were no errors detected. */
int memtest_test(unsigned long *m, size_t bytes, int passes, int interactive) {
    int pass = 0;
    int errors = 0;

    while (pass != passes) {
        pass++;

        if (interactive) memtest_progress_start("Addressing test", pass);
        errors += memtest_addressing(m, bytes, interactive);
        if (interactive) memtest_progress_end();

        if (interactive) memtest_progress_start("Random fill", pass);
        memtest_fill_random(m, bytes, interactive);
        if (interactive) memtest_progress_end();
        errors += memtest_compare_times(m, bytes, pass, 4, interactive);

        if (interactive) memtest_progress_start("Solid fill", pass);
        memtest_fill_value(m, bytes, 0, (unsigned long)-1, 'S', interactive);
        if (interactive) memtest_progress_end();
        errors += memtest_compare_times(m, bytes, pass, 4, interactive);

        if (interactive) memtest_progress_start("Checkerboard fill", pass);
        memtest_fill_value(m, bytes, ULONG_ONEZERO, ULONG_ZEROONE, 'C', interactive);
        if (interactive) memtest_progress_end();
        errors += memtest_compare_times(m, bytes, pass, 4, interactive);
    }
    return errors;
}

/* A version of memtest_test() that tests memory in small pieces
 * in order to restore the memory content at exit.
 *
 * One problem we have with this approach, is that the cache can avoid
 * real memory accesses, and we can't test big chunks of memory at the
 * same time, because we need to backup them on the stack (the allocator
 * may not be usable or we may be already in an out of memory condition).
 * So what we do is to try to trash the cache with useless memory accesses
 * between the fill and compare cycles. */
#define MEMTEST_BACKUP_WORDS (1024 * (1024 / sizeof(long)))
/* Random accesses of MEMTEST_DECACHE_SIZE are performed at the start and
 * end of the region between fill and compare cycles in order to trash
 * the cache. */
#define MEMTEST_DECACHE_SIZE (1024 * 8)

NO_SANITIZE("undefined")
int memtest_preserving_test(unsigned long *m, size_t bytes, int passes) {
    unsigned long backup[MEMTEST_BACKUP_WORDS];
    unsigned long *p = m;
    unsigned long *end = (unsigned long *)(((unsigned char *)m) + (bytes - MEMTEST_DECACHE_SIZE));
    size_t left = bytes;
    int errors = 0;

    if (bytes & 4095) return 0;     /* Can't test across 4k page boundaries. */
    if (bytes < 4096 * 2) return 0; /* Can't test a single page. */

    while (left) {
        /* If we have to test a single final page, go back a single page
         * so that we can test two pages, since the code can't test a single
         * page but at least two. */
        if (left == 4096) {
            left += 4096;
            p -= 4096 / sizeof(unsigned long);
        }

        int pass = 0;
        size_t len = (left > sizeof(backup)) ? sizeof(backup) : left;

        /* Always test an even number of pages. */
        if (len / 4096 % 2) len -= 4096;

        memcpy(backup, p, len); /* Backup. */
        while (pass != passes) {
            pass++;
            errors += memtest_addressing(p, len, 0);
            memtest_fill_random(p, len, 0);
            if (bytes >= MEMTEST_DECACHE_SIZE) {
                memtest_compare_times(m, MEMTEST_DECACHE_SIZE, pass, 1, 0);
                memtest_compare_times(end, MEMTEST_DECACHE_SIZE, pass, 1, 0);
            }
            errors += memtest_compare_times(p, len, pass, 4, 0);
            memtest_fill_value(p, len, 0, (unsigned long)-1, 'S', 0);
            if (bytes >= MEMTEST_DECACHE_SIZE) {
                memtest_compare_times(m, MEMTEST_DECACHE_SIZE, pass, 1, 0);
                memtest_compare_times(end, MEMTEST_DECACHE_SIZE, pass, 1, 0);
            }
            errors += memtest_compare_times(p, len, pass, 4, 0);
            memtest_fill_value(p, len, ULONG_ONEZERO, ULONG_ZEROONE, 'C', 0);
            if (bytes >= MEMTEST_DECACHE_SIZE) {
                memtest_compare_times(m, MEMTEST_DECACHE_SIZE, pass, 1, 0);
                memtest_compare_times(end, MEMTEST_DECACHE_SIZE, pass, 1, 0);
            }
            errors += memtest_compare_times(p, len, pass, 4, 0);
        }
        memcpy(p, backup, len); /* Restore. */
        left -= len;
        p += len / sizeof(unsigned long);
    }
    return errors;
}

/* Perform an interactive test allocating the specified number of megabytes. */
void memtest_alloc_and_test(size_t megabytes, int passes) {
    size_t bytes = megabytes * 1024 * 1024;
    unsigned long *m = malloc(bytes);

    if (m == NULL) {
        fprintf(stderr, "Unable to allocate %zu megabytes: %s", megabytes, strerror(errno));
        exit(1);
    }
    memtest_test(m, bytes, passes, 1);
    free(m);
}

void memtest(size_t megabytes, int passes) {
#if !defined(__HAIKU__)
    if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
        ws.ws_col = 80;
        ws.ws_row = 20;
    }
#else
    ws.ws_col = 80;
    ws.ws_row = 20;
#endif
    memtest_alloc_and_test(megabytes, passes);
    printf("\nYour memory passed this test.\n");
    printf("Please if you are still in doubt use the following two tools:\n");
    printf("1) memtest86: http://www.memtest86.com/\n");
    printf("2) memtester: http://pyropus.ca/software/memtester/\n");
    exit(0);
}
