commit 9dbe121e3132630e9094d36c2b0624404b75beea

Author: Jan Stancek <jstancek@redhat.com>

Date:   Tue Sep 1 15:49:35 2015 +0200

    tests/linkhuge_rw: function ptr may not refer to .text

    On some ABIs function pointer may not refer to .text section.

    For example on powerPC 64-bit ABI, function pointer may refer

    to a call stub from .opd section.

    This creates a problem for linkhuge_rw tests which run with

    HUGETLB_ELFMAP=R, because test is expecting that address of

    function pointer will be backed by huge pages. But because

    .opd section is from RW PT_LOAD segment, this doens't happen,

    since libhugetlbfs is instructed to map only R segments via

    HUGETLB_ELFMAP=R.

    This patch is replacing use of function pointer with address

    returned by gcc's __builtin_return_address(), that is called

    by the function itself. This should provide an address that

    is from an actual code, residing in .text section.

    Signed-off-by: Jan Stancek <jstancek@redhat.com>

    Cc: Adam Litke <agl@us.ibm.com>

    Cc: Eric B Munson <emunson@mgebm.net>

    Cc: Petr Holasek <pholasek@redhat.com>

    Signed-off-by: Eric B Munson <emunson@mgebm.net>

diff --git a/tests/linkhuge_rw.c b/tests/linkhuge_rw.c

index f58fff2..c1c2e96 100644

--- a/tests/linkhuge_rw.c

+++ b/tests/linkhuge_rw.c

@@ -31,7 +31,8 @@

 #include "hugetests.h"

 #define BLOCK_SIZE	16384

-#define CONST	0xdeadbeef

+#define CONST		0xdeadbeef

+#define RETURN_ADDRESS	0x0

 #define BIG_INIT	{ \

 	[0] = CONST, [17] = CONST, [BLOCK_SIZE-1] = CONST, \

@@ -45,13 +46,49 @@ static int big_bss[BLOCK_SIZE];

 const int small_const = CONST;

 const int big_const[BLOCK_SIZE] = BIG_INIT;

-static int static_func(int x)

+/*

+ * Turn function pointer into address from .text.

+ *

+ * On some ABIs function pointer may not refer to .text section. For example

+ * on powerPC 64-bit ABI, function pointer may refer to call stub from

+ * .opd section.

+ *

+ * This function expects that parameter data is a function pointer of type:

+ * long f(long), and when called with special parameter, it returns an address

+ * corresponding to actual code of the function. Current implementation relies

+ * on gcc's __builtin_return_address, see get_pc() below.

+ */

+static inline void *get_text_addr(void *data)

+{

+	long (*gettext)(long) = data;

+

+	return (void *)gettext(RETURN_ADDRESS);

+}

+

+static void __attribute__ ((noinline)) *get_pc(void)

+{

+#if defined(__s390__) && __WORDSIZE == 32

+	/* taken from sysdeps/unix/sysv/linux/s390/s390-32/profil-counter.h

+	 * 31-bit s390 pointers don't use the 32th bit, however integers do,

+	 * so wrap the value around at 31 bits */

+	return (void *)

+		((unsigned long) __builtin_return_address(0) & 0x7fffffffUL);

+#else

+	return __builtin_return_address(0);

+#endif

+}

+

+static long static_func(long x)

 {

+	if (x == RETURN_ADDRESS)

+		return (long)get_pc();

 	return x;

 }

-int global_func(int x)

+long global_func(long x)

 {

+	if (x == RETURN_ADDRESS)

+		return (long)get_pc();

 	return x;

 }

@@ -59,27 +96,28 @@ static struct test_entry {

 	const char *name;

 	void *data;

 	int size;

-	int writable, execable;

+	int writable;

+	int execable;

 	int is_huge;

 } testtab[] = {

-#define ENT(name, exec)	{ #name, (void *)&name, sizeof(name), 0, exec, }

+#define ENT(entry_name, exec) { \

+	.name = #entry_name, \

+	.data = (void *)&entry_name, \

+	.size = sizeof(entry_name), \

+	.writable = 0, \

+	.execable = exec }

+

 	ENT(small_data, 0),

 	ENT(big_data, 0),

 	ENT(small_bss, 0),

 	ENT(big_bss, 0),

 	ENT(small_const, 0),

 	ENT(big_const, 0),

-

-	/*

-	 * XXX: Due to the way functions are defined in the powerPC 64-bit ABI,

-	 * the following entries will point to a call stub in the data segment

-	 * instead of to the code as one might think.  Therefore, test coverage

-	 * is not quite as good as it could be for ppc64.

-	 */

 	ENT(static_func, 1),

 	ENT(global_func, 1),

 };

+

 #define NUM_TESTS	(sizeof(testtab) / sizeof(testtab[0]))

 static

@@ -116,12 +154,18 @@ static void check_if_writable(struct test_entry *te)

 {

 	int pid, ret, status;

-

 	pid = fork();

 	if (pid < 0)

 		FAIL("fork: %s", strerror(errno));

 	else if (pid == 0) {

-		(*(char *) te->data) = 0;

+		void *data;

+

+		if (te->execable)

+			data = get_text_addr(te->data);

+		else

+			data = te->data;

+

+		(*(char *)data) = 0;

 		exit (0);

 	} else {

 		ret = waitpid(pid, &status, 0);

@@ -137,11 +181,15 @@ static void check_if_writable(struct test_entry *te)

 static void do_test(struct test_entry *te)

 {

 	int i;

-	volatile int *p = te->data;

+	void *data = te->data;

 	check_if_writable(te);

+	verbose_printf("entry: %s, data: %p, writable: %d\n",

+		te->name, data, te->writable);

 	if (te->writable) {

+		volatile int *p = data;

+

 		for (i = 0; i < (te->size / sizeof(*p)); i++)

 			p[i] = CONST ^ i;

@@ -151,17 +199,23 @@ static void do_test(struct test_entry *te)

 			if (p[i] != (CONST ^ i))

 				FAIL("mismatch on %s", te->name);

 	} else if (te->execable) {

-		int (*pf)(int) = te->data;

+		long (*pf)(long) = data;

+

+		data = get_text_addr(data);

 		if ((*pf)(CONST) != CONST)

 			FAIL("%s returns incorrect results", te->name);

 	} else {

 		/* Otherwise just read touch it */

+		volatile int *p = data;

+

 		for (i = 0; i < (te->size / sizeof(*p)); i++)

 			p[i];

 	}

-	te->is_huge = (test_addr_huge(te->data) == 1);

+	te->is_huge = (test_addr_huge(data) == 1);

+	verbose_printf("entry: %s, data: %p, is_huge: %d\n",

+		te->name, data, te->is_huge);

 }

 int main(int argc, char *argv[])