xref: /src/tests/modules/threadpool_tester/threadpool_tester.c

/*	$NetBSD: threadpool_tester.c,v 1.1 2019/01/25 18:33:59 christos Exp $	*/

/*-
 * Copyright (c) 2018 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jason R. Thorpe.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: threadpool_tester.c,v 1.1 2019/01/25 18:33:59 christos Exp $");

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <sys/threadpool.h>

MODULE(MODULE_CLASS_MISC, threadpool_tester, NULL);

#ifdef THREADPOOL_VERBOSE
#define	TP_LOG(x)		printf x
#else
#define	TP_LOG(x)		/* nothing */
#endif /* THREADPOOL_VERBOSE */

static struct tester_context {
	kmutex_t ctx_mutex;
	struct sysctllog *ctx_sysctllog;
	struct threadpool *ctx_unbound[PRI_COUNT + 1];
	struct threadpool_percpu *ctx_percpu[PRI_COUNT + 1];
	unsigned int ctx_value;
	struct threadpool_job ctx_job;
} tester_ctx;

#define	pri_to_idx(pri)		((pri) == PRI_NONE ? PRI_COUNT : (pri))

static bool
pri_is_valid(pri_t pri)
{
	return (pri == PRI_NONE || (pri >= PRI_USER && pri < PRI_COUNT));
}

static int
threadpool_tester_get_unbound(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct threadpool *pool, *opool = NULL;
	struct sysctlnode node;
	int error, val;

	node = *rnode;
	ctx = node.sysctl_data;

	val = -1;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL)
		return error;

	if (! pri_is_valid(val))
		return EINVAL;

	error = threadpool_get(&pool, val);
	if (error) {
		TP_LOG(("%s: threadpool_get(..., %d) failed -> %d\n",
		    __func__, val, error));
		return error;
	}

	mutex_enter(&ctx->ctx_mutex);
	if (ctx->ctx_unbound[pri_to_idx(val)] == NULL)
		ctx->ctx_unbound[pri_to_idx(val)] = pool;
	else
		opool = ctx->ctx_unbound[pri_to_idx(val)];
	mutex_exit(&ctx->ctx_mutex);

	if (opool != NULL) {
		/* Should have gotten reference to existing pool. */
		TP_LOG(("%s: found existing unbound pool for pri %d (%s)\n",
		    __func__, val, opool == pool ? "match" : "NO MATCH"));
		KASSERT(opool == pool);
		threadpool_put(pool, val);
		error = EEXIST;
	} else {
		TP_LOG(("%s: created unbound pool for pri %d\n",
		    __func__, val));
	}

	return error;
}

static int
threadpool_tester_put_unbound(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct threadpool *pool;
	struct sysctlnode node;
	int error, val;

	node = *rnode;
	ctx = node.sysctl_data;

	val = -1;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL)
		return error;

	if (! pri_is_valid(val))
		return EINVAL;

	mutex_enter(&ctx->ctx_mutex);
	/* We only ever maintain a single reference. */
	pool = ctx->ctx_unbound[pri_to_idx(val)];
	ctx->ctx_unbound[pri_to_idx(val)] = NULL;
	mutex_exit(&ctx->ctx_mutex);

	if (pool == NULL) {
		TP_LOG(("%s: no unbound pool for pri %d\n",
		    __func__, val));
		return ENODEV;
	}

	threadpool_put(pool, val);
	TP_LOG(("%s: released unbound pool for pri %d\n",
	    __func__, val));

	return 0;
}

static int
threadpool_tester_run_unbound(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct threadpool *pool;
	struct sysctlnode node;
	int error, val;

	node = *rnode;
	ctx = node.sysctl_data;

	val = -1;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL)
		return error;

	if (! pri_is_valid(val))
		return EINVAL;

	mutex_enter(&ctx->ctx_mutex);
	pool = ctx->ctx_unbound[pri_to_idx(val)];
	if (pool == NULL) {
		TP_LOG(("%s: no unbound pool for pri %d\n",
		    __func__, val));
		mutex_exit(&ctx->ctx_mutex);
		return ENODEV;
	}

	threadpool_schedule_job(pool, &ctx->ctx_job);
	TP_LOG(("%s: scheduled job on unbound pool for pri %d\n",
	    __func__, val));
	mutex_exit(&ctx->ctx_mutex);

	return 0;
}

static int
threadpool_tester_get_percpu(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct threadpool_percpu *pcpu, *opcpu = NULL;
	struct sysctlnode node;
	int error, val;

	node = *rnode;
	ctx = node.sysctl_data;

	val = -1;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL)
		return error;

	if (! pri_is_valid(val))
		return EINVAL;

	error = threadpool_percpu_get(&pcpu, val);
	if (error) {
		TP_LOG(("%s: threadpool_percpu_get(..., %d) failed -> %d\n",
		    __func__, val, error));
		return error;
	}

	mutex_enter(&ctx->ctx_mutex);
	if (ctx->ctx_percpu[pri_to_idx(val)] == NULL)
		ctx->ctx_percpu[pri_to_idx(val)] = pcpu;
	else
		opcpu = ctx->ctx_percpu[pri_to_idx(val)];
	mutex_exit(&ctx->ctx_mutex);

	if (opcpu != NULL) {
		/* Should have gotten reference to existing pool. */
		TP_LOG(("%s: found existing unbound pool for pri %d (%s)\n",
		    __func__, val, opcpu == pcpu ? "match" : "NO MATCH"));
		KASSERT(opcpu == pcpu);
		threadpool_percpu_put(pcpu, val);
		error = EEXIST;
	} else {
		TP_LOG(("%s: created percpu pool for pri %d\n",
		    __func__, val));
	}

	return error;
}

static int
threadpool_tester_put_percpu(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct threadpool_percpu *pcpu;
	struct sysctlnode node;
	int error, val;

	node = *rnode;
	ctx = node.sysctl_data;

	val = -1;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL)
		return error;

	if (! pri_is_valid(val))
		return EINVAL;

	mutex_enter(&ctx->ctx_mutex);
	/* We only ever maintain a single reference. */
	pcpu = ctx->ctx_percpu[pri_to_idx(val)];
	ctx->ctx_percpu[pri_to_idx(val)] = NULL;
	mutex_exit(&ctx->ctx_mutex);

	if (pcpu == NULL) {
		TP_LOG(("%s: no percpu pool for pri %d\n",
		    __func__, val));
		return ENODEV;
	}

	threadpool_percpu_put(pcpu, val);
	TP_LOG(("%s: released percpu pool for pri %d\n",
	    __func__, val));

	return 0;
}

static int
threadpool_tester_run_percpu(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct threadpool_percpu *pcpu;
	struct threadpool *pool;
	struct sysctlnode node;
	int error, val;

	node = *rnode;
	ctx = node.sysctl_data;

	val = -1;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL)
		return error;

	if (! pri_is_valid(val))
		return EINVAL;

	mutex_enter(&ctx->ctx_mutex);
	pcpu = ctx->ctx_percpu[pri_to_idx(val)];
	if (pcpu == NULL) {
		TP_LOG(("%s: no percpu pool for pri %d\n",
		    __func__, val));
		mutex_exit(&ctx->ctx_mutex);
		return ENODEV;
	}

	pool = threadpool_percpu_ref(pcpu);
	KASSERT(pool != NULL);

	threadpool_schedule_job(pool, &ctx->ctx_job);
	TP_LOG(("%s: scheduled job on percpu pool for pri %d\n",
	    __func__, val));
	mutex_exit(&ctx->ctx_mutex);

	return 0;
}

static int
threadpool_tester_test_value(SYSCTLFN_ARGS)
{
	struct tester_context *ctx;
	struct sysctlnode node;
	unsigned int val;
	int error;

	node = *rnode;
	ctx = node.sysctl_data;

	mutex_enter(&ctx->ctx_mutex);
	val = ctx->ctx_value;
	node.sysctl_data = &val;
	error = sysctl_lookup(SYSCTLFN_CALL(&node));
	if (error || newp == NULL) {
		mutex_exit(&ctx->ctx_mutex);
		return error;
	}
	ctx->ctx_value = val;
	mutex_exit(&ctx->ctx_mutex);

	return 0;
}

static void
threadpool_tester_job(struct threadpool_job *job)
{
	struct tester_context *ctx =
	    container_of(job, struct tester_context, ctx_job);
	unsigned int oval, nval;

	TP_LOG(("%s: job = %p, ctx = %p\n", __func__, job, ctx));

	mutex_enter(&ctx->ctx_mutex);
	oval = ctx->ctx_value;
	nval = oval + 1;	/* always reference oval and nval */
	ctx->ctx_value = nval;
	mutex_exit(&ctx->ctx_mutex);

	TP_LOG(("%s: %u -> %u\n", __func__, oval, nval));
	(void) kpause("tptestjob", false, hz, NULL);

	mutex_enter(&ctx->ctx_mutex);
	threadpool_job_done(job);
	mutex_exit(&ctx->ctx_mutex);
}

#define	RETURN_ERROR	if (error) goto return_error

static int
threadpool_tester_init(void)
{
	struct sysctllog **log = &tester_ctx.ctx_sysctllog;
	const struct sysctlnode *rnode, *cnode;
	int error;

	mutex_init(&tester_ctx.ctx_mutex, MUTEX_DEFAULT, IPL_NONE);
	threadpool_job_init(&tester_ctx.ctx_job, threadpool_tester_job,
	    &tester_ctx.ctx_mutex, "tptest");

	error = sysctl_createv(log, 0, NULL, &rnode, CTLFLAG_PERMANENT,
	    CTLTYPE_NODE, "threadpool_tester",
	    SYSCTL_DESCR("threadpool testing interface"),
	    NULL, 0, NULL, 0, CTL_KERN, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "get_unbound",
	    SYSCTL_DESCR("get unbound pool of specified priority"),
	    threadpool_tester_get_unbound, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "put_unbound",
	    SYSCTL_DESCR("put unbound pool of specified priority"),
	    threadpool_tester_put_unbound, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "run_unbound",
	    SYSCTL_DESCR("run on unbound pool of specified priority"),
	    threadpool_tester_run_unbound, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "get_percpu",
	    SYSCTL_DESCR("get percpu pool of specified priority"),
	    threadpool_tester_get_percpu, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "put_percpu",
	    SYSCTL_DESCR("put percpu pool of specified priority"),
	    threadpool_tester_put_percpu, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "run_percpu",
	    SYSCTL_DESCR("run on percpu pool of specified priority"),
	    threadpool_tester_run_percpu, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	error = sysctl_createv(log, 0, &rnode, &cnode,
	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "test_value",
	    SYSCTL_DESCR("test value that jobs increment"),
	    threadpool_tester_test_value, 0,
	    (void *)&tester_ctx, 0, CTL_CREATE, CTL_EOL);
	RETURN_ERROR;

	return 0;

 return_error:
 	sysctl_teardown(log);
	return error;
}

static int
threadpool_tester_fini(void)
{
	pri_t pri;

	mutex_enter(&tester_ctx.ctx_mutex);
	for (pri = PRI_NONE/*-1*/; pri < PRI_COUNT; pri++) {
		struct threadpool *pool =
		    tester_ctx.ctx_unbound[pri_to_idx(pri)];
		struct threadpool_percpu *pcpu =
		    tester_ctx.ctx_percpu[pri_to_idx(pri)];

		/*
		 * threadpool_cancel_job() may be called on a pool
		 * other than what the job is scheduled on. This is
		 * safe; see comment in threadpool_cancel_job_async().
		 */

		if (pool != NULL) {
			threadpool_cancel_job(pool, &tester_ctx.ctx_job);
			threadpool_put(pool, pri);
			tester_ctx.ctx_unbound[pri_to_idx(pri)] = NULL;
		}
		if (pcpu != NULL) {
			pool = threadpool_percpu_ref(pcpu);
			threadpool_cancel_job(pool, &tester_ctx.ctx_job);
			threadpool_percpu_put(pcpu, pri);
			tester_ctx.ctx_percpu[pri_to_idx(pri)] = NULL;
		}
	}
	mutex_exit(&tester_ctx.ctx_mutex);
	threadpool_job_destroy(&tester_ctx.ctx_job);
	mutex_destroy(&tester_ctx.ctx_mutex);

	sysctl_teardown(&tester_ctx.ctx_sysctllog);

	return 0;
}

static int
threadpool_tester_modcmd(modcmd_t cmd, void *arg __unused)
{
	int error;

	switch (cmd) {
	case MODULE_CMD_INIT:
		error = threadpool_tester_init();
		break;

	case MODULE_CMD_FINI:
		error = threadpool_tester_fini();
		break;

	case MODULE_CMD_STAT:
	default:
		error = ENOTTY;
	}

	return error;
}