On (06/10/08 16:57), Adam Litke didst pronounce:
> On Mon, 2008-10-06 at 12:29 +0100, Mel Gorman wrote:
> > On (03/10/08 18:36), Andy Whitcroft didst pronounce:
> > > From: Adam Litke <[EMAIL PROTECTED]>
> > >
> > > The need to set and get pool counters for multiple huge page sizes is
> > > about to
> > > extend beyond just the libhugetlbfs tests. Move the counter code into
> > > hugeutils.c and make the top-level functions part of the libhugetlbfs
> > > pool and
> > > mount configuration API.
> >
> > This is the first mention of a mount configuration API. Glancing
> > through, we make changes to hugetlbfs.h but then do not expose the
> > functions in the lds file. What should happen is an application linking
> > against libhugetlbfs could see the functions in the header, but then
> > fail to bind them.
> >
> > We are linking the object files directly here which is why it appears to
> > work but the header changes need to be in the internal header, not
> > hugetlbfs.h.
> >
> > > This involves altering some function names and
> > > prologues to make them more consistent with the existing libhugetlbfs API.
> > >
> > > We create a new libtestutils.c for test case utilities that depend on
> > > linkage
> > > to libhugetlbfs.
> > >
> > > NOTE: This patch will cause the shmoverride test to fail compilation.
> > > This is
> > > fixed up by the next patch.
> > >
> > > [EMAIL PROTECTED]: consolidate makefile updates in one place]
> > > Signed-off-by: Adam Litke <[EMAIL PROTECTED]>
> > > ---
> > > hugetlbfs.h | 14 ++
> > > hugeutils.c | 157 +++++++++++++++++++---
> > > tests/Makefile | 4 +-
> > > tests/alloc-instantiate-race.c | 5 +-
> > > tests/chunk-overcommit.c | 3 +-
> > > tests/counters.c | 38 +++---
> > > tests/get_huge_pages.c | 14 +-
> > > tests/heap-overflow.c | 2 +-
> > > tests/hugetests.h | 20 +---
> > > tests/libtestutils.c | 137 +++++++++++++++++++
> > > tests/misaligned_offset.c | 20 ++--
> > > tests/quota.c | 6 +-
> > > tests/shmoverride_unlinked.c | 8 +-
> > > tests/testutils.c | 252
> > > +----------------------------------
> > > tests/truncate_reserve_wraparound.c | 21 ++--
> > > tests/truncate_sigbus_versus_oom.c | 3 +-
> > > 16 files changed, 349 insertions(+), 355 deletions(-)
> > > create mode 100644 tests/libtestutils.c
> > >
> > > diff --git a/hugetlbfs.h b/hugetlbfs.h
> > > index 48a2f68..2103515 100644
> > > --- a/hugetlbfs.h
> > > +++ b/hugetlbfs.h
> > > @@ -59,4 +59,18 @@ enum {
> > > };
> > > int hugetlbfs_test_feature(int feature_code);
> > >
> > > +/* Hugetlb pool counter operations */
> > > +/* Keys for reading hugetlb pool counters */
> > > +enum { /* The number of pages of a given size that
> > > ... */
> > > + HUGEPAGES_TOTAL, /* are allocated to the pool */
> > > + HUGEPAGES_FREE, /* are not in use */
> > > + HUGEPAGES_RSVD, /* are reserved for possible future use */
> > > + HUGEPAGES_SURP, /* are allocated to the pool on demand */
> > > + HUGEPAGES_OC, /* can be allocated on demand - maximum */
> > > + HUGEPAGES_MAX_COUNTERS,
> > > +};
> > > +long get_huge_page_counter(long pagesize, unsigned int counter);
> >
> > Ambigious name. Which counter? Free, rsvd, surp, what?
>
> Any of them (as determined by the counter parameter).
>
Ok.
> > > +int set_nr_hugepages(long pagesize, unsigned long val);
> > > +int set_nr_overcommit_hugepages(long pagesize, unsigned long val);
> > > +long read_meminfo(const char *tag);
> > > #endif /* _HUGETLBFS_H */
> > > diff --git a/hugeutils.c b/hugeutils.c
> > > index 1af26bb..f47b897 100644
> > > --- a/hugeutils.c
> > > +++ b/hugeutils.c
> > > @@ -118,7 +118,35 @@ long __lh_parse_page_size(const char *str)
> > > return size;
> > > }
> > >
> > > -static long read_meminfo(const char *tag)
> > > +struct hugetlb_pool_counter_info_t {
> > > + char *meminfo_key;
> > > + char *sysfs_file;
> > > +};
> > > +
> > > +struct hugetlb_pool_counter_info_t hugetlb_counter_info[] = {
> > > + [HUGEPAGES_TOTAL] = {
> > > + .meminfo_key = "HugePages_Total:",
> > > + .sysfs_file = "nr_hugepages",
> > > + },
> > > + [HUGEPAGES_FREE] = {
> > > + .meminfo_key = "HugePages_Free:",
> > > + .sysfs_file = "free_hugepages",
> > > + },
> > > + [HUGEPAGES_RSVD] = {
> > > + .meminfo_key = "HugePages_Rsvd:",
> > > + .sysfs_file = "resv_hugepages",
> > > + },
> > > + [HUGEPAGES_SURP] = {
> > > + .meminfo_key = "HugePages_Surp:",
> > > + .sysfs_file = "surplus_hugepages",
> > > + },
> > > + [HUGEPAGES_OC] = {
> > > + .meminfo_key = NULL,
> > > + .sysfs_file = "nr_overcommit_hugepages"
> > > + },
> > > +};
> > > +
> > > +static long file_read_ulong(char *file, const char *tag)
> > > {
> > > int fd;
> > > char buf[MEMINFO_SIZE];
> > > @@ -126,9 +154,9 @@ static long read_meminfo(const char *tag)
> > > char *p, *q;
> > > long val;
> > >
> > > - fd = open("/proc/meminfo", O_RDONLY);
> > > + fd = open(file, O_RDONLY);
> > > if (fd < 0) {
> > > - ERROR("Couldn't open /proc/meminfo (%s)\n", strerror(errno));
> > > + ERROR("Couldn't open %s: %s\n", file, strerror(errno));
> > > return -1;
> > > }
> > >
> > > @@ -136,37 +164,102 @@ static long read_meminfo(const char *tag)
> > > readerr = errno;
> > > close(fd);
> > > if (len < 0) {
> > > - ERROR("Error reading /proc/meminfo (%s)\n", strerror(readerr));
> > > + ERROR("Error reading %s: %s\n", file, strerror(errno));
> > > return -1;
> > > }
> > > if (len == sizeof(buf)) {
> > > - ERROR("/proc/meminfo is too large\n");
> > > + ERROR("%s is too large\n", file);
> > > return -1;
> > > }
> > > buf[len] = '\0';
> > >
> > > - p = strstr(buf, tag);
> > > - if (!p)
> > > - return -1; /* looks like the line we want isn't there */
> > > + /* Search for a tag if provided */
> > > + if (tag) {
> > > + p = strstr(buf, tag);
> > > + if (!p)
> > > + return -1; /* looks like the line we want isn't there */
> > > + p += strlen(tag);
> > > + } else
> > > + p = buf;
> > >
> >
> > The comment could be better here. I think the only case where a tag
> > makes no sense is sysfs files where you are just reading the value.
> > Point that out.
>
> Sysfs and Sysctls do not take tags. Only meminfo does.
>
Ok, the comment should explain that.
> > > - p += strlen(tag);
> > > - errno = 0;
> > > val = strtol(p, &q, 0);
> > > - if (errno != 0) {
> > > - if (errno == ERANGE && val == LONG_MAX)
> > > - ERROR("Value of %s in /proc/meminfo overflows long\n",
> > > tag);
> > > - else
> > > - ERROR("strtol() failed (%s)\n", strerror(errno));
> > > - return -1;
> > > - }
> > > if (! isspace(*q)) {
> > > - ERROR("Couldn't parse /proc/meminfo value\n");
> > > + ERROR("Couldn't parse %s value\n", file);
> > > return -1;
> > > }
> > >
> > > return val;
> > > }
> > >
> > > +static int file_write_ulong(char *file, unsigned long val)
> > > +{
> > > + FILE *f;
> > > + int ret;
> > > +
> > > + f = fopen(file, "w");
> > > + if (!f) {
> > > + ERROR("Couldn't open %s: %s\n", file, strerror(errno));
> > > + return -1;
> > > + }
> > > +
> > > + ret = fprintf(f, "%lu", val);
> > > + fclose(f);
> > > + return ret > 0 ? 0 : -1;
> > > +}
> > > +
> > > +static int select_pool_counter(unsigned int counter, unsigned long
> > > pagesize,
> > > + char *filename, char **key)
> > > +{
> >
> > This function needs a comment explaining what it is meant to be doing.
> > The name as-is doesn't tell me enough. What it appears to be doing is
> > giving you the proc/sysfs file that contains a given counter and a tagname
> > if appropriate.
> >
> > > + long default_size;
> > > + char *meminfo_key;
> > > + char *sysfs_file;
> > > +
> > > + if (counter >= HUGEPAGES_MAX_COUNTERS) {
> > > + ERROR("Invalid counter specified\n");
> > > + return -1;
> > > + }
> > > +
> > > + meminfo_key = hugetlb_counter_info[counter].meminfo_key;
> > > + sysfs_file = hugetlb_counter_info[counter].sysfs_file;
> > > + if (key)
> > > + *key = NULL;
> > > +
> > > + /*
> > > + * Get the meminfo page size.
> > > + * This could be made more efficient if utility functions were shared
> > > + * between libhugetlbfs and the test suite. For now we will just
> > > + * read /proc/meminfo.
> > > + */
> > > + default_size = file_read_ulong("/proc/meminfo", "Hugepagesize:");
> > > + if (default_size < 0) {
> > > + ERROR("Cannot determine the default page size\n");
> > > + return -1;
> > > + }
> >
> > hmm, strictly speaking we don't care if we can't get the default
> > pagesize because it's possible we can read it from sysfs. However, what
> > you are doing makes the most sense from a backwards-compatible point of
> > view.
> >
> > > +
> > > + /* If the user is dealing in the default page size, we can use /proc */
> > > + if (pagesize == default_size) {
> > > + if (meminfo_key && key) {
> > > + strcpy(filename, "/proc/meminfo");
> > > + *key = meminfo_key;
> > > + } else
> > > + sprintf(filename, "/proc/sys/vm/%s", sysfs_file);
> >
> > Why not always use the /proc/sys/vm file?
>
> Because the values in /proc/meminfo are not mirrored to /proc/sys/vm
> like they are to sysfs.
>
Fair point.
> > > + } else /* Use the sysfs interface */
> > > + sprintf(filename, "/sys/kernel/mm/hugepages/hugepages-%lukB/%s",
> > > + pagesize / 1024, sysfs_file);
> > > + return 0;
> > > +}
> >
> > General comment, we never check the size of filename that it's large
> > enough to store the pathname. I think we're safe as long as file is
> > always PATH_MAX+1 but if we were being paranoid, we would be passing the
> > length of filename in as a parameter.
> >
> > > +
> > > +static int set_pool_counter(long pagesize, unsigned int counter,
> > > + unsigned long val)
> > > +{
> > > + char file[PATH_MAX+1];
> > > +
> > > + if (select_pool_counter(counter, pagesize, file, NULL))
> > > + return -1;
> > > +
> > > + return file_write_ulong(file, val);
> > > +}
> > > +
> > > static int hpage_size_to_index(unsigned long size)
> > > {
> > > int i;
> > > @@ -197,7 +290,7 @@ static void probe_default_hpage_size(void)
> > > if (env && strlen(env) > 0)
> > > size = __lh_parse_page_size(env);
> > > else {
> > > - size = read_meminfo("Hugepagesize:");
> > > + size = file_read_ulong("/proc/meminfo", "Hugepagesize:");
> > > size *= 1024; /* convert from kB to B */
> > > }
> > >
> > > @@ -514,6 +607,27 @@ int __lh_hugetlbfs_prefault(int fd, void *addr,
> > > size_t length)
> > > return 0;
> > > }
> > >
> > > +long get_huge_page_counter(long pagesize, unsigned int counter)
> > > +{
> > > + char file[PATH_MAX+1];
> > > + char *key;
> > > +
> > > + if (select_pool_counter(counter, pagesize, file, &key))
> > > + return -1;
> > > +
> > > + return file_read_ulong(file, key);
> > > +}
> > > +
> > > +int set_nr_hugepages(long pagesize, unsigned long val)
> > > +{
> > > + return set_pool_counter(pagesize, HUGEPAGES_TOTAL, val);
> > > +}
> > > +
> > > +int set_nr_overcommit_hugepages(long pagesize, unsigned long val)
> > > +{
> > > + return set_pool_counter(pagesize, HUGEPAGES_OC, val);
> > > +}
> > > +
> > > /********************************************************************/
> > > /* Library user visible DIAGNOSES/DEBUGGING ONLY functions */
> > > /********************************************************************/
> > > @@ -549,3 +663,8 @@ long __lh_dump_proc_pid_maps()
> > > fclose(f);
> > > return 0;
> > > }
> > > +
> > > +long read_meminfo(const char *tag)
> > > +{
> > > + return file_read_ulong("/proc/meminfo", tag);
> > > +}
> > > diff --git a/tests/Makefile b/tests/Makefile
> > > index c8d47a5..beee18e 100644
> > > --- a/tests/Makefile
> > > +++ b/tests/Makefile
> > > @@ -100,11 +100,11 @@ obj64/libheapshrink.so:
> > > obj64/heapshrink-helper-pic.o
> > > @mkdir -p obj64
> > > $(CC64) -Wl,-soname,$(notdir $@) -shared -o $@ $^
> > >
> > > -$(LIB_TESTS:%=obj32/%): %: %.o obj32/testutils.o
> > > +$(LIB_TESTS:%=obj32/%): %: %.o obj32/testutils.o obj32/libtestutils.o
> > > @$(VECHO) LD32 "(lib test)" $@
> > > $(CC32) $(LDFLAGS) $(LDFLAGS32) -o $@ $^ $(LDLIBS) -lhugetlbfs
> > >
> > > -$(LIB_TESTS:%=obj64/%) $(LIB_TESTS_64:%=obj64/%): %: %.o
> > > obj64/testutils.o
> > > +$(LIB_TESTS:%=obj64/%) $(LIB_TESTS_64:%=obj64/%): %: %.o
> > > obj64/testutils.o obj64/libtestutils.o
> > > @$(VECHO) LD64 "(lib test)" $@
> > > $(CC64) $(LDFLAGS) $(LDFLAGS64) -o $@ $^ $(LDLIBS) -lhugetlbfs
> > >
> >
> > I think the way we link here is why we get away with changing
> > hugetlbfs.h without updating the lds file.
>
> Yep, the $^ pulls in the objects themselves. The reason we have to do
> this is because some tests want to use testutils functions but not link
> against the library proper. In order to support this small subset of
> tests, all test utils that require library linkage need to move to
> libtestutils.c
>
Then they should be using the internal header file at least. Bear in
mind that hugetlb.h is installed for use by applications that directly
link to libhugetlbfs. They shouldn't have the signature to functions
they can't call.
> > > diff --git a/tests/alloc-instantiate-race.c
> > > b/tests/alloc-instantiate-race.c
> > > index 698fa2f..0929924 100644
> > > --- a/tests/alloc-instantiate-race.c
> > > +++ b/tests/alloc-instantiate-race.c
> > > @@ -233,7 +233,8 @@ int main(int argc, char *argv[])
> > > if (argc != 2)
> > > CONFIG("Usage: alloc-instantiate-race <private|shared>");
> > >
> > > - totpages = get_pool_counter(HUGEPAGES_FREE, 0);
> > > + hpage_size = check_hugepagesize();
> > > + totpages = get_huge_page_counter(hpage_size, HUGEPAGES_FREE);
> > >
> > > if (strcmp(argv[1], "shared") == 0) {
> > > race_type = MAP_SHARED;
> > > @@ -243,8 +244,6 @@ int main(int argc, char *argv[])
> > > CONFIG("Usage: alloc-instantiate-race <private|shared>");
> > > }
> > >
> > > - hpage_size = check_hugepagesize();
> > > -
> > > fd = hugetlbfs_unlinked_fd();
> > > if (fd < 0)
> > > FAIL("hugetlbfs_unlinked_fd()");
> > > diff --git a/tests/chunk-overcommit.c b/tests/chunk-overcommit.c
> > > index 9c6f0a8..e8f20e0 100644
> > > --- a/tests/chunk-overcommit.c
> > > +++ b/tests/chunk-overcommit.c
> > > @@ -59,9 +59,8 @@ int main(int argc, char *argv[])
> > >
> > > test_init(argc, argv);
> > >
> > > - totpages = get_pool_counter(HUGEPAGES_FREE, 0);
> > > -
> > > hpage_size = check_hugepagesize();
> > > + totpages = get_huge_page_counter(hpage_size, HUGEPAGES_FREE);
> > >
> > > fd = hugetlbfs_unlinked_fd();
> > > if (fd < 0)
> > > diff --git a/tests/counters.c b/tests/counters.c
> > > index f97d68a..522a00d 100644
> > > --- a/tests/counters.c
> > > +++ b/tests/counters.c
> > > @@ -45,8 +45,8 @@ extern int errno;
> > >
> > > /* Global test configuration */
> > > #define DYNAMIC_SYSCTL "/proc/sys/vm/nr_overcommit_hugepages"
> > > -static long saved_nr_hugepages;
> > > -static long saved_oc_hugepages;
> > > +static long saved_nr_hugepages = -1;
> > > +static long saved_oc_hugepages = -1;
> > > static long hpage_size;
> > > static int private_resv;
> > >
> > > @@ -70,17 +70,20 @@ static long prev_surp;
> > >
> > > /* Restore original nr_hugepages */
> > > void cleanup(void) {
> > > - set_pool_counter(HUGEPAGES_TOTAL, saved_nr_hugepages, 0);
> > > + if (hpage_size <= 0)
> > > + return;
> > > + if (saved_nr_hugepages >= 0)
> > > + set_nr_hugepages(hpage_size, saved_nr_hugepages);
> > > if (saved_oc_hugepages >= 0)
> > > - set_pool_counter(HUGEPAGES_OC, saved_oc_hugepages, 0);
> > > + set_nr_overcommit_hugepages(hpage_size, saved_oc_hugepages);
> > > }
> > >
> > > void verify_dynamic_pool_support(void)
> > > {
> > > - saved_oc_hugepages = get_pool_counter(HUGEPAGES_OC, 0);
> > > + saved_oc_hugepages = get_huge_page_counter(hpage_size, HUGEPAGES_OC);
> > > if (saved_oc_hugepages < 0)
> > > FAIL("Kernel appears to lack dynamic hugetlb pool support");
> > > - set_pool_counter(HUGEPAGES_OC, 10, 0);
> > > + set_nr_overcommit_hugepages(hpage_size, 10);
> > > }
> > >
> > > void bad_value(int line, const char *name, long expect, long actual)
> > > @@ -96,10 +99,10 @@ void verify_counters(int line, long et, long ef, long
> > > er, long es)
> > > {
> > > long t, f, r, s;
> > >
> > > - t = get_pool_counter(HUGEPAGES_TOTAL, 0);
> > > - f = get_pool_counter(HUGEPAGES_FREE, 0);
> > > - r = get_pool_counter(HUGEPAGES_RSVD, 0);
> > > - s = get_pool_counter(HUGEPAGES_SURP, 0);
> > > + t = get_huge_page_counter(hpage_size, HUGEPAGES_TOTAL);
> > > + f = get_huge_page_counter(hpage_size, HUGEPAGES_FREE);
> > > + r = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > + s = get_huge_page_counter(hpage_size, HUGEPAGES_SURP);
> > >
> > > /* Invariant checks */
> > > if (t < 0 || f < 0 || r < 0 || s < 0)
> > > @@ -136,7 +139,7 @@ void _set_nr_hugepages(unsigned long count, int line)
> > > long min_size;
> > > long et, ef, er, es;
> > >
> > > - if (set_pool_counter(HUGEPAGES_TOTAL, count, 0))
> > > + if (set_nr_hugepages(hpage_size, count))
> > > FAIL("Cannot set nr_hugepages");
> > >
> > > /* The code below is based on set_max_huge_pages in mm/hugetlb.c */
> > > @@ -361,19 +364,16 @@ void run_test(char *desc, int base_nr)
> > >
> > > int main(int argc, char ** argv)
> > > {
> > > - int fd, base_nr;
> > > + int base_nr;
> > >
> > > test_init(argc, argv);
> > > - check_must_be_root();
> > > - saved_nr_hugepages = get_pool_counter(HUGEPAGES_TOTAL, 0);
> > > + hpage_size = check_hugepagesize();
> > > + saved_nr_hugepages = get_huge_page_counter(hpage_size, HUGEPAGES_TOTAL);
> > > verify_dynamic_pool_support();
> > > + check_must_be_root();
> > >
> > > - fd = hugetlbfs_unlinked_fd();
> > > - if ((private_resv = kernel_has_private_reservations(fd)) == -1)
> > > + if ((private_resv = kernel_has_private_reservations()) == -1)
> > > FAIL("kernel_has_private_reservations() failed\n");
> > > - close(fd);
> > > -
> > > - hpage_size = check_hugepagesize();
> > >
> > > /*
> > > * This test case should require a maximum of 3 huge pages.
> > > diff --git a/tests/get_huge_pages.c b/tests/get_huge_pages.c
> > > index c55be8e..62b27ea 100644
> > > --- a/tests/get_huge_pages.c
> > > +++ b/tests/get_huge_pages.c
> > > @@ -25,13 +25,14 @@
> > >
> > > #include "hugetests.h"
> > >
> > > +long hpage_size;
> > > long oc_hugepages = -1;
> > >
> > > /* Restore nr_overcommit_hugepages */
> > > void cleanup(void)
> > > {
> > > if (oc_hugepages != -1)
> > > - set_pool_counter(HUGEPAGES_OC, oc_hugepages, 0);
> > > + set_nr_overcommit_hugepages(hpage_size, oc_hugepages);
> > > }
> > >
> > > /* Confirm a region really frees, only really important for GHP_FALLBACK
> > > */
> > > @@ -45,7 +46,6 @@ void free_and_confirm_region_free(void *p, int line) {
> > > void test_get_huge_pages(int num_hugepages)
> > > {
> > > int err;
> > > - long hpage_size = check_hugepagesize();
> > > void *p = get_huge_pages(num_hugepages * hpage_size, GHP_DEFAULT);
> > > if (p == NULL)
> > > FAIL("get_huge_pages() for %d hugepages", num_hugepages);
> > > @@ -65,14 +65,13 @@ void test_get_huge_pages(int num_hugepages)
> > > void test_GHP_FALLBACK(void)
> > > {
> > > int err;
> > > - long hpage_size = check_hugepagesize();
> > > - long rsvd_hugepages = get_pool_counter(HUGEPAGES_RSVD, 0);
> > > - long num_hugepages = get_pool_counter(HUGEPAGES_TOTAL, 0)
> > > + long rsvd_hugepages = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > + long num_hugepages = get_huge_page_counter(hpage_size, HUGEPAGES_TOTAL)
> > > - rsvd_hugepages;
> > >
> > > /* We must disable overcommitted huge pages to test this */
> > > - oc_hugepages = get_pool_counter(HUGEPAGES_OC, 0);
> > > - set_pool_counter(HUGEPAGES_OC, 0, 0);
> > > + oc_hugepages = get_huge_page_counter(hpage_size, HUGEPAGES_OC);
> > > + set_nr_overcommit_hugepages(hpage_size, 0);
> > >
> > > /* We should be able to allocate the whole pool */
> > > void *p = get_huge_pages(num_hugepages * hpage_size, GHP_DEFAULT);
> > > @@ -118,6 +117,7 @@ void test_GHP_FALLBACK(void)
> > > int main(int argc, char *argv[])
> > > {
> > > test_init(argc, argv);
> > > + hpage_size = gethugepagesize();
> > > check_free_huge_pages(4);
> > > test_get_huge_pages(1);
> > > test_get_huge_pages(4);
> > > diff --git a/tests/heap-overflow.c b/tests/heap-overflow.c
> > > index 7d1b9ba..0f1029c 100644
> > > --- a/tests/heap-overflow.c
> > > +++ b/tests/heap-overflow.c
> > > @@ -41,7 +41,7 @@ int main(int argc, char **argv)
> > >
> > > hpagesize = check_hugepagesize();
> > >
> > > - freepages = get_pool_counter(HUGEPAGES_FREE, 0);
> > > + freepages = get_huge_page_counter(hpagesize, HUGEPAGES_FREE);
> > > if (freepages < 3)
> > > CONFIG("Must have at least 3 free hugepages");
> > >
> > > diff --git a/tests/hugetests.h b/tests/hugetests.h
> > > index 71a1e21..bb1146e 100644
> > > --- a/tests/hugetests.h
> > > +++ b/tests/hugetests.h
> > > @@ -127,27 +127,9 @@ static inline long check_hugepagesize()
> > > return hpage_size;
> > > }
> > >
> > > -/* Keys for reading hugetlb pool counters */
> > > -enum {
> > > - HUGEPAGES_TOTAL,
> > > - HUGEPAGES_FREE,
> > > - HUGEPAGES_RSVD,
> > > - HUGEPAGES_SURP,
> > > - HUGEPAGES_OC,
> > > - HUGEPAGES_MAX_COUNTERS,
> > > -};
> > > -struct hugetlb_pool_counter_info_t {
> > > - char *meminfo_key;
> > > - char *sysfs_file;
> > > -};
> > > -extern struct hugetlb_pool_counter_info_t hugetlb_counter_info[];
> > > -long get_pool_counter(unsigned int counter, unsigned long pagesize);
> > > -int set_pool_counter(unsigned int counter, unsigned long val,
> > > - unsigned long pagesize);
> > > -
> > > int using_system_hpage_size(const char *mount);
> > >
> > > /* WARNING: Racy -- use for test cases only! */
> > > -int kernel_has_private_reservations(int fd);
> > > +int kernel_has_private_reservations(void);
> > >
> >
> > This signature change is a surprise. Call it out in the leader.
> >
> > > #endif /* _HUGETESTS_H */
> > > diff --git a/tests/libtestutils.c b/tests/libtestutils.c
> > > new file mode 100644
> > > index 0000000..93388a9
> > > --- /dev/null
> > > +++ b/tests/libtestutils.c
> > > @@ -0,0 +1,137 @@
> > > +/*
> > > + * libhugetlbfs - Easy use of Linux hugepages
> > > + * Copyright (C) 2008 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 _LARGEFILE64_SOURCE
> > > +#define _GNU_SOURCE
> > > +
> > > +#include <stdio.h>
> > > +#include <stdlib.h>
> > > +#include <limits.h>
> > > +#include <string.h>
> > > +#include <errno.h>
> > > +#include <ctype.h>
> > > +#include <unistd.h>
> > > +#include <signal.h>
> > > +#include <sys/types.h>
> > > +#include <sys/vfs.h>
> > > +#include <sys/ipc.h>
> > > +#include <sys/shm.h>
> > > +#include <sys/stat.h>
> > > +#include <sys/mman.h>
> > > +#include <fcntl.h>
> > > +
> > > +#include "hugetlbfs.h"
> > > +#include "hugetests.h"
> > > +
> > > +void check_free_huge_pages(int nr_pages_needed)
> > > +{
> > > + long hpage_size = gethugepagesize();
> > > + int freepages = get_huge_page_counter(hpage_size, HUGEPAGES_FREE);
> > > + if (freepages < nr_pages_needed)
> > > + CONFIG("Must have at least %i free hugepages", nr_pages_needed);
> > > +}
> > > +
> > > +int using_system_hpage_size(const char *mount)
> > > +{
> > > + struct statfs64 sb;
> > > + int err;
> > > + long meminfo_size, mount_size;
> > > +
> > > + if (!mount)
> > > + FAIL("using_system_hpage_size: hugetlbfs is not mounted\n");
> > > +
> > > + err = statfs64(mount, &sb);
> > > + if (err)
> > > + FAIL("statfs64: %s\n", strerror(errno));
> > > +
> > > + meminfo_size = read_meminfo("Hugepagesize:");
> > > + if (meminfo_size < 0)
> > > + FAIL("using_system_hpage_size: Failed to read /proc/meminfo\n");
> > > +
> > > + mount_size = sb.f_bsize / 1024; /* Compare to meminfo in kB */
> > > + if (mount_size == meminfo_size)
> > > + return 1;
> > > + else
> > > + return 0;
> > > +}
> > > +
> > > +/* WARNING: This function relies on the hugetlb pool counters in a way
> > > that
> > > + * is known to be racy. Due to the expected usage of hugetlbfs test
> > > cases, the
> > > + * risk of a race is acceptible. This function should NOT be used for
> > > real
> > > + * applications.
> > > + */
> > > +int kernel_has_private_reservations(void)
> > > +{
> > > + int fd;
> > > + long t, f, r, s;
> > > + long nt, nf, nr, ns;
> > > + long hpage_size = gethugepagesize();
> > > + void *map;
> > > +
> > > + /* Read pool counters */
> > > + t = get_huge_page_counter(hpage_size, HUGEPAGES_TOTAL);
> > > + f = get_huge_page_counter(hpage_size, HUGEPAGES_FREE);
> > > + r = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > + s = get_huge_page_counter(hpage_size, HUGEPAGES_SURP);
> > > +
> > > + fd = hugetlbfs_unlinked_fd();
> > > + if (fd < 0) {
> > > + ERROR("kernel_has_private_reservations: hugetlbfs_unlinked_fd: "
> > > + "%s\n", strerror(errno));
> > > + return -1;
> > > + }
> > > + map = mmap(NULL, hpage_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
> > > + if (map == MAP_FAILED) {
> > > + ERROR("kernel_has_private_reservations: mmap: %s\n",
> > > + strerror(errno));
> > > + return -1;
> > > + }
> > > +
> > > + /* Recheck the counters */
> > > + nt = get_huge_page_counter(hpage_size, HUGEPAGES_TOTAL);
> > > + nf = get_huge_page_counter(hpage_size, HUGEPAGES_FREE);
> > > + nr = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > + ns = get_huge_page_counter(hpage_size, HUGEPAGES_SURP);
> > > +
> > > + munmap(map, hpage_size);
> > > + close(fd);
> > > +
> > > + /*
> > > + * There are only three valid cases:
> > > + * 1) If a surplus page was allocated to create a reservation, all
> > > + * four pool counters increment
> > > + * 2) All counters remain the same except for Hugepages_Rsvd, then
> > > + * a reservation was created using an existing pool page.
> > > + * 3) All counters remain the same, indicates that no reservation has
> > > + * been created
> > > + */
> > > + if ((nt == t + 1) && (nf == f + 1) && (ns == s + 1) && (nr == r + 1)) {
> > > + return 1;
> > > + } else if ((nt == t) && (nf == f) && (ns == s)) {
> > > + if (nr == r + 1)
> > > + return 1;
> > > + else if (nr == r)
> > > + return 0;
> > > + } else {
> > > + ERROR("kernel_has_private_reservations: bad counter state - "
> > > + "T:%li F:%li R:%li S:%li -> T:%li F:%li R:%li S:%li\n",
> > > + t, f, r, s, nt, nf, nr, ns);
> > > + }
> > > + return -1;
> > > +}
> > > diff --git a/tests/misaligned_offset.c b/tests/misaligned_offset.c
> > > index 4b1eb8f..e82ffe1 100644
> > > --- a/tests/misaligned_offset.c
> > > +++ b/tests/misaligned_offset.c
> > > @@ -44,11 +44,6 @@
> > > * 856fc29505556cf263f3dcda2533cf3766c14ab6.
> > > */
> > >
> > > -static unsigned long read_free(void)
> > > -{
> > > - return get_pool_counter(HUGEPAGES_FREE, 0);
> > > -}
> > > -
> > > #define RANDOM_CONSTANT 0x1234ABCD
> > >
> > > int main(int argc, char *argv[])
> > > @@ -80,7 +75,8 @@ int main(int argc, char *argv[])
> > > * backout path for the bogus mapping is buggy, which it was
> > > * in some kernels. */
> > >
> > > - verbose_printf("Free hugepages: %lu\n", read_free());
> > > + verbose_printf("Free hugepages: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_FREE));
> > >
> > > verbose_printf("Mapping reference map...");
> > > /* First get arena of three hpages size, at file offset 4GB */
> > > @@ -89,7 +85,8 @@ int main(int argc, char *argv[])
> > > FAIL("mmap() offset 4GB: %s", strerror(errno));
> > > verbose_printf("%p-%p\n", p, p+2*hpage_size-1);
> > >
> > > - verbose_printf("Free hugepages: %lu\n", read_free());
> > > + verbose_printf("Free hugepages: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_FREE));
> > >
> > > /* Instantiate the pages */
> > > verbose_printf("Instantiating...");
> > > @@ -98,7 +95,8 @@ int main(int argc, char *argv[])
> > > *pi = RANDOM_CONSTANT;
> > > verbose_printf("done.\n");
> > >
> > > - verbose_printf("Free hugepages: %lu\n", read_free());
> > > + verbose_printf("Free hugepages: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_FREE));
> > >
> > > /* Toggle the permissions on the first page. This forces TLB
> > > * entries (including hash page table on powerpc) to be
> > > @@ -123,13 +121,15 @@ int main(int argc, char *argv[])
> > > strerror(errno), strerror(EINVAL));
> > > verbose_printf("%s\n", strerror(errno));
> > >
> > > - verbose_printf("Free hugepages: %lu\n", read_free());
> > > + verbose_printf("Free hugepages: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_FREE));
> > >
> > > if (*pi != RANDOM_CONSTANT)
> > > FAIL("Pre-existing mapping clobbered: %x instead of %x",
> > > *pi, RANDOM_CONSTANT);
> > >
> > > - verbose_printf("Free hugepages: %lu\n", read_free());
> > > + verbose_printf("Free hugepages: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_FREE));
> > >
> > > /* The real test is whether we got a bad_pud() or similar
> > > * during the run. The check above, combined with the earlier
> > > diff --git a/tests/quota.c b/tests/quota.c
> > > index 3dc9dcd..4961371 100644
> > > --- a/tests/quota.c
> > > +++ b/tests/quota.c
> > > @@ -207,7 +207,7 @@ void _spawn(int l, int expected_result, unsigned long
> > > size, int mmap_flags,
> > >
> > > int main(int argc, char ** argv)
> > > {
> > > - int fd, private_resv;
> > > + int private_resv;
> > > int bad_priv_resv;
> > >
> > > test_init(argc, argv);
> > > @@ -221,9 +221,7 @@ int main(int argc, char ** argv)
> > > check_must_be_root();
> > > check_free_huge_pages(1);
> > >
> > > - fd = hugetlbfs_unlinked_fd();
> > > - private_resv = kernel_has_private_reservations(fd);
> > > - close(fd);
> > > + private_resv = kernel_has_private_reservations();
> > > if (private_resv == -1)
> > > FAIL("kernel_has_private_reservations() failed\n");
> > > bad_priv_resv = private_resv ? BAD_EXIT : BAD_SIG;
> > > diff --git a/tests/shmoverride_unlinked.c b/tests/shmoverride_unlinked.c
> > > index 2721b92..a8af228 100644
> > > --- a/tests/shmoverride_unlinked.c
> > > +++ b/tests/shmoverride_unlinked.c
> > > @@ -94,7 +94,7 @@ void _shmunmap(int s, int line)
> > > }
> > > #define shmunmap(s) _shmunmap(s, __LINE__)
> > >
> > > -void set_nr_hugepages(unsigned long count)
> > > +void setup_hugetlb_pool(unsigned long count)
> > > {
> > > FILE *fd;
> > > unsigned long poolsize;
> > > @@ -116,7 +116,7 @@ void run_test(char *desc, int hpages, int bpages, int
> > > pool_nr, int expect_diff)
> > > {
> > > long resv_before, resv_after;
> > > verbose_printf("%s...\n", desc);
> > > - set_nr_hugepages(pool_nr);
> > > + setup_hugetlb_pool(pool_nr);
> > >
> > > /* untouched, shared mmap */
> > > resv_before = read_meminfo("HugePages_Rsvd:");
> > > @@ -135,7 +135,7 @@ void run_test(char *desc, int hpages, int bpages, int
> > > pool_nr, int expect_diff)
> > > void cleanup(void)
> > > {
> > > if (saved_nr_hugepages >= 0)
> > > - set_nr_hugepages(saved_nr_hugepages);
> > > + setup_hugetlb_pool(saved_nr_hugepages);
> > > }
> > >
> > > int main(int argc, char **argv)
> > > @@ -166,7 +166,7 @@ int main(int argc, char **argv)
> > > run_test("override-requested-unaligned", 1, 1, POOL_SIZE, 2);
> > >
> > > /* Run the test with no pool but requested large pages */
> > > - set_nr_hugepages(0);
> > > + setup_hugetlb_pool(0);
> > > run_test("override-requested-aligned-nopool", 1, 0, 0, 0);
> > >
> > > PASS();
> > > diff --git a/tests/testutils.c b/tests/testutils.c
> > > index 910d116..b8a1bf2 100644
> > > --- a/tests/testutils.c
> > > +++ b/tests/testutils.c
> > > @@ -36,6 +36,7 @@
> > > #include <sys/mman.h>
> > > #include <fcntl.h>
> > >
> > > +#include "hugetlbfs.h"
> > > #include "hugetests.h"
> > >
> > > #define HUGETLBFS_MAGIC 0x958458f6
> > > @@ -45,13 +46,6 @@
> > > int verbose_test = 1;
> > > char *test_name;
> > >
> > > -void check_free_huge_pages(int nr_pages_needed)
> > > -{
> > > - int freepages = get_pool_counter(HUGEPAGES_FREE, 0);
> > > - if (freepages < nr_pages_needed)
> > > - CONFIG("Must have at least %i free hugepages", nr_pages_needed);
> > > -}
> > > -
> > > void check_must_be_root(void)
> > > {
> > > uid_t uid = getuid();
> > > @@ -205,164 +199,6 @@ int test_addr_huge(void *p)
> > > return (sb.f_type == HUGETLBFS_MAGIC);
> > > }
> > >
> > > -struct hugetlb_pool_counter_info_t hugetlb_counter_info[] = {
> > > - [HUGEPAGES_TOTAL] = {
> > > - .meminfo_key = "HugePages_Total:",
> > > - .sysfs_file = "nr_hugepages",
> > > - },
> > > - [HUGEPAGES_FREE] = {
> > > - .meminfo_key = "HugePages_Free:",
> > > - .sysfs_file = "free_hugepages",
> > > - },
> > > - [HUGEPAGES_RSVD] = {
> > > - .meminfo_key = "HugePages_Rsvd:",
> > > - .sysfs_file = "resv_hugepages",
> > > - },
> > > - [HUGEPAGES_SURP] = {
> > > - .meminfo_key = "HugePages_Surp:",
> > > - .sysfs_file = "surplus_hugepages",
> > > - },
> > > - [HUGEPAGES_OC] = {
> > > - .meminfo_key = NULL,
> > > - .sysfs_file = "nr_overcommit_hugepages"
> > > - },
> > > -};
> > > -
> > > -long file_read_ulong(char *file, const char *tag)
> > > -{
> > > - int fd;
> > > - char buf[MEMINFO_SZ];
> > > - int len, readerr;
> > > - char *p, *q;
> > > - long val;
> > > -
> > > - fd = open(file, O_RDONLY);
> > > - if (fd < 0) {
> > > - ERROR("Couldn't open %s: %s\n", file, strerror(errno));
> > > - return -1;
> > > - }
> > > -
> > > - len = read(fd, buf, sizeof(buf));
> > > - readerr = errno;
> > > - close(fd);
> > > - if (len < 0) {
> > > - ERROR("Error reading %s: %s\n", file, strerror(errno));
> > > - return -1;
> > > - }
> > > - if (len == sizeof(buf)) {
> > > - ERROR("%s is too large\n", file);
> > > - return -1;
> > > - }
> > > - buf[len] = '\0';
> > > -
> > > - /* Search for a tag if provided */
> > > - if (tag) {
> > > - p = strstr(buf, tag);
> > > - if (!p)
> > > - return -1; /* looks like the line we want isn't there */
> > > - p += strlen(tag);
> > > - } else
> > > - p = buf;
> > > -
> > > - val = strtol(p, &q, 0);
> > > - if (! isspace(*q)) {
> > > - ERROR("Couldn't parse %s value\n", file);
> > > - return -1;
> > > - }
> > > -
> > > - return val;
> > > -}
> > > -
> > > -int file_write_ulong(char *file, unsigned long val)
> > > -{
> > > - FILE *f;
> > > - int ret;
> > > -
> > > - f = fopen(file, "w");
> > > - if (!f) {
> > > - ERROR("Couldn't open %s: %s\n", file, strerror(errno));
> > > - return -1;
> > > - }
> > > -
> > > - ret = fprintf(f, "%lu", val);
> > > - fclose(f);
> > > - return ret > 0 ? 0 : -1;
> > > -}
> > > -
> > > -int select_pool_counter(unsigned int counter, unsigned long pagesize,
> > > - char *filename, char **key)
> > > -{
> > > - long default_size;
> > > - char *meminfo_key;
> > > - char *sysfs_file;
> > > -
> > > - if (counter >= HUGEPAGES_MAX_COUNTERS) {
> > > - ERROR("Invalid counter specified\n");
> > > - return -1;
> > > - }
> > > -
> > > - meminfo_key = hugetlb_counter_info[counter].meminfo_key;
> > > - sysfs_file = hugetlb_counter_info[counter].sysfs_file;
> > > - if (key)
> > > - *key = NULL;
> > > -
> > > - /*
> > > - * Get the meminfo page size.
> > > - * This could be made more efficient if utility functions were shared
> > > - * between libhugetlbfs and the test suite. For now we will just
> > > - * read /proc/meminfo.
> > > - */
> > > - default_size = file_read_ulong("/proc/meminfo", "Hugepagesize:");
> > > - default_size *= 1024; /* Convert from kB to B */
> > > - if (default_size < 0) {
> > > - ERROR("Cannot determine the default page size\n");
> > > - return -1;
> > > - }
> > > -
> > > - /* Convert a pagesize of 0 to the libhugetlbfs default size */
> > > - if (pagesize == 0)
> > > - pagesize = gethugepagesize();
> > > -
> > > - /* If the user is dealing in the default page size, we can use /proc */
> > > - if (pagesize == default_size) {
> > > - if (meminfo_key && key) {
> > > - strcpy(filename, "/proc/meminfo");
> > > - *key = meminfo_key;
> > > - } else
> > > - sprintf(filename, "/proc/sys/vm/%s", sysfs_file);
> > > - } else /* Use the sysfs interface */
> > > - sprintf(filename, "/sys/kernel/mm/hugepages/hugepages-%lukB/%s",
> > > - pagesize / 1024, sysfs_file);
> > > - return 0;
> > > -}
> > > -
> > > -long get_pool_counter(unsigned int counter, unsigned long pagesize)
> > > -{
> > > - char file[PATH_MAX+1];
> > > - char *key;
> > > -
> > > - if (select_pool_counter(counter, pagesize, file, &key))
> > > - return -1;
> > > -
> > > - return file_read_ulong(file, key);
> > > -}
> > > -
> > > -int set_pool_counter(unsigned int counter, unsigned long val,
> > > - unsigned long pagesize)
> > > -{
> > > - char file[PATH_MAX+1];
> > > -
> > > - if (select_pool_counter(counter, pagesize, file, NULL))
> > > - return -1;
> > > -
> > > - return file_write_ulong(file, val);
> > > -}
> > > -
> > > -long read_meminfo(const char *tag)
> > > -{
> > > - return file_read_ulong("/proc/meminfo", tag);
> > > -}
> > > -
> > > ino_t get_addr_inode(void *p)
> > > {
> > > char name[256];
> > > @@ -406,89 +242,3 @@ int remove_shmid(int shmid)
> > > }
> > > return 0;
> > > }
> > > -
> > > -/* WARNING: This function relies on the hugetlb pool counters in a way
> > > that
> > > - * is known to be racy. Due to the expected usage of hugetlbfs test
> > > cases, the
> > > - * risk of a race is acceptible. This function should NOT be used for
> > > real
> > > - * applications.
> > > - */
> > > -int kernel_has_private_reservations(int fd)
> > > -{
> > > - long t, f, r, s;
> > > - long nt, nf, nr, ns;
> > > - void *map;
> > > -
> > > - /* Read pool counters */
> > > - t = get_pool_counter(HUGEPAGES_TOTAL, 0);
> > > - f = get_pool_counter(HUGEPAGES_FREE, 0);
> > > - r = get_pool_counter(HUGEPAGES_RSVD, 0);
> > > - s = get_pool_counter(HUGEPAGES_SURP, 0);
> > > -
> > > -
> > > - if (fd < 0) {
> > > - ERROR("kernel_has_private_reservations: hugetlbfs_unlinked_fd: "
> > > - "%s\n", strerror(errno));
> > > - return -1;
> > > - }
> > > - map = mmap(NULL, gethugepagesize(), PROT_READ|PROT_WRITE, MAP_PRIVATE,
> > > fd, 0);
> > > - if (map == MAP_FAILED) {
> > > - ERROR("kernel_has_private_reservations: mmap: %s\n",
> > > - strerror(errno));
> > > - return -1;
> > > - }
> > > -
> > > - /* Recheck the counters */
> > > - nt = get_pool_counter(HUGEPAGES_TOTAL, 0);
> > > - nf = get_pool_counter(HUGEPAGES_FREE, 0);
> > > - nr = get_pool_counter(HUGEPAGES_RSVD, 0);
> > > - ns = get_pool_counter(HUGEPAGES_SURP, 0);
> > > -
> > > - munmap(map, gethugepagesize());
> > > -
> > > - /*
> > > - * There are only three valid cases:
> > > - * 1) If a surplus page was allocated to create a reservation, all
> > > - * four pool counters increment
> > > - * 2) All counters remain the same except for Hugepages_Rsvd, then
> > > - * a reservation was created using an existing pool page.
> > > - * 3) All counters remain the same, indicates that no reservation has
> > > - * been created
> > > - */
> > > - if ((nt == t + 1) && (nf == f + 1) && (ns == s + 1) && (nr == r + 1)) {
> > > - return 1;
> > > - } else if ((nt == t) && (nf == f) && (ns == s)) {
> > > - if (nr == r + 1)
> > > - return 1;
> > > - else if (nr == r)
> > > - return 0;
> > > - } else {
> > > - ERROR("kernel_has_private_reservations: bad counter state - "
> > > - "T:%li F:%li R:%li S:%li -> T:%li F:%li R:%li S:%li\n",
> > > - t, f, r, s, nt, nf, nr, ns);
> > > - }
> > > - return -1;
> > > -}
> > > -
> > > -int using_system_hpage_size(const char *mount)
> > > -{
> > > - struct statfs64 sb;
> > > - int err;
> > > - long meminfo_size, mount_size;
> > > -
> > > - if (!mount)
> > > - FAIL("using_system_hpage_size: hugetlbfs is not mounted\n");
> > > -
> > > - err = statfs64(mount, &sb);
> > > - if (err)
> > > - FAIL("statfs64: %s\n", strerror(errno));
> > > -
> > > - meminfo_size = file_read_ulong("/proc/meminfo", "Hugepagesize:");
> > > - if (meminfo_size < 0)
> > > - FAIL("using_system_hpage_size: Failed to read /proc/meminfo\n");
> > > -
> > > - mount_size = sb.f_bsize / 1024; /* Compare to meminfo in kB */
> > > - if (mount_size == meminfo_size)
> > > - return 1;
> > > - else
> > > - return 0;
> > > -}
> > > diff --git a/tests/truncate_reserve_wraparound.c
> > > b/tests/truncate_reserve_wraparound.c
> > > index f7af96b..d1da59f 100644
> > > --- a/tests/truncate_reserve_wraparound.c
> > > +++ b/tests/truncate_reserve_wraparound.c
> > > @@ -50,11 +50,6 @@ static void sigbus_handler(int signum, siginfo_t *si,
> > > void *uc)
> > > siglongjmp(sig_escape, 17);
> > > }
> > >
> > > -static unsigned long read_reserved(void)
> > > -{
> > > - return get_pool_counter(HUGEPAGES_RSVD, 0);
> > > -}
> > > -
> > > int main(int argc, char *argv[])
> > > {
> > > long hpage_size;
> > > @@ -77,7 +72,7 @@ int main(int argc, char *argv[])
> > > if (fd < 0)
> > > FAIL("hugetlbfs_unlinked_fd()");
> > >
> > > - initial_rsvd = read_reserved();
> > > + initial_rsvd = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > verbose_printf("Reserve count before map: %lu\n", initial_rsvd);
> > >
> > > p = mmap(NULL, hpage_size, PROT_READ|PROT_WRITE, MAP_SHARED,
> > > @@ -86,16 +81,18 @@ int main(int argc, char *argv[])
> > > FAIL("mmap(): %s", strerror(errno));
> > > q = p;
> > >
> > > - verbose_printf("Reserve count after map: %lu\n", read_reserved());
> > > + verbose_printf("Reserve count after map: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_RSVD));
> > >
> > > *q = 0;
> > > - verbose_printf("Reserve count after touch: %lu\n", read_reserved());
> > > + verbose_printf("Reserve count after touch: %lu\n",
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_RSVD));
> > >
> > > err = ftruncate(fd, 0);
> > > if (err)
> > > FAIL("ftruncate(): %s", strerror(errno));
> > >
> > > - rsvd = read_reserved();
> > > + rsvd = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > verbose_printf("Reserve count after truncate: %lu\n", rsvd);
> > > if (rsvd != initial_rsvd)
> > > FAIL("Reserved count is not restored after truncate: %lu
> > > instead of %lu",
> > > @@ -113,7 +110,7 @@ int main(int argc, char *argv[])
> > > if (sigbus_count != 1)
> > > FAIL("Didn't SIGBUS after truncate");
> > >
> > > - rsvd = read_reserved();
> > > + rsvd = get_huge_page_counter(hpage_size, HUGEPAGES_RSVD);
> > > verbose_printf("Reserve count after SIGBUS fault: %lu\n", rsvd);
> > > if (rsvd != initial_rsvd)
> > > FAIL("Reserved count is altered by SIGBUS fault: %lu instead of
> > > %lu",
> > > @@ -122,12 +119,12 @@ int main(int argc, char *argv[])
> > > munmap(p, hpage_size);
> > >
> > > verbose_printf("Reserve count after munmap(): %lu\n",
> > > - read_reserved());
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_RSVD));
> > >
> > > close(fd);
> > >
> > > verbose_printf("Reserve count after close(): %lu\n",
> > > - read_reserved());
> > > + get_huge_page_counter(hpage_size, HUGEPAGES_RSVD));
> > >
> > > PASS();
> > > }
> > > diff --git a/tests/truncate_sigbus_versus_oom.c
> > > b/tests/truncate_sigbus_versus_oom.c
> > > index ab7d90c..7aa2fe5 100644
> > > --- a/tests/truncate_sigbus_versus_oom.c
> > > +++ b/tests/truncate_sigbus_versus_oom.c
> > > @@ -58,9 +58,8 @@ int main(int argc, char *argv[])
> > >
> > > test_init(argc, argv);
> > >
> > > - totpages = get_pool_counter(HUGEPAGES_FREE, 0);
> > > -
> > > hpage_size = check_hugepagesize();
> > > + totpages = get_huge_page_counter(hpage_size, HUGEPAGES_TOTAL);
> > >
> > > fd = hugetlbfs_unlinked_fd();
> > > if (fd < 0)
> > > --
> > > 1.6.0.1.451.gc8d31
> > >
> >
> --
> Adam Litke - (agl at us.ibm.com)
> IBM Linux Technology Center
>
--
Mel Gorman
Part-time Phd Student Linux Technology Center
University of Limerick IBM Dublin Software Lab
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
Libhugetlbfs-devel mailing list
Libhugetlbfs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/libhugetlbfs-devel
