/*
* libhugetlbfs - Easy use of Linux hugepages
* Copyright (C) 2005-2006 David Gibson & Adam Litke, IBM Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <sched.h>
#include <hugetlbfs.h>
#include "hugetests.h"
/*
* Test rationale:
*
* On PowerPC, the address space is divided into segments. These segments can
* contain either huge pages or normal pages, but not both. All segments are
* initially set up to map normal pages. When a huge page mapping is created
* within a set of empty segments, they are "enabled" for huge pages at that
* time. Once enabled for huge pages, they can not be used again for normal
* pages for the remaining lifetime of the process.
*
* If the segment immediately preceeding the segment containing the stack is
* converted to huge pages and the stack is made to grow into the this
* preceeding segment, some kernels may attempt to map normal pages into the
* huge page-only segment -- resulting in bugs.
*
* The kernel bug in question was fixed by commit
* 0d59a01bc461bbab4017ff449b8401151ef44cf6.
*/
#ifdef __LP64__
#define STACK_ALLOCATION_SIZE (256*1024*1024)
#else
#define STACK_ALLOCATION_SIZE (16*1024*1024)
#endif
#define MIN_CHILD_STACK (2*1024*1024)
#define STEP (STACK_ALLOCATION_SIZE)
int do_child(void *stop_address)
{
struct rlimit r;
volatile int *x;
/* corefile from this process is not interesting and limiting
* its size can save a lot of time. '1' is a special value,
* that will also abort dumping via pipe, which by default
* sets limit to RLIM_INFINITY. */
r.rlim_cur = 1;
r.rlim_max = 1;
setrlimit(RLIMIT_CORE, &r);
do {
x = alloca(STACK_ALLOCATION_SIZE);
*x = 1;
} while ((void *)x >= stop_address);
return 0;
}
void *try_setup_stack_and_huge(int fd, void *hint)
{
void *mmap_address, *stack_start, *tmp;
long hpage_size = gethugepagesize();
void *stop = alloca(1);
/*
* Find a spot for huge page. We start at "hint" and
* keep going down in "STEP" increments until we find
* a place where we can mmap huge page.
*/
mmap_address = PALIGN(hint, hpage_size);
do {
mmap_address += STEP;
if (mmap_address >= stop)
return NULL;
if (range_is_mapped((unsigned long)mmap_address,
(unsigned long)mmap_address + hpage_size))
continue;
tmp = mmap(mmap_address, hpage_size,
PROT_READ|PROT_WRITE, MAP_SHARED | MAP_FIXED, fd, 0);
} while (tmp == MAP_FAILED);
verbose_printf("huge page is at: %p-%p\n",
mmap_address, mmap_address + hpage_size);
/*
* Find a spot for stack below huge page. We start at end of
* huge page we found above and keep trying to mmap stack
* below. Because stack needs to grow into hugepage, we
* also have to make sure nothing is mapped in gap between
* stack and huge page.
*/
stack_start = mmap_address + hpage_size;
do {
if (range_is_mapped((unsigned long)stack_start,
(unsigned long)stack_start + STEP + MIN_CHILD_STACK)) {
verbose_printf("range is mapped: %p-%p\n", stack_start,
stack_start + STEP + MIN_CHILD_STACK);
munmap(mmap_address, hpage_size);
return NULL;
}
stack_start += STEP;
if (stack_start >= stop)
return NULL;
tmp = mmap(stack_start, MIN_CHILD_STACK, PROT_READ|PROT_WRITE,
MAP_GROWSDOWN|MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
} while (tmp == MAP_FAILED);
verbose_printf("Child stack is at %p-%p\n",
stack_start, stack_start + MIN_CHILD_STACK);
return stack_start + MIN_CHILD_STACK;
}
int main(int argc, char *argv[])
{
int fd, pid, s, ret;
struct rlimit r;
void *stack_end;
test_init(argc, argv);
ret = getrlimit(RLIMIT_STACK, &r);
if (ret)
CONFIG("getrlimit failed: %s", strerror(errno));
if (r.rlim_cur != RLIM_INFINITY)
CONFIG("Stack rlimit must be 'unlimited'");
fd = hugetlbfs_unlinked_fd();
if (fd < 0)
CONFIG("Couldn't get hugepage fd");
stack_end = try_setup_stack_and_huge(fd, sbrk(0));
if (!stack_end)
PASS_INCONCLUSIVE();
pid = clone(do_child, stack_end, SIGCHLD, 0);
if (pid < 0)
FAIL("clone: %s", strerror(errno));
ret = waitpid(pid, &s, 0);
if (ret == -1)
FAIL("waitpid: %s", strerror(errno));
/*
* The child grows its stack until a failure occurs. We expect
* this to result in a SIGSEGV. If any other signal is
* delivered (ie. SIGTRAP) or no signal is sent at all, we
* determine the kernel has not behaved correctly and trigger a
* test failure.
*/
if (WIFSIGNALED(s)) {
int sig = WTERMSIG(s);
if (sig == SIGSEGV) {
PASS();
} else {
FAIL("Got unexpected signal: %s", strsignal(sig));
}
}
FAIL("Child not signalled");
}