Skip to main content
  • Home
  • login
  • Browse the archive

    swh mirror partner logo
swh logo
SoftwareHeritage
Software
Heritage
Mirror
Features
  • Search

  • Downloads

  • Save code now

  • Add forge now

  • Help

Revision f2c2857accd5650cbcb0767019abd75925b51a3e authored by Matt Caswell on 19 October 2023, 13:54:58 UTC, committed by Matt Caswell on 23 October 2023, 09:08:22 UTC
Don't run the QUIC client fuzzer if QUIC is disabled
Reviewed-by: Tomas Mraz <tomas@openssl.org>
Reviewed-by: Hugo Landau <hlandau@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/22368)
1 parent 49f5d95
  • Files
  • Changes
  • 5f10889
  • /
  • test
  • /
  • threadpool_test.c
Raw File
Cook and download a directory from the Software Heritage Vault

You have requested the cooking of the directory with identifier None into a standard tar.gz archive.

Are you sure you want to continue ?

Download a directory from the Software Heritage Vault

You have requested the download of the directory with identifier None as a standard tar.gz archive.

Are you sure you want to continue ?

Cook and download a revision from the Software Heritage Vault

You have requested the cooking of the history heading to revision with identifier swh:1:rev:f2c2857accd5650cbcb0767019abd75925b51a3e into a bare git archive.

Are you sure you want to continue ?

Download a revision from the Software Heritage Vault

You have requested the download of the history heading to revision with identifier swh:1:rev:f2c2857accd5650cbcb0767019abd75925b51a3e as a bare git archive.

Are you sure you want to continue ?

Invalid Email !

The provided email is not well-formed.

Download link has expired

The requested archive is no longer available for download from the Software Heritage Vault.

Do you want to cook it again ?

Permalinks

To reference or cite the objects present in the Software Heritage archive, permalinks based on SoftWare Hash IDentifiers (SWHIDs) must be used.
Select below a type of object currently browsed in order to display its associated SWHID and permalink.

  • revision
  • content
revision badge
swh:1:rev:f2c2857accd5650cbcb0767019abd75925b51a3e
content badge Iframe embedding
swh:1:cnt:90ddaa9ce7c3ff948193eb13c3c5447b7a22df3c
threadpool_test.c
/*
 * Copyright 2022 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <string.h>
#include <internal/cryptlib.h>
#include <internal/thread_arch.h>
#include <internal/thread.h>
#include <openssl/thread.h>
#include "testutil.h"

static int test_thread_reported_flags(void)
{
    uint32_t flags = OSSL_get_thread_support_flags();

#if !defined(OPENSSL_THREADS)
    if (!TEST_int_eq(flags, 0))
        return 0;
#endif

#if defined(OPENSSL_NO_THREAD_POOL)
    if (!TEST_int_eq(flags & OSSL_THREAD_SUPPORT_FLAG_THREAD_POOL, 0))
        return 0;
#else
    if (!TEST_int_eq(flags & OSSL_THREAD_SUPPORT_FLAG_THREAD_POOL,
                     OSSL_THREAD_SUPPORT_FLAG_THREAD_POOL))
        return 0;
#endif

#if defined(OPENSSL_NO_DEFAULT_THREAD_POOL)
    if (!TEST_int_eq(flags & OSSL_THREAD_SUPPORT_FLAG_DEFAULT_SPAWN, 0))
        return 0;
#else
    if (!TEST_int_eq(flags & OSSL_THREAD_SUPPORT_FLAG_DEFAULT_SPAWN,
                     OSSL_THREAD_SUPPORT_FLAG_DEFAULT_SPAWN))
        return 0;
#endif

    return 1;
}

#ifndef OPENSSL_NO_THREAD_POOL

# define TEST_THREAD_NATIVE_FN_SET_VALUE 1
static uint32_t test_thread_native_fn(void *data)
{
    uint32_t *ldata = (uint32_t*) data;
    *ldata = *ldata + 1;
    return *ldata - 1;
}
/* Tests of native threads */

static int test_thread_native(void)
{
    uint32_t retval;
    uint32_t local;
    CRYPTO_THREAD *t;

    /* thread spawn, join */

    local = 1;
    t = ossl_crypto_thread_native_start(test_thread_native_fn, &local, 1);
    if (!TEST_ptr(t))
        return 0;

    /*
     * pthread_join results in undefined behaviour if called on a joined
     * thread. We do not impose such restrictions, so it's up to us to
     * ensure that this does not happen (thread sanitizer will warn us
     * if we do).
     */
    if (!TEST_int_eq(ossl_crypto_thread_native_join(t, &retval), 1))
        return 0;
    if (!TEST_int_eq(ossl_crypto_thread_native_join(t, &retval), 1))
        return 0;

    if (!TEST_int_eq(retval, 1) || !TEST_int_eq(local, 2))
        return 0;

    if (!TEST_int_eq(ossl_crypto_thread_native_clean(t), 1))
        return 0;
    t = NULL;

    if (!TEST_int_eq(ossl_crypto_thread_native_clean(t), 0))
        return 0;

    return 1;
}

# if !defined(OPENSSL_NO_DEFAULT_THREAD_POOL)
static int test_thread_internal(void)
{
    uint32_t retval[3];
    uint32_t local[3] = { 0 };
    uint32_t threads_supported;
    size_t i;
    void *t[3];
    OSSL_LIB_CTX *cust_ctx = OSSL_LIB_CTX_new();

    threads_supported = OSSL_get_thread_support_flags();
    threads_supported &= OSSL_THREAD_SUPPORT_FLAG_DEFAULT_SPAWN;

    if (threads_supported == 0) {
        if (!TEST_uint64_t_eq(OSSL_get_max_threads(NULL), 0))
            return 0;
        if (!TEST_uint64_t_eq(OSSL_get_max_threads(cust_ctx), 0))
            return 0;

        if (!TEST_int_eq(OSSL_set_max_threads(NULL, 1), 0))
            return 0;
        if (!TEST_int_eq(OSSL_set_max_threads(cust_ctx, 1), 0))
            return 0;

        if (!TEST_uint64_t_eq(OSSL_get_max_threads(NULL), 0))
            return 0;
        if (!TEST_uint64_t_eq(OSSL_get_max_threads(cust_ctx), 0))
            return 0;

        t[0] = ossl_crypto_thread_start(NULL, test_thread_native_fn, &local[0]);
        if (!TEST_ptr_null(t[0]))
            return 0;

        return 1;
    }

    /* fail when not allowed to use threads */

    if (!TEST_uint64_t_eq(OSSL_get_max_threads(NULL), 0))
        return 0;
    t[0] = ossl_crypto_thread_start(NULL, test_thread_native_fn, &local[0]);
    if (!TEST_ptr_null(t[0]))
        return 0;

    /* fail when enabled on a different context */
    if (!TEST_uint64_t_eq(OSSL_get_max_threads(cust_ctx), 0))
        return 0;
    if (!TEST_int_eq(OSSL_set_max_threads(cust_ctx, 1), 1))
        return 0;
    if (!TEST_uint64_t_eq(OSSL_get_max_threads(NULL), 0))
        return 0;
    if (!TEST_uint64_t_eq(OSSL_get_max_threads(cust_ctx), 1))
        return 0;
    t[0] = ossl_crypto_thread_start(NULL, test_thread_native_fn, &local[0]);
    if (!TEST_ptr_null(t[0]))
        return 0;
    if (!TEST_int_eq(OSSL_set_max_threads(cust_ctx, 0), 1))
        return 0;

    /* sequential startup */

    if (!TEST_int_eq(OSSL_set_max_threads(NULL, 1), 1))
        return 0;
    if (!TEST_uint64_t_eq(OSSL_get_max_threads(NULL), 1))
        return 0;
    if (!TEST_uint64_t_eq(OSSL_get_max_threads(cust_ctx), 0))
        return 0;

    for (i = 0; i < OSSL_NELEM(t); ++i) {
        local[0] = i + 1;

        t[i] = ossl_crypto_thread_start(NULL, test_thread_native_fn, &local[0]);
        if (!TEST_ptr(t[i]))
            return 0;

        /*
         * pthread_join results in undefined behaviour if called on a joined
         * thread. We do not impose such restrictions, so it's up to us to
         * ensure that this does not happen (thread sanitizer will warn us
         * if we do).
         */
        if (!TEST_int_eq(ossl_crypto_thread_join(t[i], &retval[0]), 1))
            return 0;
        if (!TEST_int_eq(ossl_crypto_thread_join(t[i], &retval[0]), 1))
            return 0;

        if (!TEST_int_eq(retval[0], i + 1) || !TEST_int_eq(local[0], i + 2))
            return 0;

        if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 1))
            return 0;
        t[i] = NULL;

        if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 0))
            return 0;
    }

    /* parallel startup */

    if (!TEST_int_eq(OSSL_set_max_threads(NULL, OSSL_NELEM(t)), 1))
        return 0;

    for (i = 0; i < OSSL_NELEM(t); ++i) {
        local[i] = i + 1;
        t[i] = ossl_crypto_thread_start(NULL, test_thread_native_fn, &local[i]);
        if (!TEST_ptr(t[i]))
            return 0;
    }
    for (i = 0; i < OSSL_NELEM(t); ++i) {
        if (!TEST_int_eq(ossl_crypto_thread_join(t[i], &retval[i]), 1))
            return 0;
    }
    for (i = 0; i < OSSL_NELEM(t); ++i) {
        if (!TEST_int_eq(retval[i], i + 1) || !TEST_int_eq(local[i], i + 2))
            return 0;
        if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 1))
            return 0;
    }

    /* parallel startup, bottleneck */

    if (!TEST_int_eq(OSSL_set_max_threads(NULL, OSSL_NELEM(t) - 1), 1))
        return 0;

    for (i = 0; i < OSSL_NELEM(t); ++i) {
        local[i] = i + 1;
        t[i] = ossl_crypto_thread_start(NULL, test_thread_native_fn, &local[i]);
        if (!TEST_ptr(t[i]))
            return 0;
    }
    for (i = 0; i < OSSL_NELEM(t); ++i) {
        if (!TEST_int_eq(ossl_crypto_thread_join(t[i], &retval[i]), 1))
            return 0;
    }
    for (i = 0; i < OSSL_NELEM(t); ++i) {
        if (!TEST_int_eq(retval[i], i + 1) || !TEST_int_eq(local[i], i + 2))
            return 0;
        if (!TEST_int_eq(ossl_crypto_thread_clean(t[i]), 1))
            return 0;
    }

    if (!TEST_int_eq(OSSL_set_max_threads(NULL, 0), 1))
        return 0;

    OSSL_LIB_CTX_free(cust_ctx);
    return 1;
}
# endif

static uint32_t test_thread_native_multiple_joins_fn1(void *data)
{
    return 0;
}

static uint32_t test_thread_native_multiple_joins_fn2(void *data)
{
    ossl_crypto_thread_native_join((CRYPTO_THREAD *)data, NULL);
    return 0;
}

static uint32_t test_thread_native_multiple_joins_fn3(void *data)
{
    ossl_crypto_thread_native_join((CRYPTO_THREAD *)data, NULL);
    return 0;
}

static int test_thread_native_multiple_joins(void)
{
    CRYPTO_THREAD *t, *t1, *t2;

    t = ossl_crypto_thread_native_start(test_thread_native_multiple_joins_fn1, NULL, 1);
    t1 = ossl_crypto_thread_native_start(test_thread_native_multiple_joins_fn2, t, 1);
    t2 = ossl_crypto_thread_native_start(test_thread_native_multiple_joins_fn3, t, 1);

    if (!TEST_ptr(t) || !TEST_ptr(t1) || !TEST_ptr(t2))
        return 0;

    if (!TEST_int_eq(ossl_crypto_thread_native_join(t2, NULL), 1))
        return 0;
    if (!TEST_int_eq(ossl_crypto_thread_native_join(t1, NULL), 1))
        return 0;

    if (!TEST_int_eq(ossl_crypto_thread_native_clean(t2), 1))
        return 0;

    if (!TEST_int_eq(ossl_crypto_thread_native_clean(t1), 1))
        return 0;

    if (!TEST_int_eq(ossl_crypto_thread_native_clean(t), 1))
        return 0;

    return 1;
}

#endif

int setup_tests(void)
{
    ADD_TEST(test_thread_reported_flags);
#if !defined(OPENSSL_NO_THREAD_POOL)
    ADD_TEST(test_thread_native);
    ADD_TEST(test_thread_native_multiple_joins);
# if !defined(OPENSSL_NO_DEFAULT_THREAD_POOL)
    ADD_TEST(test_thread_internal);
# endif
#endif

    return 1;
}
The diff you're trying to view is too large. Only the first 1000 changed files have been loaded.
Showing with 0 additions and 0 deletions (0 / 0 diffs computed)
swh spinner

Computing file changes ...

ENEA — Copyright (C), ENEA. License: GNU AGPLv3+.
Legal notes  ::  JavaScript license information ::  Web API

back to top