testcases/kernel/syscalls/membarrier/membarrier01.c - platform/external/ltp - Git at Google

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * Copyright (c) 2018 Linaro Limited. All rights reserved.
  * Author: Rafael David Tinoco <rafael.tinoco@linaro.org>
  */
 /*
  * Basic tests for membarrier(2) syscall. Tests below are responsible for
  * testing the membarrier(2) interface only, without checking if the barrier
  * was successful or not. Check test_case structure for each test description.
  */

 #include "config.h"
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <syscall.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "tst_test.h"
 #include "lapi/syscalls.h"
 #include "lapi/membarrier.h"

 struct test_case {
 	char testname[80];
 	int command;		/* membarrier cmd                            */
 	int needregister;	/* membarrier cmd needs register cmd	     */
 	int flags;		/* flags for given membarrier cmd	     */
 	long exp_ret;		/* expected return code for given cmd        */
 	int exp_errno;		/* expected errno for given cmd failure      */
 	int enabled;		/* enabled, despite results from CMD_QUERY   */
 	int always;		/* CMD_QUERY should always enable this test  */
 	int force;		/* force if CMD_QUERY reports not enabled    */
 	int force_exp_errno;	/* expected errno after forced cmd           */
 	int change_exp_errno;	/* previous kernels forced errno result      */
 	int change_kernver[3];	/* kernel version having diff expected errno */
 };

 struct test_case tc[] = {
 	{
 	 /*
 	  * case 00) invalid cmd
 	  *     - enabled by default
 	  *     - should always fail with EINVAL
 	  */
 	 .testname = "cmd_fail",
 	 .command = -1,
 	 .exp_ret = -1,
 	 .exp_errno = EINVAL,
 	 .enabled = 1,
 	 },
 	{
 	 /*
 	  * case 01) invalid flags
 	  *     - enabled by default
 	  *     - should always fail with EINVAL
 	  */
 	 .testname = "cmd_flags_fail",
 	 .command = MEMBARRIER_CMD_QUERY,
 	 .flags = 1,
 	 .exp_ret = -1,
 	 .exp_errno = EINVAL,
 	 .enabled = 1,
 	 },
 	{
 	 /*
 	  * case 02) global barrier
 	  *     - should ALWAYS be enabled by CMD_QUERY
 	  *     - should always succeed
 	  */
 	 .testname = "cmd_global_success",
 	 .command = MEMBARRIER_CMD_GLOBAL,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .always = 1,
 	 },
 	 /*
 	  * commit 22e4ebb975 (v4.14-rc1) added cases 03, 04 and 05 features:
 	  */
 	{
 	 /*
 	  * case 03) private expedited barrier with no registrations
 	  *     - should fail with errno=EPERM due to no registrations
 	  *     - or be skipped if unsupported by running kernel
 	  */
 	 .testname = "cmd_private_expedited_fail",
 	 .command = MEMBARRIER_CMD_PRIVATE_EXPEDITED,
 	 .flags = 0,
 	 .exp_ret = -1,
 	 .exp_errno = EPERM,
 	 },
 	{
 	 /*
 	  * case 04) register private expedited
 	  *     - should succeed when supported by running kernel
 	  *     - or fail with errno=EINVAL if unsupported and forced
 	  */
 	 .testname = "cmd_private_expedited_register_success",
 	 .command = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .force = 1,
 	 .force_exp_errno = EINVAL,
 	 },
 	{
 	 /*
 	  * case 05) private expedited barrier with registration
 	  *     - should succeed due to existing registration
 	  *     - or fail with errno=EINVAL if unsupported and forced
 	  *     - NOTE: commit 70216e18e5 (v4.16-rc1) changed behavior:
 	  *     -       (a) if unsupported, and forced, < 4.16 , errno is EINVAL
 	  *     -       (b) if unsupported, and forced, >= 4.16, errno is EPERM
 	  */
 	 .testname = "cmd_private_expedited_success",
 	 .needregister = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED,
 	 .command = MEMBARRIER_CMD_PRIVATE_EXPEDITED,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .force = 1,
 	 .force_exp_errno = EPERM,
 	 .change_exp_errno = EINVAL,
 	 .change_kernver = { 4, 16, 0 },
 	 },
 	 /*
 	  * commit 70216e18e5 (v4.16-rc1) added cases 06, 07 and 08 features:
 	  */
 	{
 	 /*
 	  * case 06) private expedited sync core barrier with no registrations
 	  *     - should fail with errno=EPERM due to no registrations
 	  *     - or be skipped if unsupported by running kernel
 	  */
 	 .testname = "cmd_private_expedited_sync_core_fail",
 	 .command = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE,
 	 .flags = 0,
 	 .exp_ret = -1,
 	 .exp_errno = EPERM,
 	 },
 	{
 	 /*
 	  * case 07) register private expedited sync core
 	  *     - should succeed when supported by running kernel
 	  *     - or fail with errno=EINVAL if unsupported and forced
 	  */
 	 .testname = "cmd_private_expedited_sync_core_register_success",
 	 .command = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .force = 1,
 	 .force_exp_errno = EINVAL,
 	 },
 	{
 	 /*
 	  * case 08) private expedited sync core barrier with registration
 	  *     - should succeed due to existing registration
 	  *     - or fail with errno=EINVAL if unsupported and forced
 	  */
 	 .testname = "cmd_private_expedited_sync_core_success",
 	 .needregister = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE,
 	 .command = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .force = 1,
 	 .force_exp_errno = EINVAL,
 	 },
 	 /*
 	  * commit c5f58bd58f4 (v4.16-rc1) added cases 09, 10 and 11 features:
 	  */
 	{
 	 /*
 	  * case 09) global expedited barrier with no registrations
 	  *     - should never fail due to no registrations
 	  *     - or be skipped if unsupported by running kernel
 	  */
 	 .testname = "cmd_global_expedited_success",
 	 .command = MEMBARRIER_CMD_GLOBAL_EXPEDITED,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 },
 	{
 	 /*
 	  * case 10) register global expedited
 	  *     - should succeed when supported by running kernel
 	  *     - or fail with errno=EINVAL if unsupported and forced
 	  */
 	 .testname = "cmd_global_expedited_register_success",
 	 .command = MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .force = 1,
 	 .force_exp_errno = EINVAL,
 	 },
 	{
 	 /*
 	  * case 11) global expedited barrier with registration
 	  *     - should also succeed with registrations
 	  *     - or fail with errno=EINVAL if unsupported and forced
 	  */
 	 .testname = "cmd_global_expedited_success",
 	 .needregister = MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED,
 	 .command = MEMBARRIER_CMD_GLOBAL_EXPEDITED,
 	 .flags = 0,
 	 .exp_ret = 0,
 	 .force = 1,
 	 .force_exp_errno = EINVAL,
 	 },
 };

 #define passed_ok(_test)						       \
 	do {								       \
 		tst_res(TPASS, "membarrier(2): %s passed", _test.testname);    \
 		return;							       \
 	} while (0)

 #define passed_unexpec(_test)						       \
 	do {								       \
 		tst_res(TFAIL, "membarrier(2): %s passed unexpectedly. "       \
 			"ret = %ld with errno %d were expected. (force: %d)",  \
 			_test.testname, _test.exp_ret, _test.exp_errno,        \
 			_test.force);					       \
 		return;							       \
 	} while (0)

 #define failed_ok(_test)						       \
 	do {								       \
 		tst_res(TPASS, "membarrier(2): %s failed as expected",	       \
 			_test.testname);				       \
 		return;							       \
 	} while (0)

 #define failed_ok_unsupported(_test)					       \
 	do {								       \
 		tst_res(TPASS, "membarrier(2): %s failed as expected "	       \
 			"(unsupported)", _test.testname);		       \
 		return;							       \
 	} while (0)

 #define failed_not_ok(_test, _gotret, _goterr)				       \
 	do {								       \
 		tst_res(TFAIL, "membarrier(2): %s failed. "		       \
 			"ret = %ld when expected was %ld. "		       \
 			"errno = %d when expected was %d. (force: %d)",        \
 			_test.testname, _gotret, _test.exp_ret, _goterr,       \
 			_test.exp_errno, _test.force);			       \
 		return;							       \
 	} while (0)

 #define failed_unexpec(_test, _gotret, _goterr) 			       \
 	do {								       \
 		tst_res(TFAIL, "membarrier(2): %s failed unexpectedly. "       \
 			"Got ret = %ld with errno %d. (force: %d)",	       \
 			_test.testname, _gotret, _goterr, _test.force);	       \
 		return;							       \
 	} while (0)

 #define skipped(_test)							       \
 	do {								       \
 		tst_res(TPASS, "membarrier(2): %s skipped (unsupported)",      \
 			_test.testname);				       \
 		return;							       \
 	} while (0)

 #define skipped_fail(_test)						       \
 	do {								       \
 		tst_res(TFAIL, "membarrier(2): %s reported as not supported",  \
 			_test.testname);				       \
 		return;							       \
 	} while (0)

 static int sys_membarrier(int cmd, int flags)
 {
 	return tst_syscall(__NR_membarrier, cmd, flags);
 }

 static void verify_membarrier(unsigned int i)
 {
 	int ret;

 	/* not enabled and not enforced: test is skipped */

 	if (!tc[i].enabled && !tc[i].force) {

 		if (tc[i].always == 0)
 			skipped(tc[i]);

 		skipped_fail(tc[i]);
 	}

 	/* iterations: registration needed for some cases */

 	if (tc[i].needregister && tc[i].enabled) {
 		ret = sys_membarrier(tc[i].needregister, 0);
 		if (ret < 0) {
 			tst_brk(TBROK, "membarrier(2): %s could not register",
 					tc[i].testname);
 		}
 	}

 	TEST(sys_membarrier(tc[i].command, tc[i].flags));

 	/* enabled and not enforced: regular expected results only */

 	if (tc[i].enabled && !tc[i].force) {

 		if (TST_RET >= 0 && tc[i].exp_ret == TST_RET)
 			passed_ok(tc[i]);

 		if (TST_RET < 0) {
 			if (tc[i].exp_ret == TST_RET)
 				failed_ok(tc[i]);
 			else
 				failed_not_ok(tc[i], TST_RET, TST_ERR);
 		}
 	}

 	/* not enabled and enforced: failure and expected errors */

 	if (!tc[i].enabled && tc[i].force) {

 		if (TST_RET >= 0)
 			passed_unexpec(tc[i]);

 		if (TST_RET < 0) {
 			if (tc[i].force_exp_errno == TST_ERR)
 				failed_ok_unsupported(tc[i]);
 			else
 				failed_unexpec(tc[i], TST_RET, TST_ERR);
 		}
 	}

 	/* enabled and enforced: tricky */

 	if (tc[i].enabled && tc[i].force) {

 		if (TST_RET >= 0) {
 			if (tc[i].exp_ret == TST_RET)
 				passed_ok(tc[i]);
 			else
 				passed_unexpec(tc[i]);
 		}

 		if (TST_RET < 0) {

 			if (tc[i].exp_ret == TST_RET) {

 				if (tc[i].exp_errno == TST_ERR)
 					failed_ok(tc[i]);
 				else
 					failed_unexpec(tc[i], TST_RET, TST_ERR);
 			}

 			/* unknown on force failure if enabled and forced */
 			failed_unexpec(tc[i], TST_RET, TST_ERR);
 		}
 	}
 }

 static void wrap_verify_membarrier(unsigned int i)
 {
 	pid_t pid;

 	/*
 	 * The Linux kernel does not provide a way to unregister the process
 	 * (mm->membarrier_state) intent of being affected by the membarrier(2)
 	 * system call, thus the need of having a wrapper to fork() a child.
 	 */

 	pid = SAFE_FORK();

 	if (pid)
 		SAFE_WAITPID(pid, NULL, 0);
 	else
 		verify_membarrier(i);
 }

 static void setup(void)
 {
 	size_t i;
 	int ret;

 	ret = sys_membarrier(MEMBARRIER_CMD_QUERY, 0);
 	if (ret < 0) {
 		if (errno == ENOSYS)
 			tst_brk(TBROK, "membarrier(2): not supported");
 	}

 	for (i = 0; i < ARRAY_SIZE(tc); i++) {
 		if ((tc[i].command > 0) && (ret & tc[i].command))
 			tc[i].enabled = 1;

 		/* forcing unsupported command might have different errno */

 		if (tc[i].change_exp_errno && tc[i].enabled == 0) {
 			if (tst_kvercmp(tc[i].change_kernver[0],
 					tc[i].change_kernver[1],
 					tc[i].change_kernver[2]) < 0)
 				tc[i].force_exp_errno = tc[i].change_exp_errno;
 		}
 	}
 }

 static struct tst_test test = {
 	.setup = setup,
 	.test = wrap_verify_membarrier,
 	.tcnt = ARRAY_SIZE(tc),
 	.min_kver = "4.3.0",	/* commit: 5b25b13ab0 (sys_membarrier(): ...) */
 	.forks_child = 1,
 };
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* Copyright (c) 2018 Linaro Limited. All rights reserved.
	* Author: Rafael David Tinoco <rafael.tinoco@linaro.org>
	*/
	/*
	* Basic tests for membarrier(2) syscall. Tests below are responsible for
	* testing the membarrier(2) interface only, without checking if the barrier
	* was successful or not. Check test_case structure for each test description.
	*/

	#include "config.h"
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/wait.h>
	#include <syscall.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <signal.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include "tst_test.h"
	#include "lapi/syscalls.h"
	#include "lapi/membarrier.h"

	struct test_case {
	char testname[80];
	int command; /* membarrier cmd */
	int needregister; /* membarrier cmd needs register cmd */
	int flags; /* flags for given membarrier cmd */
	long exp_ret; /* expected return code for given cmd */
	int exp_errno; /* expected errno for given cmd failure */
	int enabled; /* enabled, despite results from CMD_QUERY */
	int always; /* CMD_QUERY should always enable this test */
	int force; /* force if CMD_QUERY reports not enabled */
	int force_exp_errno; /* expected errno after forced cmd */
	int change_exp_errno; /* previous kernels forced errno result */
	int change_kernver[3]; /* kernel version having diff expected errno */
	};

	struct test_case tc[] = {
	{
	/*
	* case 00) invalid cmd
	* - enabled by default
	* - should always fail with EINVAL
	*/
	.testname = "cmd_fail",
	.command = -1,
	.exp_ret = -1,
	.exp_errno = EINVAL,
	.enabled = 1,
	},
	{
	/*
	* case 01) invalid flags
	* - enabled by default
	* - should always fail with EINVAL
	*/
	.testname = "cmd_flags_fail",
	.command = MEMBARRIER_CMD_QUERY,
	.flags = 1,
	.exp_ret = -1,
	.exp_errno = EINVAL,
	.enabled = 1,
	},
	{
	/*
	* case 02) global barrier
	* - should ALWAYS be enabled by CMD_QUERY
	* - should always succeed
	*/
	.testname = "cmd_global_success",
	.command = MEMBARRIER_CMD_GLOBAL,
	.flags = 0,
	.exp_ret = 0,
	.always = 1,
	},
	/*
	* commit 22e4ebb975 (v4.14-rc1) added cases 03, 04 and 05 features:
	*/
	{
	/*
	* case 03) private expedited barrier with no registrations
	* - should fail with errno=EPERM due to no registrations
	* - or be skipped if unsupported by running kernel
	*/
	.testname = "cmd_private_expedited_fail",
	.command = MEMBARRIER_CMD_PRIVATE_EXPEDITED,
	.flags = 0,
	.exp_ret = -1,
	.exp_errno = EPERM,
	},
	{
	/*
	* case 04) register private expedited
	* - should succeed when supported by running kernel
	* - or fail with errno=EINVAL if unsupported and forced
	*/
	.testname = "cmd_private_expedited_register_success",
	.command = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED,
	.flags = 0,
	.exp_ret = 0,
	.force = 1,
	.force_exp_errno = EINVAL,
	},
	{
	/*
	* case 05) private expedited barrier with registration
	* - should succeed due to existing registration
	* - or fail with errno=EINVAL if unsupported and forced
	* - NOTE: commit 70216e18e5 (v4.16-rc1) changed behavior:
	* - (a) if unsupported, and forced, < 4.16 , errno is EINVAL
	* - (b) if unsupported, and forced, >= 4.16, errno is EPERM
	*/
	.testname = "cmd_private_expedited_success",
	.needregister = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED,
	.command = MEMBARRIER_CMD_PRIVATE_EXPEDITED,
	.flags = 0,
	.exp_ret = 0,
	.force = 1,
	.force_exp_errno = EPERM,
	.change_exp_errno = EINVAL,
	.change_kernver = { 4, 16, 0 },
	},
	/*
	* commit 70216e18e5 (v4.16-rc1) added cases 06, 07 and 08 features:
	*/
	{
	/*
	* case 06) private expedited sync core barrier with no registrations
	* - should fail with errno=EPERM due to no registrations
	* - or be skipped if unsupported by running kernel
	*/
	.testname = "cmd_private_expedited_sync_core_fail",
	.command = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE,
	.flags = 0,
	.exp_ret = -1,
	.exp_errno = EPERM,
	},
	{
	/*
	* case 07) register private expedited sync core
	* - should succeed when supported by running kernel
	* - or fail with errno=EINVAL if unsupported and forced
	*/
	.testname = "cmd_private_expedited_sync_core_register_success",
	.command = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE,
	.flags = 0,
	.exp_ret = 0,
	.force = 1,
	.force_exp_errno = EINVAL,
	},
	{
	/*
	* case 08) private expedited sync core barrier with registration
	* - should succeed due to existing registration
	* - or fail with errno=EINVAL if unsupported and forced
	*/
	.testname = "cmd_private_expedited_sync_core_success",
	.needregister = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE,
	.command = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE,
	.flags = 0,
	.exp_ret = 0,
	.force = 1,
	.force_exp_errno = EINVAL,
	},
	/*
	* commit c5f58bd58f4 (v4.16-rc1) added cases 09, 10 and 11 features:
	*/
	{
	/*
	* case 09) global expedited barrier with no registrations
	* - should never fail due to no registrations
	* - or be skipped if unsupported by running kernel
	*/
	.testname = "cmd_global_expedited_success",
	.command = MEMBARRIER_CMD_GLOBAL_EXPEDITED,
	.flags = 0,
	.exp_ret = 0,
	},
	{
	/*
	* case 10) register global expedited
	* - should succeed when supported by running kernel
	* - or fail with errno=EINVAL if unsupported and forced
	*/
	.testname = "cmd_global_expedited_register_success",
	.command = MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED,
	.flags = 0,
	.exp_ret = 0,
	.force = 1,
	.force_exp_errno = EINVAL,
	},
	{
	/*
	* case 11) global expedited barrier with registration
	* - should also succeed with registrations
	* - or fail with errno=EINVAL if unsupported and forced
	*/
	.testname = "cmd_global_expedited_success",
	.needregister = MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED,
	.command = MEMBARRIER_CMD_GLOBAL_EXPEDITED,
	.flags = 0,
	.exp_ret = 0,
	.force = 1,
	.force_exp_errno = EINVAL,
	},
	};

	#define passed_ok(_test) \
	do { \
	tst_res(TPASS, "membarrier(2): %s passed", _test.testname); \
	return; \
	} while (0)

	#define passed_unexpec(_test) \
	do { \
	tst_res(TFAIL, "membarrier(2): %s passed unexpectedly. " \
	"ret = %ld with errno %d were expected. (force: %d)", \
	_test.testname, _test.exp_ret, _test.exp_errno, \
	_test.force); \
	return; \
	} while (0)

	#define failed_ok(_test) \
	do { \
	tst_res(TPASS, "membarrier(2): %s failed as expected", \
	_test.testname); \
	return; \
	} while (0)

	#define failed_ok_unsupported(_test) \
	do { \
	tst_res(TPASS, "membarrier(2): %s failed as expected " \
	"(unsupported)", _test.testname); \
	return; \
	} while (0)

	#define failed_not_ok(_test, _gotret, _goterr) \
	do { \
	tst_res(TFAIL, "membarrier(2): %s failed. " \
	"ret = %ld when expected was %ld. " \
	"errno = %d when expected was %d. (force: %d)", \
	_test.testname, _gotret, _test.exp_ret, _goterr, \
	_test.exp_errno, _test.force); \
	return; \
	} while (0)

	#define failed_unexpec(_test, _gotret, _goterr) \
	do { \
	tst_res(TFAIL, "membarrier(2): %s failed unexpectedly. " \
	"Got ret = %ld with errno %d. (force: %d)", \
	_test.testname, _gotret, _goterr, _test.force); \
	return; \
	} while (0)

	#define skipped(_test) \
	do { \
	tst_res(TPASS, "membarrier(2): %s skipped (unsupported)", \
	_test.testname); \
	return; \
	} while (0)

	#define skipped_fail(_test) \
	do { \
	tst_res(TFAIL, "membarrier(2): %s reported as not supported", \
	_test.testname); \
	return; \
	} while (0)

	static int sys_membarrier(int cmd, int flags)
	{
	return tst_syscall(__NR_membarrier, cmd, flags);
	}

	static void verify_membarrier(unsigned int i)
	{
	int ret;

	/* not enabled and not enforced: test is skipped */

	if (!tc[i].enabled && !tc[i].force) {

	if (tc[i].always == 0)
	skipped(tc[i]);

	skipped_fail(tc[i]);
	}

	/* iterations: registration needed for some cases */

	if (tc[i].needregister && tc[i].enabled) {
	ret = sys_membarrier(tc[i].needregister, 0);
	if (ret < 0) {
	tst_brk(TBROK, "membarrier(2): %s could not register",
	tc[i].testname);
	}
	}

	TEST(sys_membarrier(tc[i].command, tc[i].flags));

	/* enabled and not enforced: regular expected results only */

	if (tc[i].enabled && !tc[i].force) {

	if (TST_RET >= 0 && tc[i].exp_ret == TST_RET)
	passed_ok(tc[i]);

	if (TST_RET < 0) {
	if (tc[i].exp_ret == TST_RET)
	failed_ok(tc[i]);
	else
	failed_not_ok(tc[i], TST_RET, TST_ERR);
	}
	}

	/* not enabled and enforced: failure and expected errors */

	if (!tc[i].enabled && tc[i].force) {

	if (TST_RET >= 0)
	passed_unexpec(tc[i]);

	if (TST_RET < 0) {
	if (tc[i].force_exp_errno == TST_ERR)
	failed_ok_unsupported(tc[i]);
	else
	failed_unexpec(tc[i], TST_RET, TST_ERR);
	}
	}

	/* enabled and enforced: tricky */

	if (tc[i].enabled && tc[i].force) {

	if (TST_RET >= 0) {
	if (tc[i].exp_ret == TST_RET)
	passed_ok(tc[i]);
	else
	passed_unexpec(tc[i]);
	}

	if (TST_RET < 0) {

	if (tc[i].exp_ret == TST_RET) {

	if (tc[i].exp_errno == TST_ERR)
	failed_ok(tc[i]);
	else
	failed_unexpec(tc[i], TST_RET, TST_ERR);
	}

	/* unknown on force failure if enabled and forced */
	failed_unexpec(tc[i], TST_RET, TST_ERR);
	}
	}
	}

	static void wrap_verify_membarrier(unsigned int i)
	{
	pid_t pid;

	/*
	* The Linux kernel does not provide a way to unregister the process
	* (mm->membarrier_state) intent of being affected by the membarrier(2)
	* system call, thus the need of having a wrapper to fork() a child.
	*/

	pid = SAFE_FORK();

	if (pid)
	SAFE_WAITPID(pid, NULL, 0);
	else
	verify_membarrier(i);
	}

	static void setup(void)
	{
	size_t i;
	int ret;

	ret = sys_membarrier(MEMBARRIER_CMD_QUERY, 0);
	if (ret < 0) {
	if (errno == ENOSYS)
	tst_brk(TBROK, "membarrier(2): not supported");
	}

	for (i = 0; i < ARRAY_SIZE(tc); i++) {
	if ((tc[i].command > 0) && (ret & tc[i].command))
	tc[i].enabled = 1;

	/* forcing unsupported command might have different errno */

	if (tc[i].change_exp_errno && tc[i].enabled == 0) {
	if (tst_kvercmp(tc[i].change_kernver[0],
	tc[i].change_kernver[1],
	tc[i].change_kernver[2]) < 0)
	tc[i].force_exp_errno = tc[i].change_exp_errno;
	}
	}
	}

	static struct tst_test test = {
	.setup = setup,
	.test = wrap_verify_membarrier,
	.tcnt = ARRAY_SIZE(tc),
	.min_kver = "4.3.0", /* commit: 5b25b13ab0 (sys_membarrier(): ...) */
	.forks_child = 1,
	};