Message-ID: <1433807517.3165.32.camel@stgolabs.net>
Date:	Mon, 08 Jun 2015 16:51:57 -0700
From:	Davidlohr Bueso <dave@...olabs.net>
To:	Shuah Khan <shuahkh@....samsung.com>,
	Andrew Morton <akpm@...ux-foundation.org>
Cc:	dave@...olabs.net, linux-kernel@...r.kernel.org
Subject: [PATCH -next] selftests/ipc: Consolidate posix and sysv msg queue
 tests

Move them both in the their own directory, under selftests/ipc/.
As with the actual code, all forms of ipc tend to reside in the
same directory, so apply this to selftests.

Keep the Makefiles (at least for now), with some minor path
hierarchy tweaks, for both msg and mqueue. Add a trivial
ipc/Makefile that simply passes the building to the individual
subdirectory.

Signed-off-by: Davidlohr Bueso <dbueso@...e.de>
---
 tools/testing/selftests/ipc/.gitignore             |   3 +
 tools/testing/selftests/ipc/Makefile               |  32 +-
 tools/testing/selftests/ipc/mqueue/Makefile        |  22 +
 tools/testing/selftests/ipc/mqueue/mq_open_tests.c | 500 ++++++++++++++
 tools/testing/selftests/ipc/mqueue/mq_perf_tests.c | 742 +++++++++++++++++++++
 tools/testing/selftests/ipc/msg/Makefile           |  22 +
 tools/testing/selftests/ipc/msg/msgque.c           | 254 +++++++
 tools/testing/selftests/ipc/msgque.c               | 254 -------
 tools/testing/selftests/mqueue/.gitignore          |   2 -
 tools/testing/selftests/mqueue/Makefile            |  22 -
 tools/testing/selftests/mqueue/mq_open_tests.c     | 500 --------------
 tools/testing/selftests/mqueue/mq_perf_tests.c     | 742 ---------------------
 12 files changed, 1559 insertions(+), 1536 deletions(-)
 create mode 100644 tools/testing/selftests/ipc/.gitignore
 create mode 100644 tools/testing/selftests/ipc/mqueue/Makefile
 create mode 100644 tools/testing/selftests/ipc/mqueue/mq_open_tests.c
 create mode 100644 tools/testing/selftests/ipc/mqueue/mq_perf_tests.c
 create mode 100644 tools/testing/selftests/ipc/msg/Makefile
 create mode 100644 tools/testing/selftests/ipc/msg/msgque.c
 delete mode 100644 tools/testing/selftests/ipc/msgque.c
 delete mode 100644 tools/testing/selftests/mqueue/.gitignore
 delete mode 100644 tools/testing/selftests/mqueue/Makefile
 delete mode 100644 tools/testing/selftests/mqueue/mq_open_tests.c
 delete mode 100644 tools/testing/selftests/mqueue/mq_perf_tests.c

diff --git a/tools/testing/selftests/ipc/.gitignore b/tools/testing/selftests/ipc/.gitignore
new file mode 100644
index 0000000..3d8a449
--- /dev/null
+++ b/tools/testing/selftests/ipc/.gitignore
@@ -0,0 +1,3 @@
+mqueue/mq_open_tests
+mqueue/mq_perf_tests
+msg/msgque_test
diff --git a/tools/testing/selftests/ipc/Makefile b/tools/testing/selftests/ipc/Makefile
index 25d2e70..8686551 100644
--- a/tools/testing/selftests/ipc/Makefile
+++ b/tools/testing/selftests/ipc/Makefile
@@ -1,22 +1,22 @@
-uname_M := $(shell uname -m 2>/dev/null || echo not)
-ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
-ifeq ($(ARCH),i386)
-        ARCH := x86
-	CFLAGS := -DCONFIG_X86_32 -D__i386__
-endif
-ifeq ($(ARCH),x86_64)
-	ARCH := x86
-	CFLAGS := -DCONFIG_X86_64 -D__x86_64__
-endif
-
-CFLAGS += -I../../../../usr/include/
+SUBDIRS := msg
+SUBDIRS += mqueue
 
+.PHONY: all clean
 all:
-	$(CC) $(CFLAGS) msgque.c -o msgque_test
-
-TEST_PROGS := msgque_test
+	for DIR in $(SUBDIRS); do $(MAKE) -C $$DIR $@ ; done
 
 include ../lib.mk
+override define RUN_TESTS
+	for DIR in $(SUBDIRS); do $(MAKE) -C $$DIR $@ ; done
+endef
+
+override define INSTALL_RULE
+	for DIR in $(SUBDIRS); do $(MAKE) -C $$DIR $@ ; done
+endef
+
+override define EMIT_TESTS
+	for DIR in $(SUBDIRS); do $(MAKE) -C $$DIR $@ ; done
+endef
 
 clean:
-	rm -fr ./msgque_test
+	for DIR in $(SUBDIRS); do $(MAKE) -C $$DIR $@ ; done
diff --git a/tools/testing/selftests/ipc/mqueue/Makefile b/tools/testing/selftests/ipc/mqueue/Makefile
new file mode 100644
index 0000000..1fa56ea
--- /dev/null
+++ b/tools/testing/selftests/ipc/mqueue/Makefile
@@ -0,0 +1,22 @@
+CFLAGS = -O2
+
+all:
+	$(CC) $(CFLAGS) mq_open_tests.c -o mq_open_tests -lrt
+	$(CC) $(CFLAGS) -o mq_perf_tests mq_perf_tests.c -lrt -lpthread -lpopt
+
+include ../../lib.mk
+
+override define RUN_TESTS
+	@./mq_open_tests /test1 || echo "selftests: mq_open_tests [FAIL]"
+	@./mq_perf_tests || echo "selftests: mq_perf_tests [FAIL]"
+endef
+
+TEST_PROGS := mq_open_tests mq_perf_tests
+
+override define EMIT_TESTS
+	echo "./mq_open_tests /test1 || echo \"selftests: mq_open_tests [FAIL]\""
+	echo "./mq_perf_tests || echo \"selftests: mq_perf_tests [FAIL]\""
+endef
+
+clean:
+	rm -f mq_open_tests mq_perf_tests
diff --git a/tools/testing/selftests/ipc/mqueue/mq_open_tests.c b/tools/testing/selftests/ipc/mqueue/mq_open_tests.c
new file mode 100644
index 0000000..9c1a5d35
--- /dev/null
+++ b/tools/testing/selftests/ipc/mqueue/mq_open_tests.c
@@ -0,0 +1,500 @@
+/*
+ * This application is Copyright 2012 Red Hat, Inc.
+ *	Doug Ledford <dledford@...hat.com>
+ *
+ * mq_open_tests is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * mq_open_tests is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * For the full text of the license, see <http://www.gnu.org/licenses/>.
+ *
+ * mq_open_tests.c
+ *   Tests the various situations that should either succeed or fail to
+ *   open a posix message queue and then reports whether or not they
+ *   did as they were supposed to.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <mqueue.h>
+
+static char *usage =
+"Usage:\n"
+"  %s path\n"
+"\n"
+"	path	Path name of the message queue to create\n"
+"\n"
+"	Note: this program must be run as root in order to enable all tests\n"
+"\n";
+
+char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
+char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
+char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
+char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
+
+int default_settings;
+struct rlimit saved_limits, cur_limits;
+int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
+int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
+FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
+char *queue_path;
+mqd_t queue = -1;
+
+static inline void __set(FILE *stream, int value, char *err_msg);
+void shutdown(int exit_val, char *err_cause, int line_no);
+static inline int get(FILE *stream);
+static inline void set(FILE *stream, int value);
+static inline void getr(int type, struct rlimit *rlim);
+static inline void setr(int type, struct rlimit *rlim);
+void validate_current_settings();
+static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
+static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);
+
+static inline void __set(FILE *stream, int value, char *err_msg)
+{
+	rewind(stream);
+	if (fprintf(stream, "%d", value) < 0)
+		perror(err_msg);
+}
+
+
+void shutdown(int exit_val, char *err_cause, int line_no)
+{
+	static int in_shutdown = 0;
+
+	/* In case we get called recursively by a set() call below */
+	if (in_shutdown++)
+		return;
+
+	if (seteuid(0) == -1)
+		perror("seteuid() failed");
+
+	if (queue != -1)
+		if (mq_close(queue))
+			perror("mq_close() during shutdown");
+	if (queue_path)
+		/*
+		 * Be silent if this fails, if we cleaned up already it's
+		 * expected to fail
+		 */
+		mq_unlink(queue_path);
+	if (default_settings) {
+		if (saved_def_msgs)
+			__set(def_msgs, saved_def_msgs,
+			      "failed to restore saved_def_msgs");
+		if (saved_def_msgsize)
+			__set(def_msgsize, saved_def_msgsize,
+			      "failed to restore saved_def_msgsize");
+	}
+	if (saved_max_msgs)
+		__set(max_msgs, saved_max_msgs,
+		      "failed to restore saved_max_msgs");
+	if (saved_max_msgsize)
+		__set(max_msgsize, saved_max_msgsize,
+		      "failed to restore saved_max_msgsize");
+	if (exit_val)
+		error(exit_val, errno, "%s at %d", err_cause, line_no);
+	exit(0);
+}
+
+static inline int get(FILE *stream)
+{
+	int value;
+	rewind(stream);
+	if (fscanf(stream, "%d", &value) != 1)
+		shutdown(4, "Error reading /proc entry", __LINE__ - 1);
+	return value;
+}
+
+static inline void set(FILE *stream, int value)
+{
+	int new_value;
+
+	rewind(stream);
+	if (fprintf(stream, "%d", value) < 0)
+		return shutdown(5, "Failed writing to /proc file",
+				__LINE__ - 1);
+	new_value = get(stream);
+	if (new_value != value)
+		return shutdown(5, "We didn't get what we wrote to /proc back",
+				__LINE__ - 1);
+}
+
+static inline void getr(int type, struct rlimit *rlim)
+{
+	if (getrlimit(type, rlim))
+		shutdown(6, "getrlimit()", __LINE__ - 1);
+}
+
+static inline void setr(int type, struct rlimit *rlim)
+{
+	if (setrlimit(type, rlim))
+		shutdown(7, "setrlimit()", __LINE__ - 1);
+}
+
+void validate_current_settings()
+{
+	int rlim_needed;
+
+	if (cur_limits.rlim_cur < 4096) {
+		printf("Current rlimit value for POSIX message queue bytes is "
+		       "unreasonably low,\nincreasing.\n\n");
+		cur_limits.rlim_cur = 8192;
+		cur_limits.rlim_max = 16384;
+		setr(RLIMIT_MSGQUEUE, &cur_limits);
+	}
+
+	if (default_settings) {
+		rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
+						    2 * sizeof(void *));
+		if (rlim_needed > cur_limits.rlim_cur) {
+			printf("Temporarily lowering default queue parameters "
+			       "to something that will work\n"
+			       "with the current rlimit values.\n\n");
+			set(def_msgs, 10);
+			cur_def_msgs = 10;
+			set(def_msgsize, 128);
+			cur_def_msgsize = 128;
+		}
+	} else {
+		rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
+						    2 * sizeof(void *));
+		if (rlim_needed > cur_limits.rlim_cur) {
+			printf("Temporarily lowering maximum queue parameters "
+			       "to something that will work\n"
+			       "with the current rlimit values in case this is "
+			       "a kernel that ties the default\n"
+			       "queue parameters to the maximum queue "
+			       "parameters.\n\n");
+			set(max_msgs, 10);
+			cur_max_msgs = 10;
+			set(max_msgsize, 128);
+			cur_max_msgsize = 128;
+		}
+	}
+}
+
+/*
+ * test_queue - Test opening a queue, shutdown if we fail.  This should
+ * only be called in situations that should never fail.  We clean up
+ * after ourselves and return the queue attributes in *result.
+ */
+static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
+{
+	int flags = O_RDWR | O_EXCL | O_CREAT;
+	int perms = DEFFILEMODE;
+
+	if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
+		shutdown(1, "mq_open()", __LINE__);
+	if (mq_getattr(queue, result))
+		shutdown(1, "mq_getattr()", __LINE__);
+	if (mq_close(queue))
+		shutdown(1, "mq_close()", __LINE__);
+	queue = -1;
+	if (mq_unlink(queue_path))
+		shutdown(1, "mq_unlink()", __LINE__);
+}
+
+/*
+ * Same as test_queue above, but failure is not fatal.
+ * Returns:
+ * 0 - Failed to create a queue
+ * 1 - Created a queue, attributes in *result
+ */
+static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result)
+{
+	int flags = O_RDWR | O_EXCL | O_CREAT;
+	int perms = DEFFILEMODE;
+
+	if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
+		return 0;
+	if (mq_getattr(queue, result))
+		shutdown(1, "mq_getattr()", __LINE__);
+	if (mq_close(queue))
+		shutdown(1, "mq_close()", __LINE__);
+	queue = -1;
+	if (mq_unlink(queue_path))
+		shutdown(1, "mq_unlink()", __LINE__);
+	return 1;
+}
+
+int main(int argc, char *argv[])
+{
+	struct mq_attr attr, result;
+
+	if (argc != 2) {
+		fprintf(stderr, "Must pass a valid queue name\n\n");
+		fprintf(stderr, usage, argv[0]);
+		exit(1);
+	}
+
+	/*
+	 * Although we can create a msg queue with a non-absolute path name,
+	 * unlink will fail.  So, if the name doesn't start with a /, add one
+	 * when we save it.
+	 */
+	if (*argv[1] == '/')
+		queue_path = strdup(argv[1]);
+	else {
+		queue_path = malloc(strlen(argv[1]) + 2);
+		if (!queue_path) {
+			perror("malloc()");
+			exit(1);
+		}
+		queue_path[0] = '/';
+		queue_path[1] = 0;
+		strcat(queue_path, argv[1]);
+	}
+
+	if (getuid() != 0) {
+		fprintf(stderr, "Not running as root, but almost all tests "
+			"require root in order to modify\nsystem settings.  "
+			"Exiting.\n");
+		exit(1);
+	}
+
+	/* Find out what files there are for us to make tweaks in */
+	def_msgs = fopen(DEF_MSGS, "r+");
+	def_msgsize = fopen(DEF_MSGSIZE, "r+");
+	max_msgs = fopen(MAX_MSGS, "r+");
+	max_msgsize = fopen(MAX_MSGSIZE, "r+");
+
+	if (!max_msgs)
+		shutdown(2, "Failed to open msg_max", __LINE__);
+	if (!max_msgsize)
+		shutdown(2, "Failed to open msgsize_max", __LINE__);
+	if (def_msgs || def_msgsize)
+		default_settings = 1;
+
+	/* Load up the current system values for everything we can */
+	getr(RLIMIT_MSGQUEUE, &saved_limits);
+	cur_limits = saved_limits;
+	if (default_settings) {
+		saved_def_msgs = cur_def_msgs = get(def_msgs);
+		saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
+	}
+	saved_max_msgs = cur_max_msgs = get(max_msgs);
+	saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
+
+	/* Tell the user our initial state */
+	printf("\nInitial system state:\n");
+	printf("\tUsing queue path:\t\t%s\n", queue_path);
+	printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n",
+		(long) saved_limits.rlim_cur);
+	printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n",
+		(long) saved_limits.rlim_max);
+	printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
+	printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
+	if (default_settings) {
+		printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
+		printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
+	} else {
+		printf("\tDefault Message Size:\t\tNot Supported\n");
+		printf("\tDefault Queue Size:\t\tNot Supported\n");
+	}
+	printf("\n");
+
+	validate_current_settings();
+
+	printf("Adjusted system state for testing:\n");
+	printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n", (long) cur_limits.rlim_cur);
+	printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n", (long) cur_limits.rlim_max);
+	printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
+	printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
+	if (default_settings) {
+		printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
+		printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
+	}
+
+	printf("\n\nTest series 1, behavior when no attr struct "
+	       "passed to mq_open:\n");
+	if (!default_settings) {
+		test_queue(NULL, &result);
+		printf("Given sane system settings, mq_open without an attr "
+		       "struct succeeds:\tPASS\n");
+		if (result.mq_maxmsg != cur_max_msgs ||
+		    result.mq_msgsize != cur_max_msgsize) {
+			printf("Kernel does not support setting the default "
+			       "mq attributes,\nbut also doesn't tie the "
+			       "defaults to the maximums:\t\t\tPASS\n");
+		} else {
+			set(max_msgs, ++cur_max_msgs);
+			set(max_msgsize, ++cur_max_msgsize);
+			test_queue(NULL, &result);
+			if (result.mq_maxmsg == cur_max_msgs &&
+			    result.mq_msgsize == cur_max_msgsize)
+				printf("Kernel does not support setting the "
+				       "default mq attributes and\n"
+				       "also ties system wide defaults to "
+				       "the system wide maximums:\t\t"
+				       "FAIL\n");
+			else
+				printf("Kernel does not support setting the "
+				       "default mq attributes,\n"
+				       "but also doesn't tie the defaults to "
+				       "the maximums:\t\t\tPASS\n");
+		}
+	} else {
+		printf("Kernel supports setting defaults separately from "
+		       "maximums:\t\tPASS\n");
+		/*
+		 * While we are here, go ahead and test that the kernel
+		 * properly follows the default settings
+		 */
+		test_queue(NULL, &result);
+		printf("Given sane values, mq_open without an attr struct "
+		       "succeeds:\t\tPASS\n");
+		if (result.mq_maxmsg != cur_def_msgs ||
+		    result.mq_msgsize != cur_def_msgsize)
+			printf("Kernel supports setting defaults, but does "
+			       "not actually honor them:\tFAIL\n\n");
+		else {
+			set(def_msgs, ++cur_def_msgs);
+			set(def_msgsize, ++cur_def_msgsize);
+			/* In case max was the same as the default */
+			set(max_msgs, ++cur_max_msgs);
+			set(max_msgsize, ++cur_max_msgsize);
+			test_queue(NULL, &result);
+			if (result.mq_maxmsg != cur_def_msgs ||
+			    result.mq_msgsize != cur_def_msgsize)
+				printf("Kernel supports setting defaults, but "
+				       "does not actually honor them:\t"
+				       "FAIL\n");
+			else
+				printf("Kernel properly honors default setting "
+				       "knobs:\t\t\t\tPASS\n");
+		}
+		set(def_msgs, cur_max_msgs + 1);
+		cur_def_msgs = cur_max_msgs + 1;
+		set(def_msgsize, cur_max_msgsize + 1);
+		cur_def_msgsize = cur_max_msgsize + 1;
+		if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
+		    cur_limits.rlim_cur) {
+			cur_limits.rlim_cur = (cur_def_msgs + 2) *
+				(cur_def_msgsize + 2 * sizeof(void *));
+			cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
+			setr(RLIMIT_MSGQUEUE, &cur_limits);
+		}
+		if (test_queue_fail(NULL, &result)) {
+			if (result.mq_maxmsg == cur_max_msgs &&
+			    result.mq_msgsize == cur_max_msgsize)
+				printf("Kernel properly limits default values "
+				       "to lesser of default/max:\t\tPASS\n");
+			else
+				printf("Kernel does not properly set default "
+				       "queue parameters when\ndefaults > "
+				       "max:\t\t\t\t\t\t\t\tFAIL\n");
+		} else
+			printf("Kernel fails to open mq because defaults are "
+			       "greater than maximums:\tFAIL\n");
+		set(def_msgs, --cur_def_msgs);
+		set(def_msgsize, --cur_def_msgsize);
+		cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
+			cur_def_msgsize;
+		setr(RLIMIT_MSGQUEUE, &cur_limits);
+		if (test_queue_fail(NULL, &result))
+			printf("Kernel creates queue even though defaults "
+			       "would exceed\nrlimit setting:"
+			       "\t\t\t\t\t\t\t\tFAIL\n");
+		else
+			printf("Kernel properly fails to create queue when "
+			       "defaults would\nexceed rlimit:"
+			       "\t\t\t\t\t\t\t\tPASS\n");
+	}
+
+	/*
+	 * Test #2 - open with an attr struct that exceeds rlimit
+	 */
+	printf("\n\nTest series 2, behavior when attr struct is "
+	       "passed to mq_open:\n");
+	cur_max_msgs = 32;
+	cur_max_msgsize = cur_limits.rlim_max >> 4;
+	set(max_msgs, cur_max_msgs);
+	set(max_msgsize, cur_max_msgsize);
+	attr.mq_maxmsg = cur_max_msgs;
+	attr.mq_msgsize = cur_max_msgsize;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open in excess of rlimit max when euid = 0 "
+		       "succeeded:\t\tFAIL\n");
+	else
+		printf("Queue open in excess of rlimit max when euid = 0 "
+		       "failed:\t\tPASS\n");
+	attr.mq_maxmsg = cur_max_msgs + 1;
+	attr.mq_msgsize = 10;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open with mq_maxmsg > limit when euid = 0 "
+		       "succeeded:\t\tPASS\n");
+	else
+		printf("Queue open with mq_maxmsg > limit when euid = 0 "
+		       "failed:\t\tFAIL\n");
+	attr.mq_maxmsg = 1;
+	attr.mq_msgsize = cur_max_msgsize + 1;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open with mq_msgsize > limit when euid = 0 "
+		       "succeeded:\t\tPASS\n");
+	else
+		printf("Queue open with mq_msgsize > limit when euid = 0 "
+		       "failed:\t\tFAIL\n");
+	attr.mq_maxmsg = 65536;
+	attr.mq_msgsize = 65536;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open with total size > 2GB when euid = 0 "
+		       "succeeded:\t\tFAIL\n");
+	else
+		printf("Queue open with total size > 2GB when euid = 0 "
+		       "failed:\t\t\tPASS\n");
+
+	if (seteuid(99) == -1) {
+		perror("seteuid() failed");
+		exit(1);
+	}
+
+	attr.mq_maxmsg = cur_max_msgs;
+	attr.mq_msgsize = cur_max_msgsize;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open in excess of rlimit max when euid = 99 "
+		       "succeeded:\t\tFAIL\n");
+	else
+		printf("Queue open in excess of rlimit max when euid = 99 "
+		       "failed:\t\tPASS\n");
+	attr.mq_maxmsg = cur_max_msgs + 1;
+	attr.mq_msgsize = 10;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open with mq_maxmsg > limit when euid = 99 "
+		       "succeeded:\t\tFAIL\n");
+	else
+		printf("Queue open with mq_maxmsg > limit when euid = 99 "
+		       "failed:\t\tPASS\n");
+	attr.mq_maxmsg = 1;
+	attr.mq_msgsize = cur_max_msgsize + 1;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open with mq_msgsize > limit when euid = 99 "
+		       "succeeded:\t\tFAIL\n");
+	else
+		printf("Queue open with mq_msgsize > limit when euid = 99 "
+		       "failed:\t\tPASS\n");
+	attr.mq_maxmsg = 65536;
+	attr.mq_msgsize = 65536;
+	if (test_queue_fail(&attr, &result))
+		printf("Queue open with total size > 2GB when euid = 99 "
+		       "succeeded:\t\tFAIL\n");
+	else
+		printf("Queue open with total size > 2GB when euid = 99 "
+		       "failed:\t\t\tPASS\n");
+
+	shutdown(0,"",0);
+}
diff --git a/tools/testing/selftests/ipc/mqueue/mq_perf_tests.c b/tools/testing/selftests/ipc/mqueue/mq_perf_tests.c
new file mode 100644
index 0000000..8519e9e
--- /dev/null
+++ b/tools/testing/selftests/ipc/mqueue/mq_perf_tests.c
@@ -0,0 +1,742 @@
+/*
+ * This application is Copyright 2012 Red Hat, Inc.
+ *	Doug Ledford <dledford@...hat.com>
+ *
+ * mq_perf_tests is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * mq_perf_tests is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * For the full text of the license, see <http://www.gnu.org/licenses/>.
+ *
+ * mq_perf_tests.c
+ *   Tests various types of message queue workloads, concentrating on those
+ *   situations that invole large message sizes, large message queue depths,
+ *   or both, and reports back useful metrics about kernel message queue
+ *   performance.
+ *
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <signal.h>
+#include <pthread.h>
+#include <sched.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <mqueue.h>
+#include <popt.h>
+
+static char *usage =
+"Usage:\n"
+"  %s [-c #[,#..] -f] path\n"
+"\n"
+"	-c #	Skip most tests and go straight to a high queue depth test\n"
+"		and then run that test continuously (useful for running at\n"
+"		the same time as some other workload to see how much the\n"
+"		cache thrashing caused by adding messages to a very deep\n"
+"		queue impacts the performance of other programs).  The number\n"
+"		indicates which CPU core we should bind the process to during\n"
+"		the run.  If you have more than one physical CPU, then you\n"
+"		will need one copy per physical CPU package, and you should\n"
+"		specify the CPU cores to pin ourself to via a comma separated\n"
+"		list of CPU values.\n"
+"	-f	Only usable with continuous mode.  Pin ourself to the CPUs\n"
+"		as requested, then instead of looping doing a high mq\n"
+"		workload, just busy loop.  This will allow us to lock up a\n"
+"		single CPU just like we normally would, but without actually\n"
+"		thrashing the CPU cache.  This is to make it easier to get\n"
+"		comparable numbers from some other workload running on the\n"
+"		other CPUs.  One set of numbers with # CPUs locked up running\n"
+"		an mq workload, and another set of numbers with those same\n"
+"		CPUs locked away from the test workload, but not doing\n"
+"		anything to trash the cache like the mq workload might.\n"
+"	path	Path name of the message queue to create\n"
+"\n"
+"	Note: this program must be run as root in order to enable all tests\n"
+"\n";
+
+char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
+char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define MAX_CPUS 64
+char *cpu_option_string;
+int cpus_to_pin[MAX_CPUS];
+int num_cpus_to_pin;
+pthread_t cpu_threads[MAX_CPUS];
+pthread_t main_thread;
+cpu_set_t *cpu_set;
+int cpu_set_size;
+int cpus_online;
+
+#define MSG_SIZE 16
+#define TEST1_LOOPS 10000000
+#define TEST2_LOOPS 100000
+int continuous_mode;
+int continuous_mode_fake;
+
+struct rlimit saved_limits, cur_limits;
+int saved_max_msgs, saved_max_msgsize;
+int cur_max_msgs, cur_max_msgsize;
+FILE *max_msgs, *max_msgsize;
+int cur_nice;
+char *queue_path = "/mq_perf_tests";
+mqd_t queue = -1;
+struct mq_attr result;
+int mq_prio_max;
+
+const struct poptOption options[] = {
+	{
+		.longName = "continuous",
+		.shortName = 'c',
+		.argInfo = POPT_ARG_STRING,
+		.arg = &cpu_option_string,
+		.val = 'c',
+		.descrip = "Run continuous tests at a high queue depth in "
+			"order to test the effects of cache thrashing on "
+			"other tasks on the system.  This test is intended "
+			"to be run on one core of each physical CPU while "
+			"some other CPU intensive task is run on all the other "
+			"cores of that same physical CPU and the other task "
+			"is timed.  It is assumed that the process of adding "
+			"messages to the message queue in a tight loop will "
+			"impact that other task to some degree.  Once the "
+			"tests are performed in this way, you should then "
+			"re-run the tests using fake mode in order to check "
+			"the difference in time required to perform the CPU "
+			"intensive task",
+		.argDescrip = "cpu[,cpu]",
+	},
+	{
+		.longName = "fake",
+		.shortName = 'f',
+		.argInfo = POPT_ARG_NONE,
+		.arg = &continuous_mode_fake,
+		.val = 0,
+		.descrip = "Tie up the CPUs that we would normally tie up in"
+			"continuous mode, but don't actually do any mq stuff, "
+			"just keep the CPU busy so it can't be used to process "
+			"system level tasks as this would free up resources on "
+			"the other CPU cores and skew the comparison between "
+			"the no-mqueue work and mqueue work tests",
+		.argDescrip = NULL,
+	},
+	{
+		.longName = "path",
+		.shortName = 'p',
+		.argInfo = POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT,
+		.arg = &queue_path,
+		.val = 'p',
+		.descrip = "The name of the path to use in the mqueue "
+			"filesystem for our tests",
+		.argDescrip = "pathname",
+	},
+	POPT_AUTOHELP
+	POPT_TABLEEND
+};
+
+static inline void __set(FILE *stream, int value, char *err_msg);
+void shutdown(int exit_val, char *err_cause, int line_no);
+void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context);
+void sig_action(int signum, siginfo_t *info, void *context);
+static inline int get(FILE *stream);
+static inline void set(FILE *stream, int value);
+static inline int try_set(FILE *stream, int value);
+static inline void getr(int type, struct rlimit *rlim);
+static inline void setr(int type, struct rlimit *rlim);
+static inline void open_queue(struct mq_attr *attr);
+void increase_limits(void);
+
+static inline void __set(FILE *stream, int value, char *err_msg)
+{
+	rewind(stream);
+	if (fprintf(stream, "%d", value) < 0)
+		perror(err_msg);
+}
+
+
+void shutdown(int exit_val, char *err_cause, int line_no)
+{
+	static int in_shutdown = 0;
+	int errno_at_shutdown = errno;
+	int i;
+
+	/* In case we get called by multiple threads or from an sighandler */
+	if (in_shutdown++)
+		return;
+
+	for (i = 0; i < num_cpus_to_pin; i++)
+		if (cpu_threads[i]) {
+			pthread_kill(cpu_threads[i], SIGUSR1);
+			pthread_join(cpu_threads[i], NULL);
+		}
+
+	if (queue != -1)
+		if (mq_close(queue))
+			perror("mq_close() during shutdown");
+	if (queue_path)
+		/*
+		 * Be silent if this fails, if we cleaned up already it's
+		 * expected to fail
+		 */
+		mq_unlink(queue_path);
+	if (saved_max_msgs)
+		__set(max_msgs, saved_max_msgs,
+		      "failed to restore saved_max_msgs");
+	if (saved_max_msgsize)
+		__set(max_msgsize, saved_max_msgsize,
+		      "failed to restore saved_max_msgsize");
+	if (exit_val)
+		error(exit_val, errno_at_shutdown, "%s at %d",
+		      err_cause, line_no);
+	exit(0);
+}
+
+void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context)
+{
+	if (pthread_self() != main_thread)
+		pthread_exit(0);
+	else {
+		fprintf(stderr, "Caught signal %d in SIGUSR1 handler, "
+				"exiting\n", signum);
+		shutdown(0, "", 0);
+		fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
+		exit(0);
+	}
+}
+
+void sig_action(int signum, siginfo_t *info, void *context)
+{
+	if (pthread_self() != main_thread)
+		pthread_kill(main_thread, signum);
+	else {
+		fprintf(stderr, "Caught signal %d, exiting\n", signum);
+		shutdown(0, "", 0);
+		fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
+		exit(0);
+	}
+}
+
+static inline int get(FILE *stream)
+{
+	int value;
+	rewind(stream);
+	if (fscanf(stream, "%d", &value) != 1)
+		shutdown(4, "Error reading /proc entry", __LINE__);
+	return value;
+}
+
+static inline void set(FILE *stream, int value)
+{
+	int new_value;
+
+	rewind(stream);
+	if (fprintf(stream, "%d", value) < 0)
+		return shutdown(5, "Failed writing to /proc file", __LINE__);
+	new_value = get(stream);
+	if (new_value != value)
+		return shutdown(5, "We didn't get what we wrote to /proc back",
+				__LINE__);
+}
+
+static inline int try_set(FILE *stream, int value)
+{
+	int new_value;
+
+	rewind(stream);
+	fprintf(stream, "%d", value);
+	new_value = get(stream);
+	return new_value == value;
+}
+
+static inline void getr(int type, struct rlimit *rlim)
+{
+	if (getrlimit(type, rlim))
+		shutdown(6, "getrlimit()", __LINE__);
+}
+
+static inline void setr(int type, struct rlimit *rlim)
+{
+	if (setrlimit(type, rlim))
+		shutdown(7, "setrlimit()", __LINE__);
+}
+
+/**
+ * open_queue - open the global queue for testing
+ * @attr - An attr struct specifying the desired queue traits
+ * @result - An attr struct that lists the actual traits the queue has
+ *
+ * This open is not allowed to fail, failure will result in an orderly
+ * shutdown of the program.  The global queue_path is used to set what
+ * queue to open, the queue descriptor is saved in the global queue
+ * variable.
+ */
+static inline void open_queue(struct mq_attr *attr)
+{
+	int flags = O_RDWR | O_EXCL | O_CREAT | O_NONBLOCK;
+	int perms = DEFFILEMODE;
+
+	queue = mq_open(queue_path, flags, perms, attr);
+	if (queue == -1)
+		shutdown(1, "mq_open()", __LINE__);
+	if (mq_getattr(queue, &result))
+		shutdown(1, "mq_getattr()", __LINE__);
+	printf("\n\tQueue %s created:\n", queue_path);
+	printf("\t\tmq_flags:\t\t\t%s\n", result.mq_flags & O_NONBLOCK ?
+	       "O_NONBLOCK" : "(null)");
+	printf("\t\tmq_maxmsg:\t\t\t%lu\n", result.mq_maxmsg);
+	printf("\t\tmq_msgsize:\t\t\t%lu\n", result.mq_msgsize);
+	printf("\t\tmq_curmsgs:\t\t\t%lu\n", result.mq_curmsgs);
+}
+
+void *fake_cont_thread(void *arg)
+{
+	int i;
+
+	for (i = 0; i < num_cpus_to_pin; i++)
+		if (cpu_threads[i] == pthread_self())
+			break;
+	printf("\tStarted fake continuous mode thread %d on CPU %d\n", i,
+	       cpus_to_pin[i]);
+	while (1)
+		;
+}
+
+void *cont_thread(void *arg)
+{
+	char buff[MSG_SIZE];
+	int i, priority;
+
+	for (i = 0; i < num_cpus_to_pin; i++)
+		if (cpu_threads[i] == pthread_self())
+			break;
+	printf("\tStarted continuous mode thread %d on CPU %d\n", i,
+	       cpus_to_pin[i]);
+	while (1) {
+		while (mq_send(queue, buff, sizeof(buff), 0) == 0)
+			;
+		mq_receive(queue, buff, sizeof(buff), &priority);
+	}
+}
+
+#define drain_queue() \
+	while (mq_receive(queue, buff, MSG_SIZE, &prio_in) == MSG_SIZE)
+
+#define do_untimed_send() \
+	do { \
+		if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
+			shutdown(3, "Test send failure", __LINE__); \
+	} while (0)
+
+#define do_send_recv() \
+	do { \
+		clock_gettime(clock, &start); \
+		if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
+			shutdown(3, "Test send failure", __LINE__); \
+		clock_gettime(clock, &middle); \
+		if (mq_receive(queue, buff, MSG_SIZE, &prio_in) != MSG_SIZE) \
+			shutdown(3, "Test receive failure", __LINE__); \
+		clock_gettime(clock, &end); \
+		nsec = ((middle.tv_sec - start.tv_sec) * 1000000000) + \
+			(middle.tv_nsec - start.tv_nsec); \
+		send_total.tv_nsec += nsec; \
+		if (send_total.tv_nsec >= 1000000000) { \
+			send_total.tv_sec++; \
+			send_total.tv_nsec -= 1000000000; \
+		} \
+		nsec = ((end.tv_sec - middle.tv_sec) * 1000000000) + \
+			(end.tv_nsec - middle.tv_nsec); \
+		recv_total.tv_nsec += nsec; \
+		if (recv_total.tv_nsec >= 1000000000) { \
+			recv_total.tv_sec++; \
+			recv_total.tv_nsec -= 1000000000; \
+		} \
+	} while (0)
+
+struct test {
+	char *desc;
+	void (*func)(int *);
+};
+
+void const_prio(int *prio)
+{
+	return;
+}
+
+void inc_prio(int *prio)
+{
+	if (++*prio == mq_prio_max)
+		*prio = 0;
+}
+
+void dec_prio(int *prio)
+{
+	if (--*prio < 0)
+		*prio = mq_prio_max - 1;
+}
+
+void random_prio(int *prio)
+{
+	*prio = random() % mq_prio_max;
+}
+
+struct test test2[] = {
+	{"\n\tTest #2a: Time send/recv message, queue full, constant prio\n",
+		const_prio},
+	{"\n\tTest #2b: Time send/recv message, queue full, increasing prio\n",
+		inc_prio},
+	{"\n\tTest #2c: Time send/recv message, queue full, decreasing prio\n",
+		dec_prio},
+	{"\n\tTest #2d: Time send/recv message, queue full, random prio\n",
+		random_prio},
+	{NULL, NULL}
+};
+
+/**
+ * Tests to perform (all done with MSG_SIZE messages):
+ *
+ * 1) Time to add/remove message with 0 messages on queue
+ * 1a) with constant prio
+ * 2) Time to add/remove message when queue close to capacity:
+ * 2a) with constant prio
+ * 2b) with increasing prio
+ * 2c) with decreasing prio
+ * 2d) with random prio
+ * 3) Test limits of priorities honored (double check _SC_MQ_PRIO_MAX)
+ */
+void *perf_test_thread(void *arg)
+{
+	char buff[MSG_SIZE];
+	int prio_out, prio_in;
+	int i;
+	clockid_t clock;
+	pthread_t *t;
+	struct timespec res, start, middle, end, send_total, recv_total;
+	unsigned long long nsec;
+	struct test *cur_test;
+
+	t = &cpu_threads[0];
+	printf("\n\tStarted mqueue performance test thread on CPU %d\n",
+	       cpus_to_pin[0]);
+	mq_prio_max = sysconf(_SC_MQ_PRIO_MAX);
+	if (mq_prio_max == -1)
+		shutdown(2, "sysconf(_SC_MQ_PRIO_MAX)", __LINE__);
+	if (pthread_getcpuclockid(cpu_threads[0], &clock) != 0)
+		shutdown(2, "pthread_getcpuclockid", __LINE__);
+
+	if (clock_getres(clock, &res))
+		shutdown(2, "clock_getres()", __LINE__);
+
+	printf("\t\tMax priorities:\t\t\t%d\n", mq_prio_max);
+	printf("\t\tClock resolution:\t\t%lu nsec%s\n", res.tv_nsec,
+	       res.tv_nsec > 1 ? "s" : "");
+
+
+
+	printf("\n\tTest #1: Time send/recv message, queue empty\n");
+	printf("\t\t(%d iterations)\n", TEST1_LOOPS);
+	prio_out = 0;
+	send_total.tv_sec = 0;
+	send_total.tv_nsec = 0;
+	recv_total.tv_sec = 0;
+	recv_total.tv_nsec = 0;
+	for (i = 0; i < TEST1_LOOPS; i++)
+		do_send_recv();
+	printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
+	       send_total.tv_sec, send_total.tv_nsec);
+	nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
+		 send_total.tv_nsec) / TEST1_LOOPS;
+	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
+	printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
+	       recv_total.tv_sec, recv_total.tv_nsec);
+	nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
+		recv_total.tv_nsec) / TEST1_LOOPS;
+	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
+
+
+	for (cur_test = test2; cur_test->desc != NULL; cur_test++) {
+		printf("%s:\n", cur_test->desc);
+		printf("\t\t(%d iterations)\n", TEST2_LOOPS);
+		prio_out = 0;
+		send_total.tv_sec = 0;
+		send_total.tv_nsec = 0;
+		recv_total.tv_sec = 0;
+		recv_total.tv_nsec = 0;
+		printf("\t\tFilling queue...");
+		fflush(stdout);
+		clock_gettime(clock, &start);
+		for (i = 0; i < result.mq_maxmsg - 1; i++) {
+			do_untimed_send();
+			cur_test->func(&prio_out);
+		}
+		clock_gettime(clock, &end);
+		nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
+			1000000000) + (end.tv_nsec - start.tv_nsec);
+		printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
+		       nsec % 1000000000);
+		printf("\t\tTesting...");
+		fflush(stdout);
+		for (i = 0; i < TEST2_LOOPS; i++) {
+			do_send_recv();
+			cur_test->func(&prio_out);
+		}
+		printf("done.\n");
+		printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
+		       send_total.tv_sec, send_total.tv_nsec);
+		nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
+			 send_total.tv_nsec) / TEST2_LOOPS;
+		printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
+		printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
+		       recv_total.tv_sec, recv_total.tv_nsec);
+		nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
+			recv_total.tv_nsec) / TEST2_LOOPS;
+		printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
+		printf("\t\tDraining queue...");
+		fflush(stdout);
+		clock_gettime(clock, &start);
+		drain_queue();
+		clock_gettime(clock, &end);
+		nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
+			1000000000) + (end.tv_nsec - start.tv_nsec);
+		printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
+		       nsec % 1000000000);
+	}
+	return 0;
+}
+
+void increase_limits(void)
+{
+	cur_limits.rlim_cur = RLIM_INFINITY;
+	cur_limits.rlim_max = RLIM_INFINITY;
+	setr(RLIMIT_MSGQUEUE, &cur_limits);
+	while (try_set(max_msgs, cur_max_msgs += 10))
+		;
+	cur_max_msgs = get(max_msgs);
+	while (try_set(max_msgsize, cur_max_msgsize += 1024))
+		;
+	cur_max_msgsize = get(max_msgsize);
+	if (setpriority(PRIO_PROCESS, 0, -20) != 0)
+		shutdown(2, "setpriority()", __LINE__);
+	cur_nice = -20;
+}
+
+int main(int argc, char *argv[])
+{
+	struct mq_attr attr;
+	char *option, *next_option;
+	int i, cpu, rc;
+	struct sigaction sa;
+	poptContext popt_context;
+	void *retval;
+
+	main_thread = pthread_self();
+	num_cpus_to_pin = 0;
+
+	if (sysconf(_SC_NPROCESSORS_ONLN) == -1) {
+		perror("sysconf(_SC_NPROCESSORS_ONLN)");
+		exit(1);
+	}
+	cpus_online = min(MAX_CPUS, sysconf(_SC_NPROCESSORS_ONLN));
+	cpu_set = CPU_ALLOC(cpus_online);
+	if (cpu_set == NULL) {
+		perror("CPU_ALLOC()");
+		exit(1);
+	}
+	cpu_set_size = CPU_ALLOC_SIZE(cpus_online);
+	CPU_ZERO_S(cpu_set_size, cpu_set);
+
+	popt_context = poptGetContext(NULL, argc, (const char **)argv,
+				      options, 0);
+
+	while ((rc = poptGetNextOpt(popt_context)) > 0) {
+		switch (rc) {
+		case 'c':
+			continuous_mode = 1;
+			option = cpu_option_string;
+			do {
+				next_option = strchr(option, ',');
+				if (next_option)
+					*next_option = '\0';
+				cpu = atoi(option);
+				if (cpu >= cpus_online)
+					fprintf(stderr, "CPU %d exceeds "
+						"cpus online, ignoring.\n",
+						cpu);
+				else
+					cpus_to_pin[num_cpus_to_pin++] = cpu;
+				if (next_option)
+					option = ++next_option;
+			} while (next_option && num_cpus_to_pin < MAX_CPUS);
+			/* Double check that they didn't give us the same CPU
+			 * more than once */
+			for (cpu = 0; cpu < num_cpus_to_pin; cpu++) {
+				if (CPU_ISSET_S(cpus_to_pin[cpu], cpu_set_size,
+						cpu_set)) {
+					fprintf(stderr, "Any given CPU may "
+						"only be given once.\n");
+					exit(1);
+				} else
+					CPU_SET_S(cpus_to_pin[cpu],
+						  cpu_set_size, cpu_set);
+			}
+			break;
+		case 'p':
+			/*
+			 * Although we can create a msg queue with a
+			 * non-absolute path name, unlink will fail.  So,
+			 * if the name doesn't start with a /, add one
+			 * when we save it.
+			 */
+			option = queue_path;
+			if (*option != '/') {
+				queue_path = malloc(strlen(option) + 2);
+				if (!queue_path) {
+					perror("malloc()");
+					exit(1);
+				}
+				queue_path[0] = '/';
+				queue_path[1] = 0;
+				strcat(queue_path, option);
+				free(option);
+			}
+			break;
+		}
+	}
+
+	if (continuous_mode && num_cpus_to_pin == 0) {
+		fprintf(stderr, "Must pass at least one CPU to continuous "
+			"mode.\n");
+		poptPrintUsage(popt_context, stderr, 0);
+		exit(1);
+	} else if (!continuous_mode) {
+		num_cpus_to_pin = 1;
+		cpus_to_pin[0] = cpus_online - 1;
+	}
+
+	if (getuid() != 0) {
+		fprintf(stderr, "Not running as root, but almost all tests "
+			"require root in order to modify\nsystem settings.  "
+			"Exiting.\n");
+		exit(1);
+	}
+
+	max_msgs = fopen(MAX_MSGS, "r+");
+	max_msgsize = fopen(MAX_MSGSIZE, "r+");
+	if (!max_msgs)
+		shutdown(2, "Failed to open msg_max", __LINE__);
+	if (!max_msgsize)
+		shutdown(2, "Failed to open msgsize_max", __LINE__);
+
+	/* Load up the current system values for everything we can */
+	getr(RLIMIT_MSGQUEUE, &saved_limits);
+	cur_limits = saved_limits;
+	saved_max_msgs = cur_max_msgs = get(max_msgs);
+	saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
+	errno = 0;
+	cur_nice = getpriority(PRIO_PROCESS, 0);
+	if (errno)
+		shutdown(2, "getpriority()", __LINE__);
+
+	/* Tell the user our initial state */
+	printf("\nInitial system state:\n");
+	printf("\tUsing queue path:\t\t\t%s\n", queue_path);
+	printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
+		(long) saved_limits.rlim_cur);
+	printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
+		(long) saved_limits.rlim_max);
+	printf("\tMaximum Message Size:\t\t\t%d\n", saved_max_msgsize);
+	printf("\tMaximum Queue Size:\t\t\t%d\n", saved_max_msgs);
+	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
+	printf("\n");
+
+	increase_limits();
+
+	printf("Adjusted system state for testing:\n");
+	if (cur_limits.rlim_cur == RLIM_INFINITY) {
+		printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t(unlimited)\n");
+		printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t(unlimited)\n");
+	} else {
+		printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
+		       (long) cur_limits.rlim_cur);
+		printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
+		       (long) cur_limits.rlim_max);
+	}
+	printf("\tMaximum Message Size:\t\t\t%d\n", cur_max_msgsize);
+	printf("\tMaximum Queue Size:\t\t\t%d\n", cur_max_msgs);
+	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
+	printf("\tContinuous mode:\t\t\t(%s)\n", continuous_mode ?
+	       (continuous_mode_fake ? "fake mode" : "enabled") :
+	       "disabled");
+	printf("\tCPUs to pin:\t\t\t\t%d", cpus_to_pin[0]);
+	for (cpu = 1; cpu < num_cpus_to_pin; cpu++)
+			printf(",%d", cpus_to_pin[cpu]);
+	printf("\n");
+
+	sa.sa_sigaction = sig_action_SIGUSR1;
+	sigemptyset(&sa.sa_mask);
+	sigaddset(&sa.sa_mask, SIGHUP);
+	sigaddset(&sa.sa_mask, SIGINT);
+	sigaddset(&sa.sa_mask, SIGQUIT);
+	sigaddset(&sa.sa_mask, SIGTERM);
+	sa.sa_flags = SA_SIGINFO;
+	if (sigaction(SIGUSR1, &sa, NULL) == -1)
+		shutdown(1, "sigaction(SIGUSR1)", __LINE__);
+	sa.sa_sigaction = sig_action;
+	if (sigaction(SIGHUP, &sa, NULL) == -1)
+		shutdown(1, "sigaction(SIGHUP)", __LINE__);
+	if (sigaction(SIGINT, &sa, NULL) == -1)
+		shutdown(1, "sigaction(SIGINT)", __LINE__);
+	if (sigaction(SIGQUIT, &sa, NULL) == -1)
+		shutdown(1, "sigaction(SIGQUIT)", __LINE__);
+	if (sigaction(SIGTERM, &sa, NULL) == -1)
+		shutdown(1, "sigaction(SIGTERM)", __LINE__);
+
+	if (!continuous_mode_fake) {
+		attr.mq_flags = O_NONBLOCK;
+		attr.mq_maxmsg = cur_max_msgs;
+		attr.mq_msgsize = MSG_SIZE;
+		open_queue(&attr);
+	}
+	for (i = 0; i < num_cpus_to_pin; i++) {
+		pthread_attr_t thread_attr;
+		void *thread_func;
+
+		if (continuous_mode_fake)
+			thread_func = &fake_cont_thread;
+		else if (continuous_mode)
+			thread_func = &cont_thread;
+		else
+			thread_func = &perf_test_thread;
+
+		CPU_ZERO_S(cpu_set_size, cpu_set);
+		CPU_SET_S(cpus_to_pin[i], cpu_set_size, cpu_set);
+		pthread_attr_init(&thread_attr);
+		pthread_attr_setaffinity_np(&thread_attr, cpu_set_size,
+					    cpu_set);
+		if (pthread_create(&cpu_threads[i], &thread_attr, thread_func,
+				   NULL))
+			shutdown(1, "pthread_create()", __LINE__);
+		pthread_attr_destroy(&thread_attr);
+	}
+
+	if (!continuous_mode) {
+		pthread_join(cpu_threads[0], &retval);
+		shutdown((long)retval, "perf_test_thread()", __LINE__);
+	} else {
+		while (1)
+			sleep(1);
+	}
+	shutdown(0, "", 0);
+}
diff --git a/tools/testing/selftests/ipc/msg/Makefile b/tools/testing/selftests/ipc/msg/Makefile
new file mode 100644
index 0000000..777ca76
--- /dev/null
+++ b/tools/testing/selftests/ipc/msg/Makefile
@@ -0,0 +1,22 @@
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
+ifeq ($(ARCH),i386)
+        ARCH := x86
+	CFLAGS := -DCONFIG_X86_32 -D__i386__
+endif
+ifeq ($(ARCH),x86_64)
+	ARCH := x86
+	CFLAGS := -DCONFIG_X86_64 -D__x86_64__
+endif
+
+CFLAGS += -I../../../../usr/include/
+
+all:
+	$(CC) $(CFLAGS) msgque.c -o msgque_test
+
+TEST_PROGS := msgque_test
+
+include ../../lib.mk
+
+clean:
+	rm -fr ./msgque_test
diff --git a/tools/testing/selftests/ipc/msg/msgque.c b/tools/testing/selftests/ipc/msg/msgque.c
new file mode 100644
index 0000000..69d539d
--- /dev/null
+++ b/tools/testing/selftests/ipc/msg/msgque.c
@@ -0,0 +1,254 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <linux/msg.h>
+#include <fcntl.h>
+
+#include "../../kselftest.h"
+
+#define MAX_MSG_SIZE		32
+
+struct msg1 {
+	int msize;
+	long mtype;
+	char mtext[MAX_MSG_SIZE];
+};
+
+#define TEST_STRING "Test sysv5 msg"
+#define MSG_TYPE 1
+
+#define ANOTHER_TEST_STRING "Yet another test sysv5 msg"
+#define ANOTHER_MSG_TYPE 26538
+
+struct msgque_data {
+	key_t key;
+	int msq_id;
+	int qbytes;
+	int qnum;
+	int mode;
+	struct msg1 *messages;
+};
+
+int restore_queue(struct msgque_data *msgque)
+{
+	int fd, ret, id, i;
+	char buf[32];
+
+	fd = open("/proc/sys/kernel/msg_next_id", O_WRONLY);
+	if (fd == -1) {
+		printf("Failed to open /proc/sys/kernel/msg_next_id\n");
+		return -errno;
+	}
+	sprintf(buf, "%d", msgque->msq_id);
+
+	ret = write(fd, buf, strlen(buf));
+	if (ret != strlen(buf)) {
+		printf("Failed to write to /proc/sys/kernel/msg_next_id\n");
+		return -errno;
+	}
+
+	id = msgget(msgque->key, msgque->mode | IPC_CREAT | IPC_EXCL);
+	if (id == -1) {
+		printf("Failed to create queue\n");
+		return -errno;
+	}
+
+	if (id != msgque->msq_id) {
+		printf("Restored queue has wrong id (%d instead of %d)\n",
+							id, msgque->msq_id);
+		ret = -EFAULT;
+		goto destroy;
+	}
+
+	for (i = 0; i < msgque->qnum; i++) {
+		if (msgsnd(msgque->msq_id, &msgque->messages[i].mtype,
+			   msgque->messages[i].msize, IPC_NOWAIT) != 0) {
+			printf("msgsnd failed (%m)\n");
+			ret = -errno;
+			goto destroy;
+		};
+	}
+	return 0;
+
+destroy:
+	if (msgctl(id, IPC_RMID, 0))
+		printf("Failed to destroy queue: %d\n", -errno);
+	return ret;
+}
+
+int check_and_destroy_queue(struct msgque_data *msgque)
+{
+	struct msg1 message;
+	int cnt = 0, ret;
+
+	while (1) {
+		ret = msgrcv(msgque->msq_id, &message.mtype, MAX_MSG_SIZE,
+				0, IPC_NOWAIT);
+		if (ret < 0) {
+			if (errno == ENOMSG)
+				break;
+			printf("Failed to read IPC message: %m\n");
+			ret = -errno;
+			goto err;
+		}
+		if (ret != msgque->messages[cnt].msize) {
+			printf("Wrong message size: %d (expected %d)\n", ret,
+						msgque->messages[cnt].msize);
+			ret = -EINVAL;
+			goto err;
+		}
+		if (message.mtype != msgque->messages[cnt].mtype) {
+			printf("Wrong message type\n");
+			ret = -EINVAL;
+			goto err;
+		}
+		if (memcmp(message.mtext, msgque->messages[cnt].mtext, ret)) {
+			printf("Wrong message content\n");
+			ret = -EINVAL;
+			goto err;
+		}
+		cnt++;
+	}
+
+	if (cnt != msgque->qnum) {
+		printf("Wrong message number\n");
+		ret = -EINVAL;
+		goto err;
+	}
+
+	ret = 0;
+err:
+	if (msgctl(msgque->msq_id, IPC_RMID, 0)) {
+		printf("Failed to destroy queue: %d\n", -errno);
+		return -errno;
+	}
+	return ret;
+}
+
+int dump_queue(struct msgque_data *msgque)
+{
+	struct msqid64_ds ds;
+	int kern_id;
+	int i, ret;
+
+	for (kern_id = 0; kern_id < 256; kern_id++) {
+		ret = msgctl(kern_id, MSG_STAT, &ds);
+		if (ret < 0) {
+			if (errno == -EINVAL)
+				continue;
+			printf("Failed to get stats for IPC queue with id %d\n",
+					kern_id);
+			return -errno;
+		}
+
+		if (ret == msgque->msq_id)
+			break;
+	}
+
+	msgque->messages = malloc(sizeof(struct msg1) * ds.msg_qnum);
+	if (msgque->messages == NULL) {
+		printf("Failed to get stats for IPC queue\n");
+		return -ENOMEM;
+	}
+
+	msgque->qnum = ds.msg_qnum;
+	msgque->mode = ds.msg_perm.mode;
+	msgque->qbytes = ds.msg_qbytes;
+
+	for (i = 0; i < msgque->qnum; i++) {
+		ret = msgrcv(msgque->msq_id, &msgque->messages[i].mtype,
+				MAX_MSG_SIZE, i, IPC_NOWAIT | MSG_COPY);
+		if (ret < 0) {
+			printf("Failed to copy IPC message: %m (%d)\n", errno);
+			return -errno;
+		}
+		msgque->messages[i].msize = ret;
+	}
+	return 0;
+}
+
+int fill_msgque(struct msgque_data *msgque)
+{
+	struct msg1 msgbuf;
+
+	msgbuf.mtype = MSG_TYPE;
+	memcpy(msgbuf.mtext, TEST_STRING, sizeof(TEST_STRING));
+	if (msgsnd(msgque->msq_id, &msgbuf.mtype, sizeof(TEST_STRING),
+				IPC_NOWAIT) != 0) {
+		printf("First message send failed (%m)\n");
+		return -errno;
+	};
+
+	msgbuf.mtype = ANOTHER_MSG_TYPE;
+	memcpy(msgbuf.mtext, ANOTHER_TEST_STRING, sizeof(ANOTHER_TEST_STRING));
+	if (msgsnd(msgque->msq_id, &msgbuf.mtype, sizeof(ANOTHER_TEST_STRING),
+				IPC_NOWAIT) != 0) {
+		printf("Second message send failed (%m)\n");
+		return -errno;
+	};
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	int msg, pid, err;
+	struct msgque_data msgque;
+
+	if (getuid() != 0) {
+		printf("Please run the test as root - Exiting.\n");
+		return ksft_exit_fail();
+	}
+
+	msgque.key = ftok(argv[0], 822155650);
+	if (msgque.key == -1) {
+		printf("Can't make key: %d\n", -errno);
+		return ksft_exit_fail();
+	}
+
+	msgque.msq_id = msgget(msgque.key, IPC_CREAT | IPC_EXCL | 0666);
+	if (msgque.msq_id == -1) {
+		err = -errno;
+		printf("Can't create queue: %d\n", err);
+		goto err_out;
+	}
+
+	err = fill_msgque(&msgque);
+	if (err) {
+		printf("Failed to fill queue: %d\n", err);
+		goto err_destroy;
+	}
+
+	err = dump_queue(&msgque);
+	if (err) {
+		printf("Failed to dump queue: %d\n", err);
+		goto err_destroy;
+	}
+
+	err = check_and_destroy_queue(&msgque);
+	if (err) {
+		printf("Failed to check and destroy queue: %d\n", err);
+		goto err_out;
+	}
+
+	err = restore_queue(&msgque);
+	if (err) {
+		printf("Failed to restore queue: %d\n", err);
+		goto err_destroy;
+	}
+
+	err = check_and_destroy_queue(&msgque);
+	if (err) {
+		printf("Failed to test queue: %d\n", err);
+		goto err_out;
+	}
+	return ksft_exit_pass();
+
+err_destroy:
+	if (msgctl(msgque.msq_id, IPC_RMID, 0)) {
+		printf("Failed to destroy queue: %d\n", -errno);
+		return ksft_exit_fail();
+	}
+err_out:
+	return ksft_exit_fail();
+}
diff --git a/tools/testing/selftests/ipc/msgque.c b/tools/testing/selftests/ipc/msgque.c
deleted file mode 100644
index 1b2ce33..0000000
--- a/tools/testing/selftests/ipc/msgque.c
+++ /dev/null
@@ -1,254 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <linux/msg.h>
-#include <fcntl.h>
-
-#include "../kselftest.h"
-
-#define MAX_MSG_SIZE		32
-
-struct msg1 {
-	int msize;
-	long mtype;
-	char mtext[MAX_MSG_SIZE];
-};
-
-#define TEST_STRING "Test sysv5 msg"
-#define MSG_TYPE 1
-
-#define ANOTHER_TEST_STRING "Yet another test sysv5 msg"
-#define ANOTHER_MSG_TYPE 26538
-
-struct msgque_data {
-	key_t key;
-	int msq_id;
-	int qbytes;
-	int qnum;
-	int mode;
-	struct msg1 *messages;
-};
-
-int restore_queue(struct msgque_data *msgque)
-{
-	int fd, ret, id, i;
-	char buf[32];
-
-	fd = open("/proc/sys/kernel/msg_next_id", O_WRONLY);
-	if (fd == -1) {
-		printf("Failed to open /proc/sys/kernel/msg_next_id\n");
-		return -errno;
-	}
-	sprintf(buf, "%d", msgque->msq_id);
-
-	ret = write(fd, buf, strlen(buf));
-	if (ret != strlen(buf)) {
-		printf("Failed to write to /proc/sys/kernel/msg_next_id\n");
-		return -errno;
-	}
-
-	id = msgget(msgque->key, msgque->mode | IPC_CREAT | IPC_EXCL);
-	if (id == -1) {
-		printf("Failed to create queue\n");
-		return -errno;
-	}
-
-	if (id != msgque->msq_id) {
-		printf("Restored queue has wrong id (%d instead of %d)\n",
-							id, msgque->msq_id);
-		ret = -EFAULT;
-		goto destroy;
-	}
-
-	for (i = 0; i < msgque->qnum; i++) {
-		if (msgsnd(msgque->msq_id, &msgque->messages[i].mtype,
-			   msgque->messages[i].msize, IPC_NOWAIT) != 0) {
-			printf("msgsnd failed (%m)\n");
-			ret = -errno;
-			goto destroy;
-		};
-	}
-	return 0;
-
-destroy:
-	if (msgctl(id, IPC_RMID, 0))
-		printf("Failed to destroy queue: %d\n", -errno);
-	return ret;
-}
-
-int check_and_destroy_queue(struct msgque_data *msgque)
-{
-	struct msg1 message;
-	int cnt = 0, ret;
-
-	while (1) {
-		ret = msgrcv(msgque->msq_id, &message.mtype, MAX_MSG_SIZE,
-				0, IPC_NOWAIT);
-		if (ret < 0) {
-			if (errno == ENOMSG)
-				break;
-			printf("Failed to read IPC message: %m\n");
-			ret = -errno;
-			goto err;
-		}
-		if (ret != msgque->messages[cnt].msize) {
-			printf("Wrong message size: %d (expected %d)\n", ret,
-						msgque->messages[cnt].msize);
-			ret = -EINVAL;
-			goto err;
-		}
-		if (message.mtype != msgque->messages[cnt].mtype) {
-			printf("Wrong message type\n");
-			ret = -EINVAL;
-			goto err;
-		}
-		if (memcmp(message.mtext, msgque->messages[cnt].mtext, ret)) {
-			printf("Wrong message content\n");
-			ret = -EINVAL;
-			goto err;
-		}
-		cnt++;
-	}
-
-	if (cnt != msgque->qnum) {
-		printf("Wrong message number\n");
-		ret = -EINVAL;
-		goto err;
-	}
-
-	ret = 0;
-err:
-	if (msgctl(msgque->msq_id, IPC_RMID, 0)) {
-		printf("Failed to destroy queue: %d\n", -errno);
-		return -errno;
-	}
-	return ret;
-}
-
-int dump_queue(struct msgque_data *msgque)
-{
-	struct msqid64_ds ds;
-	int kern_id;
-	int i, ret;
-
-	for (kern_id = 0; kern_id < 256; kern_id++) {
-		ret = msgctl(kern_id, MSG_STAT, &ds);
-		if (ret < 0) {
-			if (errno == -EINVAL)
-				continue;
-			printf("Failed to get stats for IPC queue with id %d\n",
-					kern_id);
-			return -errno;
-		}
-
-		if (ret == msgque->msq_id)
-			break;
-	}
-
-	msgque->messages = malloc(sizeof(struct msg1) * ds.msg_qnum);
-	if (msgque->messages == NULL) {
-		printf("Failed to get stats for IPC queue\n");
-		return -ENOMEM;
-	}
-
-	msgque->qnum = ds.msg_qnum;
-	msgque->mode = ds.msg_perm.mode;
-	msgque->qbytes = ds.msg_qbytes;
-
-	for (i = 0; i < msgque->qnum; i++) {
-		ret = msgrcv(msgque->msq_id, &msgque->messages[i].mtype,
-				MAX_MSG_SIZE, i, IPC_NOWAIT | MSG_COPY);
-		if (ret < 0) {
-			printf("Failed to copy IPC message: %m (%d)\n", errno);
-			return -errno;
-		}
-		msgque->messages[i].msize = ret;
-	}
-	return 0;
-}
-
-int fill_msgque(struct msgque_data *msgque)
-{
-	struct msg1 msgbuf;
-
-	msgbuf.mtype = MSG_TYPE;
-	memcpy(msgbuf.mtext, TEST_STRING, sizeof(TEST_STRING));
-	if (msgsnd(msgque->msq_id, &msgbuf.mtype, sizeof(TEST_STRING),
-				IPC_NOWAIT) != 0) {
-		printf("First message send failed (%m)\n");
-		return -errno;
-	};
-
-	msgbuf.mtype = ANOTHER_MSG_TYPE;
-	memcpy(msgbuf.mtext, ANOTHER_TEST_STRING, sizeof(ANOTHER_TEST_STRING));
-	if (msgsnd(msgque->msq_id, &msgbuf.mtype, sizeof(ANOTHER_TEST_STRING),
-				IPC_NOWAIT) != 0) {
-		printf("Second message send failed (%m)\n");
-		return -errno;
-	};
-	return 0;
-}
-
-int main(int argc, char **argv)
-{
-	int msg, pid, err;
-	struct msgque_data msgque;
-
-	if (getuid() != 0) {
-		printf("Please run the test as root - Exiting.\n");
-		return ksft_exit_fail();
-	}
-
-	msgque.key = ftok(argv[0], 822155650);
-	if (msgque.key == -1) {
-		printf("Can't make key: %d\n", -errno);
-		return ksft_exit_fail();
-	}
-
-	msgque.msq_id = msgget(msgque.key, IPC_CREAT | IPC_EXCL | 0666);
-	if (msgque.msq_id == -1) {
-		err = -errno;
-		printf("Can't create queue: %d\n", err);
-		goto err_out;
-	}
-
-	err = fill_msgque(&msgque);
-	if (err) {
-		printf("Failed to fill queue: %d\n", err);
-		goto err_destroy;
-	}
-
-	err = dump_queue(&msgque);
-	if (err) {
-		printf("Failed to dump queue: %d\n", err);
-		goto err_destroy;
-	}
-
-	err = check_and_destroy_queue(&msgque);
-	if (err) {
-		printf("Failed to check and destroy queue: %d\n", err);
-		goto err_out;
-	}
-
-	err = restore_queue(&msgque);
-	if (err) {
-		printf("Failed to restore queue: %d\n", err);
-		goto err_destroy;
-	}
-
-	err = check_and_destroy_queue(&msgque);
-	if (err) {
-		printf("Failed to test queue: %d\n", err);
-		goto err_out;
-	}
-	return ksft_exit_pass();
-
-err_destroy:
-	if (msgctl(msgque.msq_id, IPC_RMID, 0)) {
-		printf("Failed to destroy queue: %d\n", -errno);
-		return ksft_exit_fail();
-	}
-err_out:
-	return ksft_exit_fail();
-}
diff --git a/tools/testing/selftests/mqueue/.gitignore b/tools/testing/selftests/mqueue/.gitignore
deleted file mode 100644
index d8d4237..0000000
--- a/tools/testing/selftests/mqueue/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-mq_open_tests
-mq_perf_tests
diff --git a/tools/testing/selftests/mqueue/Makefile b/tools/testing/selftests/mqueue/Makefile
deleted file mode 100644
index 0e3b41e..0000000
--- a/tools/testing/selftests/mqueue/Makefile
+++ /dev/null
@@ -1,22 +0,0 @@
-CFLAGS = -O2
-
-all:
-	$(CC) $(CFLAGS) mq_open_tests.c -o mq_open_tests -lrt
-	$(CC) $(CFLAGS) -o mq_perf_tests mq_perf_tests.c -lrt -lpthread -lpopt
-
-include ../lib.mk
-
-override define RUN_TESTS
-	@./mq_open_tests /test1 || echo "selftests: mq_open_tests [FAIL]"
-	@./mq_perf_tests || echo "selftests: mq_perf_tests [FAIL]"
-endef
-
-TEST_PROGS := mq_open_tests mq_perf_tests
-
-override define EMIT_TESTS
-	echo "./mq_open_tests /test1 || echo \"selftests: mq_open_tests [FAIL]\""
-	echo "./mq_perf_tests || echo \"selftests: mq_perf_tests [FAIL]\""
-endef
-
-clean:
-	rm -f mq_open_tests mq_perf_tests
diff --git a/tools/testing/selftests/mqueue/mq_open_tests.c b/tools/testing/selftests/mqueue/mq_open_tests.c
deleted file mode 100644
index 9c1a5d35..0000000
--- a/tools/testing/selftests/mqueue/mq_open_tests.c
+++ /dev/null
@@ -1,500 +0,0 @@
-/*
- * This application is Copyright 2012 Red Hat, Inc.
- *	Doug Ledford <dledford@...hat.com>
- *
- * mq_open_tests is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * mq_open_tests is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * For the full text of the license, see <http://www.gnu.org/licenses/>.
- *
- * mq_open_tests.c
- *   Tests the various situations that should either succeed or fail to
- *   open a posix message queue and then reports whether or not they
- *   did as they were supposed to.
- *
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <mqueue.h>
-
-static char *usage =
-"Usage:\n"
-"  %s path\n"
-"\n"
-"	path	Path name of the message queue to create\n"
-"\n"
-"	Note: this program must be run as root in order to enable all tests\n"
-"\n";
-
-char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
-char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
-char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
-char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
-
-int default_settings;
-struct rlimit saved_limits, cur_limits;
-int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
-int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
-FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
-char *queue_path;
-mqd_t queue = -1;
-
-static inline void __set(FILE *stream, int value, char *err_msg);
-void shutdown(int exit_val, char *err_cause, int line_no);
-static inline int get(FILE *stream);
-static inline void set(FILE *stream, int value);
-static inline void getr(int type, struct rlimit *rlim);
-static inline void setr(int type, struct rlimit *rlim);
-void validate_current_settings();
-static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
-static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);
-
-static inline void __set(FILE *stream, int value, char *err_msg)
-{
-	rewind(stream);
-	if (fprintf(stream, "%d", value) < 0)
-		perror(err_msg);
-}
-
-
-void shutdown(int exit_val, char *err_cause, int line_no)
-{
-	static int in_shutdown = 0;
-
-	/* In case we get called recursively by a set() call below */
-	if (in_shutdown++)
-		return;
-
-	if (seteuid(0) == -1)
-		perror("seteuid() failed");
-
-	if (queue != -1)
-		if (mq_close(queue))
-			perror("mq_close() during shutdown");
-	if (queue_path)
-		/*
-		 * Be silent if this fails, if we cleaned up already it's
-		 * expected to fail
-		 */
-		mq_unlink(queue_path);
-	if (default_settings) {
-		if (saved_def_msgs)
-			__set(def_msgs, saved_def_msgs,
-			      "failed to restore saved_def_msgs");
-		if (saved_def_msgsize)
-			__set(def_msgsize, saved_def_msgsize,
-			      "failed to restore saved_def_msgsize");
-	}
-	if (saved_max_msgs)
-		__set(max_msgs, saved_max_msgs,
-		      "failed to restore saved_max_msgs");
-	if (saved_max_msgsize)
-		__set(max_msgsize, saved_max_msgsize,
-		      "failed to restore saved_max_msgsize");
-	if (exit_val)
-		error(exit_val, errno, "%s at %d", err_cause, line_no);
-	exit(0);
-}
-
-static inline int get(FILE *stream)
-{
-	int value;
-	rewind(stream);
-	if (fscanf(stream, "%d", &value) != 1)
-		shutdown(4, "Error reading /proc entry", __LINE__ - 1);
-	return value;
-}
-
-static inline void set(FILE *stream, int value)
-{
-	int new_value;
-
-	rewind(stream);
-	if (fprintf(stream, "%d", value) < 0)
-		return shutdown(5, "Failed writing to /proc file",
-				__LINE__ - 1);
-	new_value = get(stream);
-	if (new_value != value)
-		return shutdown(5, "We didn't get what we wrote to /proc back",
-				__LINE__ - 1);
-}
-
-static inline void getr(int type, struct rlimit *rlim)
-{
-	if (getrlimit(type, rlim))
-		shutdown(6, "getrlimit()", __LINE__ - 1);
-}
-
-static inline void setr(int type, struct rlimit *rlim)
-{
-	if (setrlimit(type, rlim))
-		shutdown(7, "setrlimit()", __LINE__ - 1);
-}
-
-void validate_current_settings()
-{
-	int rlim_needed;
-
-	if (cur_limits.rlim_cur < 4096) {
-		printf("Current rlimit value for POSIX message queue bytes is "
-		       "unreasonably low,\nincreasing.\n\n");
-		cur_limits.rlim_cur = 8192;
-		cur_limits.rlim_max = 16384;
-		setr(RLIMIT_MSGQUEUE, &cur_limits);
-	}
-
-	if (default_settings) {
-		rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
-						    2 * sizeof(void *));
-		if (rlim_needed > cur_limits.rlim_cur) {
-			printf("Temporarily lowering default queue parameters "
-			       "to something that will work\n"
-			       "with the current rlimit values.\n\n");
-			set(def_msgs, 10);
-			cur_def_msgs = 10;
-			set(def_msgsize, 128);
-			cur_def_msgsize = 128;
-		}
-	} else {
-		rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
-						    2 * sizeof(void *));
-		if (rlim_needed > cur_limits.rlim_cur) {
-			printf("Temporarily lowering maximum queue parameters "
-			       "to something that will work\n"
-			       "with the current rlimit values in case this is "
-			       "a kernel that ties the default\n"
-			       "queue parameters to the maximum queue "
-			       "parameters.\n\n");
-			set(max_msgs, 10);
-			cur_max_msgs = 10;
-			set(max_msgsize, 128);
-			cur_max_msgsize = 128;
-		}
-	}
-}
-
-/*
- * test_queue - Test opening a queue, shutdown if we fail.  This should
- * only be called in situations that should never fail.  We clean up
- * after ourselves and return the queue attributes in *result.
- */
-static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
-{
-	int flags = O_RDWR | O_EXCL | O_CREAT;
-	int perms = DEFFILEMODE;
-
-	if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
-		shutdown(1, "mq_open()", __LINE__);
-	if (mq_getattr(queue, result))
-		shutdown(1, "mq_getattr()", __LINE__);
-	if (mq_close(queue))
-		shutdown(1, "mq_close()", __LINE__);
-	queue = -1;
-	if (mq_unlink(queue_path))
-		shutdown(1, "mq_unlink()", __LINE__);
-}
-
-/*
- * Same as test_queue above, but failure is not fatal.
- * Returns:
- * 0 - Failed to create a queue
- * 1 - Created a queue, attributes in *result
- */
-static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result)
-{
-	int flags = O_RDWR | O_EXCL | O_CREAT;
-	int perms = DEFFILEMODE;
-
-	if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
-		return 0;
-	if (mq_getattr(queue, result))
-		shutdown(1, "mq_getattr()", __LINE__);
-	if (mq_close(queue))
-		shutdown(1, "mq_close()", __LINE__);
-	queue = -1;
-	if (mq_unlink(queue_path))
-		shutdown(1, "mq_unlink()", __LINE__);
-	return 1;
-}
-
-int main(int argc, char *argv[])
-{
-	struct mq_attr attr, result;
-
-	if (argc != 2) {
-		fprintf(stderr, "Must pass a valid queue name\n\n");
-		fprintf(stderr, usage, argv[0]);
-		exit(1);
-	}
-
-	/*
-	 * Although we can create a msg queue with a non-absolute path name,
-	 * unlink will fail.  So, if the name doesn't start with a /, add one
-	 * when we save it.
-	 */
-	if (*argv[1] == '/')
-		queue_path = strdup(argv[1]);
-	else {
-		queue_path = malloc(strlen(argv[1]) + 2);
-		if (!queue_path) {
-			perror("malloc()");
-			exit(1);
-		}
-		queue_path[0] = '/';
-		queue_path[1] = 0;
-		strcat(queue_path, argv[1]);
-	}
-
-	if (getuid() != 0) {
-		fprintf(stderr, "Not running as root, but almost all tests "
-			"require root in order to modify\nsystem settings.  "
-			"Exiting.\n");
-		exit(1);
-	}
-
-	/* Find out what files there are for us to make tweaks in */
-	def_msgs = fopen(DEF_MSGS, "r+");
-	def_msgsize = fopen(DEF_MSGSIZE, "r+");
-	max_msgs = fopen(MAX_MSGS, "r+");
-	max_msgsize = fopen(MAX_MSGSIZE, "r+");
-
-	if (!max_msgs)
-		shutdown(2, "Failed to open msg_max", __LINE__);
-	if (!max_msgsize)
-		shutdown(2, "Failed to open msgsize_max", __LINE__);
-	if (def_msgs || def_msgsize)
-		default_settings = 1;
-
-	/* Load up the current system values for everything we can */
-	getr(RLIMIT_MSGQUEUE, &saved_limits);
-	cur_limits = saved_limits;
-	if (default_settings) {
-		saved_def_msgs = cur_def_msgs = get(def_msgs);
-		saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
-	}
-	saved_max_msgs = cur_max_msgs = get(max_msgs);
-	saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
-
-	/* Tell the user our initial state */
-	printf("\nInitial system state:\n");
-	printf("\tUsing queue path:\t\t%s\n", queue_path);
-	printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n",
-		(long) saved_limits.rlim_cur);
-	printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n",
-		(long) saved_limits.rlim_max);
-	printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
-	printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
-	if (default_settings) {
-		printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
-		printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
-	} else {
-		printf("\tDefault Message Size:\t\tNot Supported\n");
-		printf("\tDefault Queue Size:\t\tNot Supported\n");
-	}
-	printf("\n");
-
-	validate_current_settings();
-
-	printf("Adjusted system state for testing:\n");
-	printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n", (long) cur_limits.rlim_cur);
-	printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n", (long) cur_limits.rlim_max);
-	printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
-	printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
-	if (default_settings) {
-		printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
-		printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
-	}
-
-	printf("\n\nTest series 1, behavior when no attr struct "
-	       "passed to mq_open:\n");
-	if (!default_settings) {
-		test_queue(NULL, &result);
-		printf("Given sane system settings, mq_open without an attr "
-		       "struct succeeds:\tPASS\n");
-		if (result.mq_maxmsg != cur_max_msgs ||
-		    result.mq_msgsize != cur_max_msgsize) {
-			printf("Kernel does not support setting the default "
-			       "mq attributes,\nbut also doesn't tie the "
-			       "defaults to the maximums:\t\t\tPASS\n");
-		} else {
-			set(max_msgs, ++cur_max_msgs);
-			set(max_msgsize, ++cur_max_msgsize);
-			test_queue(NULL, &result);
-			if (result.mq_maxmsg == cur_max_msgs &&
-			    result.mq_msgsize == cur_max_msgsize)
-				printf("Kernel does not support setting the "
-				       "default mq attributes and\n"
-				       "also ties system wide defaults to "
-				       "the system wide maximums:\t\t"
-				       "FAIL\n");
-			else
-				printf("Kernel does not support setting the "
-				       "default mq attributes,\n"
-				       "but also doesn't tie the defaults to "
-				       "the maximums:\t\t\tPASS\n");
-		}
-	} else {
-		printf("Kernel supports setting defaults separately from "
-		       "maximums:\t\tPASS\n");
-		/*
-		 * While we are here, go ahead and test that the kernel
-		 * properly follows the default settings
-		 */
-		test_queue(NULL, &result);
-		printf("Given sane values, mq_open without an attr struct "
-		       "succeeds:\t\tPASS\n");
-		if (result.mq_maxmsg != cur_def_msgs ||
-		    result.mq_msgsize != cur_def_msgsize)
-			printf("Kernel supports setting defaults, but does "
-			       "not actually honor them:\tFAIL\n\n");
-		else {
-			set(def_msgs, ++cur_def_msgs);
-			set(def_msgsize, ++cur_def_msgsize);
-			/* In case max was the same as the default */
-			set(max_msgs, ++cur_max_msgs);
-			set(max_msgsize, ++cur_max_msgsize);
-			test_queue(NULL, &result);
-			if (result.mq_maxmsg != cur_def_msgs ||
-			    result.mq_msgsize != cur_def_msgsize)
-				printf("Kernel supports setting defaults, but "
-				       "does not actually honor them:\t"
-				       "FAIL\n");
-			else
-				printf("Kernel properly honors default setting "
-				       "knobs:\t\t\t\tPASS\n");
-		}
-		set(def_msgs, cur_max_msgs + 1);
-		cur_def_msgs = cur_max_msgs + 1;
-		set(def_msgsize, cur_max_msgsize + 1);
-		cur_def_msgsize = cur_max_msgsize + 1;
-		if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
-		    cur_limits.rlim_cur) {
-			cur_limits.rlim_cur = (cur_def_msgs + 2) *
-				(cur_def_msgsize + 2 * sizeof(void *));
-			cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
-			setr(RLIMIT_MSGQUEUE, &cur_limits);
-		}
-		if (test_queue_fail(NULL, &result)) {
-			if (result.mq_maxmsg == cur_max_msgs &&
-			    result.mq_msgsize == cur_max_msgsize)
-				printf("Kernel properly limits default values "
-				       "to lesser of default/max:\t\tPASS\n");
-			else
-				printf("Kernel does not properly set default "
-				       "queue parameters when\ndefaults > "
-				       "max:\t\t\t\t\t\t\t\tFAIL\n");
-		} else
-			printf("Kernel fails to open mq because defaults are "
-			       "greater than maximums:\tFAIL\n");
-		set(def_msgs, --cur_def_msgs);
-		set(def_msgsize, --cur_def_msgsize);
-		cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
-			cur_def_msgsize;
-		setr(RLIMIT_MSGQUEUE, &cur_limits);
-		if (test_queue_fail(NULL, &result))
-			printf("Kernel creates queue even though defaults "
-			       "would exceed\nrlimit setting:"
-			       "\t\t\t\t\t\t\t\tFAIL\n");
-		else
-			printf("Kernel properly fails to create queue when "
-			       "defaults would\nexceed rlimit:"
-			       "\t\t\t\t\t\t\t\tPASS\n");
-	}
-
-	/*
-	 * Test #2 - open with an attr struct that exceeds rlimit
-	 */
-	printf("\n\nTest series 2, behavior when attr struct is "
-	       "passed to mq_open:\n");
-	cur_max_msgs = 32;
-	cur_max_msgsize = cur_limits.rlim_max >> 4;
-	set(max_msgs, cur_max_msgs);
-	set(max_msgsize, cur_max_msgsize);
-	attr.mq_maxmsg = cur_max_msgs;
-	attr.mq_msgsize = cur_max_msgsize;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open in excess of rlimit max when euid = 0 "
-		       "succeeded:\t\tFAIL\n");
-	else
-		printf("Queue open in excess of rlimit max when euid = 0 "
-		       "failed:\t\tPASS\n");
-	attr.mq_maxmsg = cur_max_msgs + 1;
-	attr.mq_msgsize = 10;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open with mq_maxmsg > limit when euid = 0 "
-		       "succeeded:\t\tPASS\n");
-	else
-		printf("Queue open with mq_maxmsg > limit when euid = 0 "
-		       "failed:\t\tFAIL\n");
-	attr.mq_maxmsg = 1;
-	attr.mq_msgsize = cur_max_msgsize + 1;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open with mq_msgsize > limit when euid = 0 "
-		       "succeeded:\t\tPASS\n");
-	else
-		printf("Queue open with mq_msgsize > limit when euid = 0 "
-		       "failed:\t\tFAIL\n");
-	attr.mq_maxmsg = 65536;
-	attr.mq_msgsize = 65536;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open with total size > 2GB when euid = 0 "
-		       "succeeded:\t\tFAIL\n");
-	else
-		printf("Queue open with total size > 2GB when euid = 0 "
-		       "failed:\t\t\tPASS\n");
-
-	if (seteuid(99) == -1) {
-		perror("seteuid() failed");
-		exit(1);
-	}
-
-	attr.mq_maxmsg = cur_max_msgs;
-	attr.mq_msgsize = cur_max_msgsize;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open in excess of rlimit max when euid = 99 "
-		       "succeeded:\t\tFAIL\n");
-	else
-		printf("Queue open in excess of rlimit max when euid = 99 "
-		       "failed:\t\tPASS\n");
-	attr.mq_maxmsg = cur_max_msgs + 1;
-	attr.mq_msgsize = 10;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open with mq_maxmsg > limit when euid = 99 "
-		       "succeeded:\t\tFAIL\n");
-	else
-		printf("Queue open with mq_maxmsg > limit when euid = 99 "
-		       "failed:\t\tPASS\n");
-	attr.mq_maxmsg = 1;
-	attr.mq_msgsize = cur_max_msgsize + 1;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open with mq_msgsize > limit when euid = 99 "
-		       "succeeded:\t\tFAIL\n");
-	else
-		printf("Queue open with mq_msgsize > limit when euid = 99 "
-		       "failed:\t\tPASS\n");
-	attr.mq_maxmsg = 65536;
-	attr.mq_msgsize = 65536;
-	if (test_queue_fail(&attr, &result))
-		printf("Queue open with total size > 2GB when euid = 99 "
-		       "succeeded:\t\tFAIL\n");
-	else
-		printf("Queue open with total size > 2GB when euid = 99 "
-		       "failed:\t\t\tPASS\n");
-
-	shutdown(0,"",0);
-}
diff --git a/tools/testing/selftests/mqueue/mq_perf_tests.c b/tools/testing/selftests/mqueue/mq_perf_tests.c
deleted file mode 100644
index 8519e9e..0000000
--- a/tools/testing/selftests/mqueue/mq_perf_tests.c
+++ /dev/null
@@ -1,742 +0,0 @@
-/*
- * This application is Copyright 2012 Red Hat, Inc.
- *	Doug Ledford <dledford@...hat.com>
- *
- * mq_perf_tests is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, version 3.
- *
- * mq_perf_tests is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * For the full text of the license, see <http://www.gnu.org/licenses/>.
- *
- * mq_perf_tests.c
- *   Tests various types of message queue workloads, concentrating on those
- *   situations that invole large message sizes, large message queue depths,
- *   or both, and reports back useful metrics about kernel message queue
- *   performance.
- *
- */
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-#include <signal.h>
-#include <pthread.h>
-#include <sched.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <mqueue.h>
-#include <popt.h>
-
-static char *usage =
-"Usage:\n"
-"  %s [-c #[,#..] -f] path\n"
-"\n"
-"	-c #	Skip most tests and go straight to a high queue depth test\n"
-"		and then run that test continuously (useful for running at\n"
-"		the same time as some other workload to see how much the\n"
-"		cache thrashing caused by adding messages to a very deep\n"
-"		queue impacts the performance of other programs).  The number\n"
-"		indicates which CPU core we should bind the process to during\n"
-"		the run.  If you have more than one physical CPU, then you\n"
-"		will need one copy per physical CPU package, and you should\n"
-"		specify the CPU cores to pin ourself to via a comma separated\n"
-"		list of CPU values.\n"
-"	-f	Only usable with continuous mode.  Pin ourself to the CPUs\n"
-"		as requested, then instead of looping doing a high mq\n"
-"		workload, just busy loop.  This will allow us to lock up a\n"
-"		single CPU just like we normally would, but without actually\n"
-"		thrashing the CPU cache.  This is to make it easier to get\n"
-"		comparable numbers from some other workload running on the\n"
-"		other CPUs.  One set of numbers with # CPUs locked up running\n"
-"		an mq workload, and another set of numbers with those same\n"
-"		CPUs locked away from the test workload, but not doing\n"
-"		anything to trash the cache like the mq workload might.\n"
-"	path	Path name of the message queue to create\n"
-"\n"
-"	Note: this program must be run as root in order to enable all tests\n"
-"\n";
-
-char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
-char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
-
-#define min(a, b) ((a) < (b) ? (a) : (b))
-#define MAX_CPUS 64
-char *cpu_option_string;
-int cpus_to_pin[MAX_CPUS];
-int num_cpus_to_pin;
-pthread_t cpu_threads[MAX_CPUS];
-pthread_t main_thread;
-cpu_set_t *cpu_set;
-int cpu_set_size;
-int cpus_online;
-
-#define MSG_SIZE 16
-#define TEST1_LOOPS 10000000
-#define TEST2_LOOPS 100000
-int continuous_mode;
-int continuous_mode_fake;
-
-struct rlimit saved_limits, cur_limits;
-int saved_max_msgs, saved_max_msgsize;
-int cur_max_msgs, cur_max_msgsize;
-FILE *max_msgs, *max_msgsize;
-int cur_nice;
-char *queue_path = "/mq_perf_tests";
-mqd_t queue = -1;
-struct mq_attr result;
-int mq_prio_max;
-
-const struct poptOption options[] = {
-	{
-		.longName = "continuous",
-		.shortName = 'c',
-		.argInfo = POPT_ARG_STRING,
-		.arg = &cpu_option_string,
-		.val = 'c',
-		.descrip = "Run continuous tests at a high queue depth in "
-			"order to test the effects of cache thrashing on "
-			"other tasks on the system.  This test is intended "
-			"to be run on one core of each physical CPU while "
-			"some other CPU intensive task is run on all the other "
-			"cores of that same physical CPU and the other task "
-			"is timed.  It is assumed that the process of adding "
-			"messages to the message queue in a tight loop will "
-			"impact that other task to some degree.  Once the "
-			"tests are performed in this way, you should then "
-			"re-run the tests using fake mode in order to check "
-			"the difference in time required to perform the CPU "
-			"intensive task",
-		.argDescrip = "cpu[,cpu]",
-	},
-	{
-		.longName = "fake",
-		.shortName = 'f',
-		.argInfo = POPT_ARG_NONE,
-		.arg = &continuous_mode_fake,
-		.val = 0,
-		.descrip = "Tie up the CPUs that we would normally tie up in"
-			"continuous mode, but don't actually do any mq stuff, "
-			"just keep the CPU busy so it can't be used to process "
-			"system level tasks as this would free up resources on "
-			"the other CPU cores and skew the comparison between "
-			"the no-mqueue work and mqueue work tests",
-		.argDescrip = NULL,
-	},
-	{
-		.longName = "path",
-		.shortName = 'p',
-		.argInfo = POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT,
-		.arg = &queue_path,
-		.val = 'p',
-		.descrip = "The name of the path to use in the mqueue "
-			"filesystem for our tests",
-		.argDescrip = "pathname",
-	},
-	POPT_AUTOHELP
-	POPT_TABLEEND
-};
-
-static inline void __set(FILE *stream, int value, char *err_msg);
-void shutdown(int exit_val, char *err_cause, int line_no);
-void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context);
-void sig_action(int signum, siginfo_t *info, void *context);
-static inline int get(FILE *stream);
-static inline void set(FILE *stream, int value);
-static inline int try_set(FILE *stream, int value);
-static inline void getr(int type, struct rlimit *rlim);
-static inline void setr(int type, struct rlimit *rlim);
-static inline void open_queue(struct mq_attr *attr);
-void increase_limits(void);
-
-static inline void __set(FILE *stream, int value, char *err_msg)
-{
-	rewind(stream);
-	if (fprintf(stream, "%d", value) < 0)
-		perror(err_msg);
-}
-
-
-void shutdown(int exit_val, char *err_cause, int line_no)
-{
-	static int in_shutdown = 0;
-	int errno_at_shutdown = errno;
-	int i;
-
-	/* In case we get called by multiple threads or from an sighandler */
-	if (in_shutdown++)
-		return;
-
-	for (i = 0; i < num_cpus_to_pin; i++)
-		if (cpu_threads[i]) {
-			pthread_kill(cpu_threads[i], SIGUSR1);
-			pthread_join(cpu_threads[i], NULL);
-		}
-
-	if (queue != -1)
-		if (mq_close(queue))
-			perror("mq_close() during shutdown");
-	if (queue_path)
-		/*
-		 * Be silent if this fails, if we cleaned up already it's
-		 * expected to fail
-		 */
-		mq_unlink(queue_path);
-	if (saved_max_msgs)
-		__set(max_msgs, saved_max_msgs,
-		      "failed to restore saved_max_msgs");
-	if (saved_max_msgsize)
-		__set(max_msgsize, saved_max_msgsize,
-		      "failed to restore saved_max_msgsize");
-	if (exit_val)
-		error(exit_val, errno_at_shutdown, "%s at %d",
-		      err_cause, line_no);
-	exit(0);
-}
-
-void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context)
-{
-	if (pthread_self() != main_thread)
-		pthread_exit(0);
-	else {
-		fprintf(stderr, "Caught signal %d in SIGUSR1 handler, "
-				"exiting\n", signum);
-		shutdown(0, "", 0);
-		fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
-		exit(0);
-	}
-}
-
-void sig_action(int signum, siginfo_t *info, void *context)
-{
-	if (pthread_self() != main_thread)
-		pthread_kill(main_thread, signum);
-	else {
-		fprintf(stderr, "Caught signal %d, exiting\n", signum);
-		shutdown(0, "", 0);
-		fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
-		exit(0);
-	}
-}
-
-static inline int get(FILE *stream)
-{
-	int value;
-	rewind(stream);
-	if (fscanf(stream, "%d", &value) != 1)
-		shutdown(4, "Error reading /proc entry", __LINE__);
-	return value;
-}
-
-static inline void set(FILE *stream, int value)
-{
-	int new_value;
-
-	rewind(stream);
-	if (fprintf(stream, "%d", value) < 0)
-		return shutdown(5, "Failed writing to /proc file", __LINE__);
-	new_value = get(stream);
-	if (new_value != value)
-		return shutdown(5, "We didn't get what we wrote to /proc back",
-				__LINE__);
-}
-
-static inline int try_set(FILE *stream, int value)
-{
-	int new_value;
-
-	rewind(stream);
-	fprintf(stream, "%d", value);
-	new_value = get(stream);
-	return new_value == value;
-}
-
-static inline void getr(int type, struct rlimit *rlim)
-{
-	if (getrlimit(type, rlim))
-		shutdown(6, "getrlimit()", __LINE__);
-}
-
-static inline void setr(int type, struct rlimit *rlim)
-{
-	if (setrlimit(type, rlim))
-		shutdown(7, "setrlimit()", __LINE__);
-}
-
-/**
- * open_queue - open the global queue for testing
- * @attr - An attr struct specifying the desired queue traits
- * @result - An attr struct that lists the actual traits the queue has
- *
- * This open is not allowed to fail, failure will result in an orderly
- * shutdown of the program.  The global queue_path is used to set what
- * queue to open, the queue descriptor is saved in the global queue
- * variable.
- */
-static inline void open_queue(struct mq_attr *attr)
-{
-	int flags = O_RDWR | O_EXCL | O_CREAT | O_NONBLOCK;
-	int perms = DEFFILEMODE;
-
-	queue = mq_open(queue_path, flags, perms, attr);
-	if (queue == -1)
-		shutdown(1, "mq_open()", __LINE__);
-	if (mq_getattr(queue, &result))
-		shutdown(1, "mq_getattr()", __LINE__);
-	printf("\n\tQueue %s created:\n", queue_path);
-	printf("\t\tmq_flags:\t\t\t%s\n", result.mq_flags & O_NONBLOCK ?
-	       "O_NONBLOCK" : "(null)");
-	printf("\t\tmq_maxmsg:\t\t\t%lu\n", result.mq_maxmsg);
-	printf("\t\tmq_msgsize:\t\t\t%lu\n", result.mq_msgsize);
-	printf("\t\tmq_curmsgs:\t\t\t%lu\n", result.mq_curmsgs);
-}
-
-void *fake_cont_thread(void *arg)
-{
-	int i;
-
-	for (i = 0; i < num_cpus_to_pin; i++)
-		if (cpu_threads[i] == pthread_self())
-			break;
-	printf("\tStarted fake continuous mode thread %d on CPU %d\n", i,
-	       cpus_to_pin[i]);
-	while (1)
-		;
-}
-
-void *cont_thread(void *arg)
-{
-	char buff[MSG_SIZE];
-	int i, priority;
-
-	for (i = 0; i < num_cpus_to_pin; i++)
-		if (cpu_threads[i] == pthread_self())
-			break;
-	printf("\tStarted continuous mode thread %d on CPU %d\n", i,
-	       cpus_to_pin[i]);
-	while (1) {
-		while (mq_send(queue, buff, sizeof(buff), 0) == 0)
-			;
-		mq_receive(queue, buff, sizeof(buff), &priority);
-	}
-}
-
-#define drain_queue() \
-	while (mq_receive(queue, buff, MSG_SIZE, &prio_in) == MSG_SIZE)
-
-#define do_untimed_send() \
-	do { \
-		if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
-			shutdown(3, "Test send failure", __LINE__); \
-	} while (0)
-
-#define do_send_recv() \
-	do { \
-		clock_gettime(clock, &start); \
-		if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
-			shutdown(3, "Test send failure", __LINE__); \
-		clock_gettime(clock, &middle); \
-		if (mq_receive(queue, buff, MSG_SIZE, &prio_in) != MSG_SIZE) \
-			shutdown(3, "Test receive failure", __LINE__); \
-		clock_gettime(clock, &end); \
-		nsec = ((middle.tv_sec - start.tv_sec) * 1000000000) + \
-			(middle.tv_nsec - start.tv_nsec); \
-		send_total.tv_nsec += nsec; \
-		if (send_total.tv_nsec >= 1000000000) { \
-			send_total.tv_sec++; \
-			send_total.tv_nsec -= 1000000000; \
-		} \
-		nsec = ((end.tv_sec - middle.tv_sec) * 1000000000) + \
-			(end.tv_nsec - middle.tv_nsec); \
-		recv_total.tv_nsec += nsec; \
-		if (recv_total.tv_nsec >= 1000000000) { \
-			recv_total.tv_sec++; \
-			recv_total.tv_nsec -= 1000000000; \
-		} \
-	} while (0)
-
-struct test {
-	char *desc;
-	void (*func)(int *);
-};
-
-void const_prio(int *prio)
-{
-	return;
-}
-
-void inc_prio(int *prio)
-{
-	if (++*prio == mq_prio_max)
-		*prio = 0;
-}
-
-void dec_prio(int *prio)
-{
-	if (--*prio < 0)
-		*prio = mq_prio_max - 1;
-}
-
-void random_prio(int *prio)
-{
-	*prio = random() % mq_prio_max;
-}
-
-struct test test2[] = {
-	{"\n\tTest #2a: Time send/recv message, queue full, constant prio\n",
-		const_prio},
-	{"\n\tTest #2b: Time send/recv message, queue full, increasing prio\n",
-		inc_prio},
-	{"\n\tTest #2c: Time send/recv message, queue full, decreasing prio\n",
-		dec_prio},
-	{"\n\tTest #2d: Time send/recv message, queue full, random prio\n",
-		random_prio},
-	{NULL, NULL}
-};
-
-/**
- * Tests to perform (all done with MSG_SIZE messages):
- *
- * 1) Time to add/remove message with 0 messages on queue
- * 1a) with constant prio
- * 2) Time to add/remove message when queue close to capacity:
- * 2a) with constant prio
- * 2b) with increasing prio
- * 2c) with decreasing prio
- * 2d) with random prio
- * 3) Test limits of priorities honored (double check _SC_MQ_PRIO_MAX)
- */
-void *perf_test_thread(void *arg)
-{
-	char buff[MSG_SIZE];
-	int prio_out, prio_in;
-	int i;
-	clockid_t clock;
-	pthread_t *t;
-	struct timespec res, start, middle, end, send_total, recv_total;
-	unsigned long long nsec;
-	struct test *cur_test;
-
-	t = &cpu_threads[0];
-	printf("\n\tStarted mqueue performance test thread on CPU %d\n",
-	       cpus_to_pin[0]);
-	mq_prio_max = sysconf(_SC_MQ_PRIO_MAX);
-	if (mq_prio_max == -1)
-		shutdown(2, "sysconf(_SC_MQ_PRIO_MAX)", __LINE__);
-	if (pthread_getcpuclockid(cpu_threads[0], &clock) != 0)
-		shutdown(2, "pthread_getcpuclockid", __LINE__);
-
-	if (clock_getres(clock, &res))
-		shutdown(2, "clock_getres()", __LINE__);
-
-	printf("\t\tMax priorities:\t\t\t%d\n", mq_prio_max);
-	printf("\t\tClock resolution:\t\t%lu nsec%s\n", res.tv_nsec,
-	       res.tv_nsec > 1 ? "s" : "");
-
-
-
-	printf("\n\tTest #1: Time send/recv message, queue empty\n");
-	printf("\t\t(%d iterations)\n", TEST1_LOOPS);
-	prio_out = 0;
-	send_total.tv_sec = 0;
-	send_total.tv_nsec = 0;
-	recv_total.tv_sec = 0;
-	recv_total.tv_nsec = 0;
-	for (i = 0; i < TEST1_LOOPS; i++)
-		do_send_recv();
-	printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
-	       send_total.tv_sec, send_total.tv_nsec);
-	nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
-		 send_total.tv_nsec) / TEST1_LOOPS;
-	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
-	printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
-	       recv_total.tv_sec, recv_total.tv_nsec);
-	nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
-		recv_total.tv_nsec) / TEST1_LOOPS;
-	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
-
-
-	for (cur_test = test2; cur_test->desc != NULL; cur_test++) {
-		printf("%s:\n", cur_test->desc);
-		printf("\t\t(%d iterations)\n", TEST2_LOOPS);
-		prio_out = 0;
-		send_total.tv_sec = 0;
-		send_total.tv_nsec = 0;
-		recv_total.tv_sec = 0;
-		recv_total.tv_nsec = 0;
-		printf("\t\tFilling queue...");
-		fflush(stdout);
-		clock_gettime(clock, &start);
-		for (i = 0; i < result.mq_maxmsg - 1; i++) {
-			do_untimed_send();
-			cur_test->func(&prio_out);
-		}
-		clock_gettime(clock, &end);
-		nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
-			1000000000) + (end.tv_nsec - start.tv_nsec);
-		printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
-		       nsec % 1000000000);
-		printf("\t\tTesting...");
-		fflush(stdout);
-		for (i = 0; i < TEST2_LOOPS; i++) {
-			do_send_recv();
-			cur_test->func(&prio_out);
-		}
-		printf("done.\n");
-		printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
-		       send_total.tv_sec, send_total.tv_nsec);
-		nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
-			 send_total.tv_nsec) / TEST2_LOOPS;
-		printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
-		printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
-		       recv_total.tv_sec, recv_total.tv_nsec);
-		nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
-			recv_total.tv_nsec) / TEST2_LOOPS;
-		printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
-		printf("\t\tDraining queue...");
-		fflush(stdout);
-		clock_gettime(clock, &start);
-		drain_queue();
-		clock_gettime(clock, &end);
-		nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
-			1000000000) + (end.tv_nsec - start.tv_nsec);
-		printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
-		       nsec % 1000000000);
-	}
-	return 0;
-}
-
-void increase_limits(void)
-{
-	cur_limits.rlim_cur = RLIM_INFINITY;
-	cur_limits.rlim_max = RLIM_INFINITY;
-	setr(RLIMIT_MSGQUEUE, &cur_limits);
-	while (try_set(max_msgs, cur_max_msgs += 10))
-		;
-	cur_max_msgs = get(max_msgs);
-	while (try_set(max_msgsize, cur_max_msgsize += 1024))
-		;
-	cur_max_msgsize = get(max_msgsize);
-	if (setpriority(PRIO_PROCESS, 0, -20) != 0)
-		shutdown(2, "setpriority()", __LINE__);
-	cur_nice = -20;
-}
-
-int main(int argc, char *argv[])
-{
-	struct mq_attr attr;
-	char *option, *next_option;
-	int i, cpu, rc;
-	struct sigaction sa;
-	poptContext popt_context;
-	void *retval;
-
-	main_thread = pthread_self();
-	num_cpus_to_pin = 0;
-
-	if (sysconf(_SC_NPROCESSORS_ONLN) == -1) {
-		perror("sysconf(_SC_NPROCESSORS_ONLN)");
-		exit(1);
-	}
-	cpus_online = min(MAX_CPUS, sysconf(_SC_NPROCESSORS_ONLN));
-	cpu_set = CPU_ALLOC(cpus_online);
-	if (cpu_set == NULL) {
-		perror("CPU_ALLOC()");
-		exit(1);
-	}
-	cpu_set_size = CPU_ALLOC_SIZE(cpus_online);
-	CPU_ZERO_S(cpu_set_size, cpu_set);
-
-	popt_context = poptGetContext(NULL, argc, (const char **)argv,
-				      options, 0);
-
-	while ((rc = poptGetNextOpt(popt_context)) > 0) {
-		switch (rc) {
-		case 'c':
-			continuous_mode = 1;
-			option = cpu_option_string;
-			do {
-				next_option = strchr(option, ',');
-				if (next_option)
-					*next_option = '\0';
-				cpu = atoi(option);
-				if (cpu >= cpus_online)
-					fprintf(stderr, "CPU %d exceeds "
-						"cpus online, ignoring.\n",
-						cpu);
-				else
-					cpus_to_pin[num_cpus_to_pin++] = cpu;
-				if (next_option)
-					option = ++next_option;
-			} while (next_option && num_cpus_to_pin < MAX_CPUS);
-			/* Double check that they didn't give us the same CPU
-			 * more than once */
-			for (cpu = 0; cpu < num_cpus_to_pin; cpu++) {
-				if (CPU_ISSET_S(cpus_to_pin[cpu], cpu_set_size,
-						cpu_set)) {
-					fprintf(stderr, "Any given CPU may "
-						"only be given once.\n");
-					exit(1);
-				} else
-					CPU_SET_S(cpus_to_pin[cpu],
-						  cpu_set_size, cpu_set);
-			}
-			break;
-		case 'p':
-			/*
-			 * Although we can create a msg queue with a
-			 * non-absolute path name, unlink will fail.  So,
-			 * if the name doesn't start with a /, add one
-			 * when we save it.
-			 */
-			option = queue_path;
-			if (*option != '/') {
-				queue_path = malloc(strlen(option) + 2);
-				if (!queue_path) {
-					perror("malloc()");
-					exit(1);
-				}
-				queue_path[0] = '/';
-				queue_path[1] = 0;
-				strcat(queue_path, option);
-				free(option);
-			}
-			break;
-		}
-	}
-
-	if (continuous_mode && num_cpus_to_pin == 0) {
-		fprintf(stderr, "Must pass at least one CPU to continuous "
-			"mode.\n");
-		poptPrintUsage(popt_context, stderr, 0);
-		exit(1);
-	} else if (!continuous_mode) {
-		num_cpus_to_pin = 1;
-		cpus_to_pin[0] = cpus_online - 1;
-	}
-
-	if (getuid() != 0) {
-		fprintf(stderr, "Not running as root, but almost all tests "
-			"require root in order to modify\nsystem settings.  "
-			"Exiting.\n");
-		exit(1);
-	}
-
-	max_msgs = fopen(MAX_MSGS, "r+");
-	max_msgsize = fopen(MAX_MSGSIZE, "r+");
-	if (!max_msgs)
-		shutdown(2, "Failed to open msg_max", __LINE__);
-	if (!max_msgsize)
-		shutdown(2, "Failed to open msgsize_max", __LINE__);
-
-	/* Load up the current system values for everything we can */
-	getr(RLIMIT_MSGQUEUE, &saved_limits);
-	cur_limits = saved_limits;
-	saved_max_msgs = cur_max_msgs = get(max_msgs);
-	saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
-	errno = 0;
-	cur_nice = getpriority(PRIO_PROCESS, 0);
-	if (errno)
-		shutdown(2, "getpriority()", __LINE__);
-
-	/* Tell the user our initial state */
-	printf("\nInitial system state:\n");
-	printf("\tUsing queue path:\t\t\t%s\n", queue_path);
-	printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
-		(long) saved_limits.rlim_cur);
-	printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
-		(long) saved_limits.rlim_max);
-	printf("\tMaximum Message Size:\t\t\t%d\n", saved_max_msgsize);
-	printf("\tMaximum Queue Size:\t\t\t%d\n", saved_max_msgs);
-	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
-	printf("\n");
-
-	increase_limits();
-
-	printf("Adjusted system state for testing:\n");
-	if (cur_limits.rlim_cur == RLIM_INFINITY) {
-		printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t(unlimited)\n");
-		printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t(unlimited)\n");
-	} else {
-		printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
-		       (long) cur_limits.rlim_cur);
-		printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
-		       (long) cur_limits.rlim_max);
-	}
-	printf("\tMaximum Message Size:\t\t\t%d\n", cur_max_msgsize);
-	printf("\tMaximum Queue Size:\t\t\t%d\n", cur_max_msgs);
-	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
-	printf("\tContinuous mode:\t\t\t(%s)\n", continuous_mode ?
-	       (continuous_mode_fake ? "fake mode" : "enabled") :
-	       "disabled");
-	printf("\tCPUs to pin:\t\t\t\t%d", cpus_to_pin[0]);
-	for (cpu = 1; cpu < num_cpus_to_pin; cpu++)
-			printf(",%d", cpus_to_pin[cpu]);
-	printf("\n");
-
-	sa.sa_sigaction = sig_action_SIGUSR1;
-	sigemptyset(&sa.sa_mask);
-	sigaddset(&sa.sa_mask, SIGHUP);
-	sigaddset(&sa.sa_mask, SIGINT);
-	sigaddset(&sa.sa_mask, SIGQUIT);
-	sigaddset(&sa.sa_mask, SIGTERM);
-	sa.sa_flags = SA_SIGINFO;
-	if (sigaction(SIGUSR1, &sa, NULL) == -1)
-		shutdown(1, "sigaction(SIGUSR1)", __LINE__);
-	sa.sa_sigaction = sig_action;
-	if (sigaction(SIGHUP, &sa, NULL) == -1)
-		shutdown(1, "sigaction(SIGHUP)", __LINE__);
-	if (sigaction(SIGINT, &sa, NULL) == -1)
-		shutdown(1, "sigaction(SIGINT)", __LINE__);
-	if (sigaction(SIGQUIT, &sa, NULL) == -1)
-		shutdown(1, "sigaction(SIGQUIT)", __LINE__);
-	if (sigaction(SIGTERM, &sa, NULL) == -1)
-		shutdown(1, "sigaction(SIGTERM)", __LINE__);
-
-	if (!continuous_mode_fake) {
-		attr.mq_flags = O_NONBLOCK;
-		attr.mq_maxmsg = cur_max_msgs;
-		attr.mq_msgsize = MSG_SIZE;
-		open_queue(&attr);
-	}
-	for (i = 0; i < num_cpus_to_pin; i++) {
-		pthread_attr_t thread_attr;
-		void *thread_func;
-
-		if (continuous_mode_fake)
-			thread_func = &fake_cont_thread;
-		else if (continuous_mode)
-			thread_func = &cont_thread;
-		else
-			thread_func = &perf_test_thread;
-
-		CPU_ZERO_S(cpu_set_size, cpu_set);
-		CPU_SET_S(cpus_to_pin[i], cpu_set_size, cpu_set);
-		pthread_attr_init(&thread_attr);
-		pthread_attr_setaffinity_np(&thread_attr, cpu_set_size,
-					    cpu_set);
-		if (pthread_create(&cpu_threads[i], &thread_attr, thread_func,
-				   NULL))
-			shutdown(1, "pthread_create()", __LINE__);
-		pthread_attr_destroy(&thread_attr);
-	}
-
-	if (!continuous_mode) {
-		pthread_join(cpu_threads[0], &retval);
-		shutdown((long)retval, "perf_test_thread()", __LINE__);
-	} else {
-		while (1)
-			sleep(1);
-	}
-	shutdown(0, "", 0);
-}
-- 
2.1.4



--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

Powered by blists - more mailing lists