xenocara/lib/pixman/test/fence-image-self-test.c

/*
 * Copyright © 2015 Raspberry Pi Foundation
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of the copyright holders not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  The copyright holders make no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "utils.h"


#if FENCE_MALLOC_ACTIVE && defined (HAVE_SIGACTION)

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

pixman_bool_t verbose;

static void
segv_handler (int sig, siginfo_t *si, void *unused)
{
    _exit (EXIT_SUCCESS);
}

static void
die (const char *msg, int err)
{
    if (err)
        perror (msg);
    else
        fprintf (stderr, "%s\n", msg);

    abort ();
}

static void
prinfo (const char *fmt, ...)
{
    va_list ap;

    if (!verbose)
        return;

    va_start (ap, fmt);
    vfprintf (stderr, fmt, ap);
    va_end (ap);
}

static void
do_expect_signal (void (*fn)(void *), void *data)
{
    struct sigaction sa;

    sa.sa_flags = SA_SIGINFO;
    sigemptyset (&sa.sa_mask);
    sa.sa_sigaction = segv_handler;
    if (sigaction (SIGSEGV, &sa, NULL) == -1)
        die ("sigaction failed", errno);
    if (sigaction (SIGBUS, &sa, NULL) == -1)
        die ("sigaction failed", errno);

    (*fn)(data);

    _exit (EXIT_FAILURE);
}

/* Check that calling fn(data) causes a segmentation fault.
 *
 * You cannot portably return from a SIGSEGV handler in any way,
 * so we fork, and do the test in the child process. Child's
 * exit status will reflect the result. Its SEGV handler causes it
 * to exit with success, and return failure otherwise.
 */
static pixman_bool_t
expect_signal (void (*fn)(void *), void *data)
{
    pid_t pid, wp;
    int status;

    pid = fork ();
    if (pid == -1)
        die ("fork failed", errno);

    if (pid == 0)
        do_expect_signal (fn, data); /* never returns */

    wp = waitpid (pid, &status, 0);
    if (wp != pid)
        die ("waitpid did not work", wp == -1 ? errno : 0);

    if (WIFEXITED (status) && WEXITSTATUS (status) == EXIT_SUCCESS)
        return TRUE;

    return FALSE;
}

static void
read_u8 (void *data)
{
    volatile uint8_t *p = data;

    *p;
}

static pixman_bool_t
test_read_fault (uint8_t *p, int offset)
{
    prinfo ("*(uint8_t *)(%p + %d)", p, offset);

    if (expect_signal (read_u8, p + offset))
    {
        prinfo ("\tsignal OK\n");

        return TRUE;
    }

    prinfo ("\tFAILED\n");

    return FALSE;
}

static void
test_read_ok (uint8_t *p, int offset)
{
    prinfo ("*(uint8_t *)(%p + %d)", p, offset);

    /* If fails, SEGV. */
    read_u8 (p + offset);

    prinfo ("\tOK\n");
}

static pixman_bool_t
test_read_faults (pixman_image_t *image)
{
    pixman_bool_t ok = TRUE;
    pixman_format_code_t format = pixman_image_get_format (image);
    int width = pixman_image_get_width (image);
    int height = pixman_image_get_height (image);
    int stride = pixman_image_get_stride (image);
    uint8_t *p = (void *)pixman_image_get_data (image);
    int row_bytes = width * PIXMAN_FORMAT_BPP (format) / 8;

    prinfo ("%s %dx%d, row %d B, stride %d B:\n",
            format_name (format), width, height, row_bytes, stride);

    assert (height > 3);

    test_read_ok (p, 0);
    test_read_ok (p, row_bytes - 1);
    test_read_ok (p, stride);
    test_read_ok (p, stride + row_bytes - 1);
    test_read_ok (p, 2 * stride);
    test_read_ok (p, 2 * stride + row_bytes - 1);
    test_read_ok (p, 3 * stride);
    test_read_ok (p, (height - 1) * stride + row_bytes - 1);

    ok &= test_read_fault (p, -1);
    ok &= test_read_fault (p, row_bytes);
    ok &= test_read_fault (p, stride - 1);
    ok &= test_read_fault (p, stride + row_bytes);
    ok &= test_read_fault (p, 2 * stride - 1);
    ok &= test_read_fault (p, 2 * stride + row_bytes);
    ok &= test_read_fault (p, 3 * stride - 1);
    ok &= test_read_fault (p, height * stride);

    return ok;
}

static pixman_bool_t
test_image_faults (pixman_format_code_t format, int min_width, int height)
{
    pixman_bool_t ok;
    pixman_image_t *image;

    image = fence_image_create_bits (format, min_width, height, TRUE);
    ok = test_read_faults (image);
    pixman_image_unref (image);

    return ok;
}

int
main (int argc, char **argv)
{
    pixman_bool_t ok = TRUE;

    if (getenv ("VERBOSE") != NULL)
        verbose = TRUE;

    ok &= test_image_faults (PIXMAN_a8r8g8b8, 7, 5);
    ok &= test_image_faults (PIXMAN_r8g8b8, 7, 5);
    ok &= test_image_faults (PIXMAN_r5g6b5, 7, 5);
    ok &= test_image_faults (PIXMAN_a8, 7, 5);
    ok &= test_image_faults (PIXMAN_a4, 7, 5);
    ok &= test_image_faults (PIXMAN_a1, 7, 5);

    if (ok)
        return EXIT_SUCCESS;

    return EXIT_FAILURE;
}

#else /* FENCE_MALLOC_ACTIVE */

int
main (int argc, char **argv)
{
    /* Automake return code for test SKIP. */
    return 77;
}

#endif /* FENCE_MALLOC_ACTIVE */