diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..b7258f8
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,407 @@
+[Note: newer entries are at the bottom]
+
+The actual patches and their series are in the tarball:  patches.tar.gz
+
+Early prehistory:
+
+- Fix some warnings
+- Add const to global variables and prototypes
+- Document numa_warn
+- Add numa_distance() support to read topology
+- remove internal alias from numa_{warn,error} to allow overwriting
+  again
+- Various bug fixes
+- add -f option to memhog to map file
+- more bugfixes
+- replace forward backward with STREAM test in numademo
+
+0.6.1
+
+- make headers C++ clean
+
+0.6.2 
+
+- use more accurate buffer length for cpumask
+- add --cpubind to test suite
+
+0.6.3
+
+- fix cpumask parser for large number of cpus.
+Note that you need a kernel patch (as of 2.6.7-pre) for that too
+if the cpumask is longer than 99 characters.
+
+0.6.4
+
+- Add Copyright headers
+
+0.6.5
+
+- Reduce unneeded DSO relocations (Arjan van de Ven) 
+- Add -r option to memhog (repeat walk) 
+- some manpage fixes
+- Use syscall numbers from asm/unistd.h if possible
+- Add numa_node_size64 to handle large nodes on 32bit architectures
+- Fix numactl to use it (report from Rajan Ravindran) 
+- Use ln -sf in make install (Rajan Ravindran)
+- Add syscall numbers for ppc/ppc64
+- Add private syscall6 for i386 since the glibc version is broken
+- Remove STUB
+- Change numactl --show to use cpubind instead of nodebind for CPU affinity.
+- Fix make install into examples directory
+- Work around broken sched_set_affinity API. This adds a 32768 CPUs limit.
+- Fix segfault with /sys not mounted.
+- Clean up Makefile
+- Make numactl --show more clever
+
+0.7-pre1
+
+- add test/regress2 and some fixes to test programs
+- Fix DSO relocation patch for global variables
+- Change nodeset sizes back to be binary compatible with SLES9
+- Cosmetic changes to manpages (pointed out by Eric S. Raymond) 
+- Make numa_run_on_node etc. act on current thread only even on NPTL systems
+  (Dinakar Guniguntala)
+- Make numa_no_nodes / numa_all_nodes const (Werner Almesberger) 
+- Fix up the warnings caused by above change
+- Add numa_distance() on systems with ACPI
+- remove some obsolete code
+- add rdtsc for ppc64
+- fix unsigned/unsigned long confusion in cpumasks (Matt Dobson)
+- fix CPU_BYTES and rename CPU_WORDS to CPU_LONGS (Matt Dobson) 
+- Print node distances in numactl
+
+[0.7 skipped]
+
+0.8
+- hardend numactl command line parsing against bad arguments in some cases
+- remove cpumask/nodemask confusion which has become a FAQ:
+  --cpubind deprecated, added --cpunodebind and --physcpubind= options
+  print both in --show, old cpumask kept for compatibility
+- Fix --show problems
+- various fixes for bugs noted by Mike Stroyan (thanks!)
+- install set_mempolicy manpage
+- various smaller fixes
+
+0.9
+- Get rid of bogus distance.o that broke compilation on !x86-64 (sorry)
+- Handle CFLAGS overriding without OPT_CFLAGS (Ian Wienand)
+- Fix up section of get/set_mempolicy (Ian Wienand)
+- When no NUMA available fall back to one global node instead of one node
+per CPU (Samuel Thibault)
+- Don't rely on architecture symbols for dependency generation
+- Use __powerpc__ to detect PPC/PPC64
+- numastat: 
+  * wrap display properly with many nodes
+  * display nodes in forward order
+  * install manpage in `make install'.
+- remove bogus numamemcpy.c
+- numademo: 
+  * allow standalone compile, make streamlib optional
+  * clean up output
+  * change output unit to standard MB/s
+  * compile with more optimization
+  * add random pass to fool any prefetching (slow)
+- make numademo compileable outside source tree
+- use gettimeofday instead of time stamp counters in benchmarks
+- support valgrind in testsuite
+- other minor changes
+
+0.9.1
+- Make automatic selection of lib64 vs lib more robust. Now should work
+even on ppc32 with a lib64 directory. Architecture lists are hardcoded now
+unfortunately.
+
+0.9.2
+- Fix compilation on architectures with gcc 3.3+ but without TLS
+(MIPS, Alpha, Sparc) 
+- Add warning against using of MPOL_F_NODE
+- numa.3 improvements from Michael Kerrisk
+- Support page migration (migratepages, manpages) from Christoph
+Lameter. Requires 2.6.16+ kernels
+
+0.9.3
+- Some more manpage fixes
+- install migratepages manpage in make install
+- Build fix for Debian make from Ian Wienand
+
+0.9.4:
+- Remove syscall manpages. They're in main man-pages now.
+- More migrate fixes from C.Lameter
+
+0.9.5:
+- Fix parsing of cpumap in sysfs from Doug Chapman
+
+0.9.6:
+- Fix make install again
+
+0.9.7
+- Fix cpumap parsing fix to not corrupt memory (Doug Chapman) 
+- Small optimization to cpumap parsing
+- Create target directories for Debian (Ian Wienand)
+
+0.9.8
+- Fix cpumap parsing again (Doug Chapman)
+
+0.9.9 (aka "Will 1.0 ever happen?") 
+- Fix sizing of cpu buffers for affinity syscalls
+- Don't corrupt errno in numa_run_on_node_mask. This fixes
+numactl cpubind issues on some systems.
+- Print cpus belonging to nodes in numactl --hardware
+- Rewrite cpumap parser to be simpler and hopefully finally work
+in all cases
+- add testcases for cpu affinity and topology discovery
+- Add make test target to run regression test easier and fix up
+test/README
+
+Lots of fixes thanks to thorough testing by Noriyuki Taniuchi:
+- Better command line parsing in numactl and fix various documentation bugs
+- Wrong arguments to --prefered don't crash numactl anymore
+- Fix --cpunodebind=all
+- Auto collect short option list in numactl - a couple were missing.
+- Fix documentation of numa_set_localalloc. It doesn't have a flag. 
+- Fix numa_run_on_node(-1)
+- numa_get_run_node_mask(): Fix documentation, don't warn
+
+0.9.10:
+- Fix cpumap parsing bug when NR_CPUS < 32 (dean gaudet)  
+
+0.9.11
+- Fix usage output for --shmid (Noriyuki Taniuchi)
+- Use correct syscall number for migrate_pages() on PPC
+ 
+1.0
+- Add sleep to regression test to work with delayed statistic
+updating in newer kernels (Mel Gorman) 
+- Default to -O2
+
+1.0.1
+- Fix build on powerpc
+
+1.0.2
+- Fix parallel Makefile build (Andreas Herrmann)
+- Fix target command argument parsing for numactl (no -- needed again anymore) 
+- Clarify numa_node_to_cpus() manpage
+
+1.0.3
+
+- Add the migspeed test program to test the speed of migrating pages from
+  one node to another
+- Support for move_pages(2) to numactl, and numa_move_pages() to libnuma
+- Add the move_pages test command to exercise the move_pages(2) system call
+- Add the mbind_mig_pages test command to verify the moving of a task's
+  pages with move_pages(2)
+- Add the migrate_pages test command to test that a task's pages can be
+  moved with move_pages(2)
+- Support numactl +nn syntax for cpuset_relative cpu and node numbers
+- Modify libnuma to use variable-length bit masks (the bitmask structure)
+- Modify numactl, migspeed, memhog, migratepages, numademo and stream_main
+  to use variable-length bit masks
+- Modify the test/ programs to use the libnuma that uses variable size bit masks
+- Version 2 (symbol versioning)
+- Man page changes with the change to variable-length bit masks, move_pages
+  migrate_pages and others
+
+2.0.0
+- Added API version 2 and symbol versioning.  This provides binary
+  compatibility with old codes that use libnuma.
+- Brought the man page in line with the version 2 changes.
+- Provide numacompat1.h and additions to numa.h, which provide source code
+  compatibility to libnuma version 1.  (The application progamming interface
+  changes, but the ABI is preserved through the use of symbol versioning. So
+  the library stays libnuma.so.1)
+- Added variable-length bit masks to libnuma.  These are struct bitmask.
+  This allows libnuma to be independent of ever increasing cpu counts.
+  o Modified the test/ programs to use variable size bit masks.
+  o Modified numactl, migspeed, memhog, migratepages, numademo and stream_main
+    to use variable-length bit masks.
+- Added support for move_pages(2) (sys_move_pages()) to numactl.  Adds
+  numa_move_pages() to libnuma.
+  o Added the mbind_mig_pages test command to verify the moving of a
+    task's pages with move_pages(2).
+  o Added the move_pages test command to exercise the move_pages(2) system call.
+  o Added the migrate_pages test command to test that a task's pages can
+    be moved with move_pages(2).
+  o Added the migspeed test program.  It tests the speed of migrating pages
+    from one node to another.
+- Allow a numactl +nn syntax for cpuset_relative cpu and node numbers.
+- General cleanup of man page.
+- Return nodes allowed by the application's current cpuset context via new
+  API numa_get_mems_allowed().
+- Change numa_alloc_local() to use MPOL_PREFERRED with NULL nodemask to
+  effect local allocation.
+- Man page for numactl: numa_maps man page clarifications and cleanup
+- Minor cleanups of numademo.c
+- Fix numastat sysfs scanning in numactl
+- Reorganize the regress test script.
+- Fix mempolicy regression test for assymetric platforms and memoryless nodes.
+- Fix checkaffinity and checktopology regression tests.
+- Fix the __NR_migrate_pages system call number.
+- Fix the way numactl handles the building of the mask when executing
+  the --physbind option, and the way Cpus_allowed mask is created.
+
+2.0.1
+- Fix bug in dombind (when passed a null)
+- Make 4 fixes from Debian: MIPS support, MIPS hppa fix for syscalls,
+                            make sure -lm for numademo, build a static library 
+- Fix parsing of /proc/self/status for 2.6.25 additions to it
+
+2.0.2
+- Various numademo improvements:
+  * Fix random benchmark to use all specified memory
+  * Rename to random2 to signify it's different
+  * Optimize random benchmark by inlining random number generator fast path.
+  * Clear caches between runs for more stable results
+  * Add new random pointer chaser benchmark
+  * Compile benchmarks with gcc vectorization if available
+  * run numademo in regression test
+- Add numa_exit_on_warn
+- Fix no cpuset fallback in libnuma.c
+- Install symlinks for the manpages of all new functions
+- Make internal libnuma functions static
+- Add copy_bitmask_to_bitmask() to numa.h
+- Some cleanups
+- Fix line reading in proc
+- Add versions.ldscript to libnuma.so dependencies
+- Remove the non-"numa_" functions from numacompat1.h and numa.h
+- Add ia64 clearcache() to numademo
+- Add -t to numademo for regression testing
+- Remove "numa_all_cpus" from numa.h
+- Changed VERSION1_COMPATIBILITY to NUMA_VERSION1_COMPATIBILITY
+- Defined LIBNUMA_API_VERSION 2 in numa.h
+- Fix numaif.h and numaint.h (migrate_pages; from Masatake Yamato)
+- Fixes to numademo (min/max, and array index; from Kent Liu)
+- Fixes to Makefile and permissions; from Berhard Walle
+
+2.0.3-rc1 - rc3
+- Fixes to libnuma.c numa.h numacompat1.h by Daniel Gollub to fix v1 compatiblity
+- Restore nodemask_zero() and nodemask_equal()
+- Drops a warning message about this not being a NUMA system
+- Remove the numa_maps.5 man page (it's in Linux now) (by Bernhard Walle)
+- Fix makefiles in tests (Andi)
+- Fix off-by-ones in test mbind_mig_pages (Andi)
+- Fix test/prefered.c (Andi)
+- Fix to print_node_cpus() (Arnd/Bill Buros)
+- Fixes to read_mask()  (Arnd's on top of cpw's)
+- Fix to makefile (LDFLAGS/LDLIBS/AR/RANLIB) (Mike Frysinger)
+- Fix numactl for noncontiguous nodes (Amit Arora)
+- Fix bitmask memory leaks, numa_alloc_onnode/numa_preferred (Kornilios Kourtis)
+- Add numa_node_of_cpu() to retrieve local node of a cpu (Kornilios Kourtis)
+- Fix parsing of /proc/self/status (Brice Goglin/Lee Shermerhorn)
+- Small reorganization of numa_alloc_local() (L.S.)
+- Fixes of bitmask memory leaks in about eight functions (L.S.)
+- Make library always return allocated masks that user can free (L.S.)
+- Fix to numademo memtest (allocation overhead) (L.S.)
+- Fix to checkaffinity test (possible shell errors) (L.S.)
+- Fix a printf in migspeed.c (Frederik Himpe)
+- Fix test/regress grep of node number (Cliff W.)
+- Change numademo to finish in a timely manner on large machines (Cliff W.)
+- tested on 96p 48nodes
+
+2.0.3-rc1 - rc4
+- Add --dump-nodes option to numactl (Andi)
+
+2.0.3 released in June, 2009
+
+2.0.4-rc3
+- Fix numactl for a machine with sparse cpu ids (Anton Blanchard)
+- Fix makefile to remove move_pages on make clean (Andi)
+- Fix numa_node_to_cpus() (Sharyathi Nagesh)
+- Rename 'thread' to 'task' (L.S.)
+- Remove other trailing spaces (Cliff W.)
+- Man page correction/clarification for numa_node_to_cpus() (Ian Wienand)
+- Man page clarification for numactl (Mike MacCana)
+- Fix numactl --hardware for cpu-less nodes (Thomas Renninger)
+- Fix set_configured_cpus() (Jan Beulich)
+- Fix memory corrupting use of strlen (Jan Beulich)
+- Add a DSO destructor for memory deallocation (Neil Horman)
+
+2.0.4 released in July, 2010
+
+2.0.5 released in July, 2010 (about 2 days after 2.0.4)
+- Fix numactl calls to set_mempolicy, get_mempolicy and mbind
+
+newer:
+- include stat.h in shm.c (Mike Frysinger)
+
+2.0.6-rc1
+- Correct numa_max_node() use of broken numa_num_configured_nodes() (Tim Pepper)
+- Use numa_max_node() not numa_num_configured_nodes() (Tim Pepper)
+- Fix numa_num_configured_nodes() to match man page description (Tim Pepper)
+- Clarify comment for numa_all_nodes_ptr extern (Tim Pepper)
+- numactl --hardware should handle sparse node numbering (Tim Pepper)
+- Maintain compatibility with 2.0.3 numa_num_thread...()'s (Cliff W.)
+2.0.6-rc2
+- numa_num_task_cpus()/..nodes() to return actual counts (Cliff W.)
+2.0.6-rc3
+- Fix numa_get_run_node_mask() to return a cpuset-aware node mask (Cliff W.)
+  (replaced 110112)
+- Add a better warning to numa_node_to_cpus()
+2.0.6-rc4
+- Fix numa_get_mems_allowed() to use MPOL_F_MEMS_ALLOWED (Michael Spiegel)
+
+2.0.6 released Dec, 2010
+
+2.0.7-rc1
+- 110111 Add numa_realloc() (and realloc_test) (Vasileios Karakasis)
+- 110112 Re-fix numa_get_run_node_mask() and fix numa_get_run_node_mask (Cliff)
+- 110112 Fix the numa_get_run_node_mask() man page (cpus vs nodes) (Cliff W.)
+2.0.7-rc2
+- 110112 Fix the cpu and node parsing to be cpuset aware (Cliff W.)
+- 110112 Fix test/checkaffinity to be cpuset aware (Cliff W.)
+- 110302 Fix two typos in numactl.8 (John Bradshaw)
+
+2.0.7 released Apr, 2011
+
+2.0.8-rc1
+- 110818 Checking of sucessful allocations in numademo (Petr Holasek)
+2.0.8-rc2
+- 110823 Fix of numactl (--touch) warnings and man page (Cliff W.)
+2.0.8-rc3
+- 111214 Add "same" nodemask alias to numactl (Andi Kleen)
+- 111214 Add constructors for numa_init/exit (Andi Kleen)
+- 111214 Add use of glibc syscall stub where possible (Andi Kleen)
+- 111214 Fix regress1 to show all the problems before exiting (Andi Kleen)
+- 111214 Add IO affinity support (Andi Kleen)
+- 111214 Clean regression test temp files (Andi Kleen)
+- 111214 Add an option to memhog to disable transparent huge pages (Andi Kleen)
+- 111214 Fix the test suite on systems that force THP, disable them (Andi Kleen)
+2.0.8-rc4
+- 120106 Install man pages migspeed, migratepages and numastat (Petr Holasek)
+- 120106 Warnings in numa_node_to_cpus_v1 to be more verbose (Petr Holasek)
+- 120216 Fix for numademo: msize check for ptrchase test (Petr Holasek)
+2.0.8-rc5
+- 120823 Fix calculation of maxconfiguredcpu (Petr Holasek)
+- 120823 Fix: do not recalculate maxconfiguredcpu (Petr Holasek)
+- 120823 v.1.3 numa_num_possible_cpus symbol is exported (Petr Holasek)
+- 120823 Add all versions of numa_parse_{cpu,node}string() (Petr Holasek)
+- 120823 Add numa_parse_cpustring take a const char* parameter (Petr Holasek)
+- 120823 Fix unused bufferlen variable (Petr Holasek)
+- 120823 Fix warnings when there are holes in numbering of nodes (Petr Holasek)
+2.0.8-rc6
+- 120911 Show distances on machines without a node 0 (Petr Holasek)
+- 121007 Replace perl numastat with a C command (Bill Gray)
+- 121011 Allow an install location PREFIX in the Makefile (Frank Tampe)
+
+2.0.8 released Oct, 2012
+
+2.0.9-rc1
+- 130207 Add a prototype for numa_bitmask_weight (Cliff W.)
+2.0.9-rc2
+- 130725 Fix numastat huge pages bug, version number, man page (Bill Gray)
+- 130726 Disable the regress-io test (Cliff W.)
+- 130730 Fix typos in numactl man page; add short opts to --help (Petr Holasek)
+2.0.9-rc3
+- 130906 numactl: option --all/-a added for policy settings (Petr Holasek)
+- 130906 libnuma: new function numa_run_on_node_mask_all (Petr Holasek)
+
+2.0.9 released Oct, 2013
+
+2.0.10-rc1
+- 131123 numactl: numactl check for NUMA available (Elena Ufimtseva)
+- 140715 numactl: fix numactl --show  and preferrred node (Bill Gray)
+2.0.10-rc2
+- 140722 makefile: remove warning about missing .depend (Filipe Brandenburger)
+- 140820 convert the build procedure to automake (Filipe Brandenburger)
+
+2.0.10 released Oct, 2014
+
diff --git a/DESIGN b/DESIGN
new file mode 100644
index 0000000..fee72c5
--- /dev/null
+++ b/DESIGN
@@ -0,0 +1,2 @@
+
+[ old description removed because it was too out of date ]
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..04d403b
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,61 @@
+Building numactl
+----------------
+
+      $ ./autogen.sh
+      $ ./configure
+      $ make
+      # make install
+
+    Start by configuring the build running the configure script:
+
+      $ ./autogen.sh
+      $ ./configure
+
+    You can pass options to configure to define build options, to pass it
+    compiler paths, compiler flags and to define the installation layout. Run
+    "./configure --help" for more details on how to customize the build.
+
+    Once build is completed, build numactl with:
+
+      $ make
+
+    If you would like to increase verbosity by printing the full build command
+    lines, pass "make" the V=1 parameter:
+
+      $ make V=1
+
+    You can run the tests included with numactl with the following command:
+
+      $ make check
+
+    The results will be saved in test/*.log files and a test-suite.log will be
+    generated with the summary of test passes and failures.
+
+    Install numactl to the system by running the following command as root:
+
+      # make install
+
+    You can also install it to a staging directory, in which case it is not
+    required to be root while running the install steps. Just pass a DESTDIR
+    variable while running "make install" with the path to the staging
+    directory.
+
+      $ make install DESTDIR=/path/to/staging/numactl
+
+Source code maintenance:
+    https://github.com/numactl/numactl/
+
+Using a snapshot from the Git repository
+
+    First, the build system files need to be generated using the ./autogen.sh
+    script, which calls autoreconf with the appropriate options to generate the
+    configure script and the templates for Makefile, config.h, etc.
+
+    Once those files are generated, follow the normal steps to configure and
+    build numactl.
+
+    In order to create a distribution tarball, use "make dist" from a
+    configured build tree. Use "make distcheck" to confirm that rebuilding from
+    the distribution archive works as expected, that building from out-of-tree
+    works, that test cases pass, etc.
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..1ca6eb7
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,851 @@
+Libraries:
+
+Retrieved from: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt
+
+      GNU LESSER GENERAL PUBLIC LICENSE
+           Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+          Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+      GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+          NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+         END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+Commands:
+
+Retrieved from: http://www.gnu.org/licenses/gpl-2.0.txt
+
+        GNU GENERAL PUBLIC LICENSE
+           Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+          Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+        GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+          NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+         END OF TERMS AND CONDITIONS
+
+      How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program 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; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
+
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..03b0ab6
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,161 @@
+
+ACLOCAL_AMFLAGS = -I m4
+CLEANFILES =
+
+AM_CPPFLAGS = -Wall
+
+bin_PROGRAMS = numactl numastat numademo migratepages migspeed memhog
+
+lib_LTLIBRARIES = libnuma.la
+
+include_HEADERS = numa.h numacompat1.h numaif.h
+
+noinst_HEADERS = numaint.h util.h
+
+dist_man_MANS = move_pages.2 numa.3 numactl.8 numastat.8 migratepages.8 migspeed.8
+
+EXTRA_DIST = README.md INSTALL.md
+
+numactl_SOURCES = numactl.c util.c shm.c shm.h
+numactl_LDADD = libnuma.la
+
+numastat_SOURCES = numastat.c
+numastat_CFLAGS = $(AM_CFLAGS) -std=gnu99
+
+numademo_SOURCES = numademo.c stream_lib.c stream_lib.h mt.c mt.h clearcache.c clearcache.h
+numademo_CPPFLAGS = $(AM_CPPFLAGS) -DHAVE_STREAM_LIB -DHAVE_MT -DHAVE_CLEAR_CACHE
+numademo_CFLAGS = -O3 -ffast-math -funroll-loops
+if HAVE_TREE_VECTORIZE
+numademo_CFLAGS += -ftree-vectorize
+endif
+numademo_LDADD = libnuma.la -lm
+
+migratepages_SOURCES = migratepages.c util.c
+migratepages_LDADD = libnuma.la
+
+migspeed_SOURCES = migspeed.c util.c
+migspeed_LDADD = libnuma.la -lrt
+
+memhog_SOURCES = memhog.c util.c
+memhog_LDADD = libnuma.la
+
+libnuma_la_SOURCES = libnuma.c syscall.c distance.c affinity.c affinity.h sysfs.c sysfs.h rtnetlink.c rtnetlink.h versions.ldscript
+libnuma_la_LDFLAGS = -version-info 1:0:0 -Wl,--version-script,$(srcdir)/versions.ldscript -Wl,-init,numa_init -Wl,-fini,numa_fini
+
+check_PROGRAMS = \
+	test/distance \
+	test/ftok \
+	test/mbind_mig_pages \
+	test/migrate_pages \
+	test/move_pages \
+	test/mynode \
+	test/node-parse \
+	test/nodemap \
+	test/pagesize \
+	test/prefered \
+	test/randmap \
+	test/realloc_test \
+	test/tbitmap \
+	test/tshared
+
+EXTRA_DIST += \
+	test/README \
+	test/bind_range \
+	test/checkaffinity \
+	test/checktopology \
+	test/numademo \
+	test/printcpu \
+	test/regress \
+	test/regress2 \
+	test/regress-io \
+	test/runltp \
+	test/shmtest
+
+test_distance_SOURCES = test/distance.c
+test_distance_LDADD = libnuma.la
+
+test_ftok_SOURCES = test/ftok.c
+test_ftok_LDADD = libnuma.la
+
+test_mbind_mig_pages_SOURCES = test/mbind_mig_pages.c
+test_mbind_mig_pages_LDADD = libnuma.la
+
+test_migrate_pages_SOURCES = test/migrate_pages.c
+test_migrate_pages_LDADD = libnuma.la
+
+test_move_pages_SOURCES = test/move_pages.c
+test_move_pages_LDADD = libnuma.la
+
+test_mynode_SOURCES = test/mynode.c
+test_mynode_LDADD = libnuma.la
+
+test_node_parse_SOURCES = test/node-parse.c util.c
+test_node_parse_LDADD = libnuma.la
+
+test_nodemap_SOURCES = test/nodemap.c
+test_nodemap_LDADD = libnuma.la
+
+test_pagesize_SOURCES = test/pagesize.c
+test_pagesize_LDADD = libnuma.la
+
+test_prefered_SOURCES = test/prefered.c
+test_prefered_LDADD = libnuma.la
+
+test_randmap_SOURCES = test/randmap.c
+test_randmap_LDADD = libnuma.la
+
+test_realloc_test_SOURCES = test/realloc_test.c
+test_realloc_test_LDADD = libnuma.la
+
+test_tbitmap_SOURCES = test/tbitmap.c util.c
+test_tbitmap_LDADD = libnuma.la
+
+test_tshared_SOURCES = test/tshared.c
+test_tshared_LDADD = libnuma.la
+
+# Legacy make rules for test cases.
+# These will be superceded by "make check".
+
+regress1: $(check_PROGRAMS)
+	cd test && ./regress
+
+regress2: $(check_PROGRAMS)
+	cd test && ./regress2
+
+test_numademo: numademo
+	./numademo -t -e 10M
+
+test: all $(check_PROGRAMS) regress1 regress2 test_numademo
+
+TESTS_ENVIRONMENT = builddir='$(builddir)'; export builddir;
+
+TESTS = \
+	test/bind_range \
+	test/checkaffinity \
+	test/checktopology \
+	test/distance \
+	test/nodemap \
+	test/numademo \
+	test/regress \
+	test/tbitmap
+
+# These are known to be broken:
+#	test/prefered
+#	test/randmap
+
+SED_PROCESS = \
+        $(AM_V_GEN)$(SED) \
+        -e 's,@VERSION\@,$(VERSION),g' \
+        -e 's,@prefix\@,$(prefix),g' \
+        -e 's,@exec_prefix\@,$(exec_prefix),g' \
+        -e 's,@libdir\@,$(libdir),g' \
+        -e 's,@includedir\@,$(includedir),g' \
+        < $< > $@ || rm $@
+
+%.pc: %.pc.in Makefile
+	$(SED_PROCESS)
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = numa.pc
+EXTRA_DIST += numa.pc.in
+CLEANFILES += numa.pc
diff --git a/README b/README
new file mode 100644
index 0000000..6d77543
--- /dev/null
+++ b/README
@@ -0,0 +1,44 @@
+
+Simple NUMA policy support. It consists of a numactl program to run
+other programs with a specific NUMA policy and a libnuma shared library 
+("NUMA API") to set NUMA policy in applications.
+
+The libnuma binary interface is supposed to stay binary compatible. 
+Incompatible changes will use new symbol version numbers.
+
+In addition there are various test and utility programs, like
+numastat to display NUMA allocation statistics and memhog.
+
+In test there is a small regression test suite.
+Note that regress assumes a unloaded machine with memory free on each
+node. Otherwise you will get spurious failures in the non strict
+policies (prefered, interleave) 
+
+See the manpages numactl.8 and numa.3 for details.
+
+Source code maintenance:
+  https://github.com/numactl/numactl/
+
+Copyright:
+
+numactl and the demo programs are under the GNU General Public License, v.2
+libnuma is under the GNU Lesser General Public License, v2.1.
+
+The manpages are under the same license as the Linux manpages (see the files)
+
+numademo links with a library derived from the C version of STREAM
+by John D. McCalpin and Joe R. Zagar for one sub benchmark. See stream_lib.c 
+for the license. In particular when you publish numademo output
+you might need to pay attention there or filter out the STREAM results.
+
+It also uses a public domain Mersenne Twister implementation from
+Michael Brundage.
+
+Version 2.0.10-rc2: (C)2014 SGI
+
+Author:
+Andi Kleen, SUSE Labs
+
+Version 2.0.0 by Cliff Wickman, Christoph Lameter and Lee Schermerhorn
+cpw@sgi.com clameter@sgi.com lee.schermerhorn@hp.com
+
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..1af588d
--- /dev/null
+++ b/TODO
@@ -0,0 +1,23 @@
+last update Aug 16 2007:
+
+need to fix hugetlbfs to allow holey files (for numactl)
+numademo numbers seem to be unstable. investigate.
+need more test programs
+
+Replace unreliable counters in numamon with supported ones.
+According to Alex Tomas:
+seems ht bus utilization can be found by 
+(cmd+data+bufrelease / cmd+data+bufrelease+nop)
+according to chm in codeanalyst. 
+quote from .chm:
+Buses 0,1, 2 ?The number of Dwords transmitted (or unused, in the case
++of Nops) on the outgoing side of the HyperTransport links. The sum of all
++four sub-events (all four unit mask bits set) directly reflects the
++transmission rate of the link. Calculate link utilization by dividing the
++combined Command, Data, and Buffer Release count (unit mask 07h) by that
++value plus the Nop count (unit mask 08h). Bandwi
+dth in terms of bytes per unit-time for any one component, or
++combination of components, is calculated by multiplying the count by four and
++dividing by elapsed time.
+and
+0xE9 is also documented
diff --git a/affinity.c b/affinity.c
new file mode 100644
index 0000000..6f69a9b
--- /dev/null
+++ b/affinity.c
@@ -0,0 +1,347 @@
+/* Support for specifying IO affinity by various means.
+   Copyright 2010 Intel Corporation
+   Author: Andi Kleen
+
+   libnuma 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; version
+   2.1.
+
+   libnuma 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 find a copy of v2.1 of the GNU Lesser General Public License
+   somewhere on your Linux system; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+/* Notebook:
+   - Separate real errors from no NUMA with fallback
+   - Infiniband
+   - FCoE?
+   - Support for other special IO devices
+   - Specifying cpu subsets inside the IO node?
+   - Handle multiple IO nodes (needs kernel changes)
+   - Better support for multi-path IO?
+ */
+#define _GNU_SOURCE 1
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <dirent.h>
+#include <linux/rtnetlink.h>
+#include <linux/netlink.h>
+#include <sys/types.h>
+#include <sys/sysmacros.h>
+#include <ctype.h>
+#include <assert.h>
+#include <regex.h>
+#include <sys/sysmacros.h>
+#include "numa.h"
+#include "numaint.h"
+#include "sysfs.h"
+#include "affinity.h"
+#include "rtnetlink.h"
+
+static int badchar(const char *s)
+{
+	if (strpbrk(s, "/."))
+		return 1;
+	return 0;
+}
+
+static int node_parse_failure(int ret, char *cls, const char *dev)
+{
+	if (!cls)
+		cls = "";
+	if (ret == -2)
+		numa_warn(W_node_parse1,
+			  "Kernel does not know node mask for%s%s device `%s'",
+				*cls ? " " : "", cls, dev);
+	else
+		numa_warn(W_node_parse2,
+			  "Cannot read node mask for %s device `%s'",
+			  cls, dev);
+	return -1;
+}
+
+/* Generic sysfs class lookup */
+static int
+affinity_class(struct bitmask *mask, char *cls, const char *dev)
+{
+	int ret;
+	while (isspace(*dev))
+		dev++;
+	if (badchar(dev)) {
+		numa_warn(W_badchar, "Illegal characters in `%s' specification",
+			  dev);
+		return -1;
+	}
+
+	/* Somewhat hackish: extract device from symlink path.
+	   Better would be a direct backlink. This knows slightly too
+	   much about the actual sysfs layout. */
+	char path[1024];
+	char *fn = NULL;
+	if (asprintf(&fn, "/sys/class/%s/%s", cls, dev) > 0 &&
+	    readlink(fn, path, sizeof path) > 0) {
+		regex_t re;
+		regmatch_t match[2];
+		char *p;
+
+		regcomp(&re, "(/devices/pci[0-9a-fA-F:/]+\\.[0-9]+)/",
+			REG_EXTENDED);
+		ret = regexec(&re, path, 2, match, 0);
+		regfree(&re);
+		if (ret == 0) {
+			free(fn);
+			assert(match[0].rm_so > 0);
+			assert(match[0].rm_eo > 0);
+			path[match[1].rm_eo + 1] = 0;
+			p = path + match[0].rm_so;
+			ret = sysfs_node_read(mask, "/sys/%s/numa_node", p);
+			if (ret < 0)
+				return node_parse_failure(ret, NULL, p);
+			return ret;
+		}
+	}
+	free(fn);
+
+	ret = sysfs_node_read(mask, "/sys/class/%s/%s/device/numa_node",
+			      cls, dev);
+	if (ret < 0)
+		return node_parse_failure(ret, cls, dev);
+	return 0;
+}
+
+/* Turn file (or device node) into class name */
+static int affinity_file(struct bitmask *mask, char *cls, const char *file)
+{
+	struct stat st;
+	DIR *dir;
+	int n;
+	unsigned maj = 0, min = 0;
+	dev_t d;
+	struct dirent *dep;
+
+	cls = "block";
+	char fn[sizeof("/sys/class/") + strlen(cls)];
+	if (stat(file, &st) < 0) {
+		numa_warn(W_blockdev1, "Cannot stat file %s", file);
+		return -1;
+	}
+	d = st.st_dev;
+	if (S_ISCHR(st.st_mode)) {
+		/* Better choice than misc? Most likely misc will not work
+		   anyways unless the kernel is fixed. */
+		cls = "misc";
+		d = st.st_rdev;
+	} else if (S_ISBLK(st.st_mode))
+		d = st.st_rdev;
+
+	sprintf(fn, "/sys/class/%s", cls);
+	dir = opendir(fn);
+	if (!dir) {
+		numa_warn(W_blockdev2, "Cannot enumerate %s devices in sysfs",
+			  cls);
+		return -1;
+	}
+	while ((dep = readdir(dir)) != NULL) {
+		char *name = dep->d_name;
+		int ret;
+
+		if (*name == '.')
+			continue;
+		char *dev;
+		char fn2[sizeof("/sys/class/block//dev") + strlen(name)];
+
+		n = -1;
+		if (sprintf(fn2, "/sys/class/block/%s/dev", name) < 0)
+			break;
+		dev = sysfs_read(fn2);
+		if (dev) {
+			n = sscanf(dev, "%u:%u", &maj, &min);
+			free(dev);
+		}
+		if (n != 2) {
+			numa_warn(W_blockdev3, "Cannot parse sysfs device %s",
+				  name);
+			continue;
+		}
+
+		if (major(d) != maj || minor(d) != min)
+			continue;
+
+		ret = affinity_class(mask, "block", name);
+		closedir(dir);
+		return ret;
+	}
+	closedir(dir);
+	numa_warn(W_blockdev5, "Cannot find block device %x:%x in sysfs for `%s'",
+		  maj, min, file);
+	return -1;
+}
+
+/* Look up interface of route using rtnetlink. */
+static int find_route(struct sockaddr *dst, int *iifp)
+{
+	struct rtattr *rta;
+	const int hdrlen = NLMSG_LENGTH(sizeof(struct rtmsg));
+	struct {
+		struct nlmsghdr msg;
+		struct rtmsg rt;
+		char buf[256];
+	} req = {
+		.msg = {
+			.nlmsg_len = hdrlen,
+			.nlmsg_type = RTM_GETROUTE,
+			.nlmsg_flags = NLM_F_REQUEST,
+		},
+		.rt = {
+			.rtm_family = dst->sa_family,
+		},
+	};
+	struct sockaddr_nl adr = {
+		.nl_family = AF_NETLINK,
+	};
+
+	if (rta_put_address(&req.msg, RTA_DST, dst) < 0) {
+		numa_warn(W_netlink1, "Cannot handle network family %x",
+			  dst->sa_family);
+		return -1;
+	}
+
+	if (rtnetlink_request(&req.msg, sizeof req, &adr) < 0) {
+		numa_warn(W_netlink2, "Cannot request rtnetlink route: %s",
+			  strerror(errno));
+		return -1;
+	}
+
+	/* Fish the interface out of the netlink soup. */
+	rta = NULL;
+	while ((rta = rta_get(&req.msg, rta, hdrlen)) != NULL) {
+		if (rta->rta_type == RTA_OIF) {
+			memcpy(iifp, RTA_DATA(rta), sizeof(int));
+			return 0;
+		}
+	}
+
+	numa_warn(W_netlink3, "rtnetlink query did not return interface");
+	return -1;
+}
+
+static int iif_to_name(int iif, struct ifreq *ifr)
+{
+	int n;
+	int sk = socket(PF_INET, SOCK_DGRAM, 0);
+	if (sk < 0)
+		return -1;
+	ifr->ifr_ifindex = iif;
+	n = ioctl(sk, SIOCGIFNAME, ifr);
+	close(sk);
+	return n;
+}
+
+/* Resolve an IP address to the nodes of a network device.
+   This generally only attempts to handle simple cases:
+   no multi-path, no bounding etc. In these cases only
+   the first interface or none is chosen. */
+static int affinity_ip(struct bitmask *mask, char *cls, const char *id)
+{
+	struct addrinfo *ai;
+	int n;
+	int iif;
+	struct ifreq ifr;
+
+	if ((n = getaddrinfo(id, NULL, NULL, &ai)) != 0) {
+		numa_warn(W_net1, "Cannot resolve %s: %s",
+			  id, gai_strerror(n));
+		return -1;
+	}
+
+	if (find_route(&ai->ai_addr[0], &iif) < 0)
+		goto out_ai;
+
+	if (iif_to_name(iif, &ifr) < 0) {
+		numa_warn(W_net2, "Cannot resolve network interface %d", iif);
+		goto out_ai;
+	}
+
+	freeaddrinfo(ai);
+	return affinity_class(mask, "net", ifr.ifr_name);
+
+out_ai:
+	freeaddrinfo(ai);
+	return -1;
+}
+
+/* Look up affinity for a PCI device */
+static int affinity_pci(struct bitmask *mask, char *cls, const char *id)
+{
+	unsigned seg, bus, dev, func;
+	int n, ret;
+
+	/* Func is optional. */
+	if ((n = sscanf(id, "%x:%x:%x.%x",&seg,&bus,&dev,&func)) == 4 || n == 3) {
+		if (n == 3)
+			func = 0;
+	}
+	/* Segment is optional too */
+	else if ((n = sscanf(id, "%x:%x.%x",&bus,&dev,&func)) == 3 || n == 2) {
+		seg = 0;
+		if (n == 2)
+			func = 0;
+	} else {
+		numa_warn(W_pci1, "Cannot parse PCI device `%s'", id);
+		return -1;
+	}
+	ret = sysfs_node_read(mask,
+			"/sys/devices/pci%04x:%02x/%04x:%02x:%02x.%x/numa_node",
+			      seg, bus, seg, bus, dev, func);
+	if (ret < 0)
+		return node_parse_failure(ret, cls, id);
+	return 0;
+}
+
+static struct handler {
+	char first;
+	char *name;
+	char *cls;
+	int (*handler)(struct bitmask *mask, char *cls, const char *desc);
+} handlers[] = {
+	{ 'n', "netdev:", "net",   affinity_class },
+	{ 'i', "ip:",     NULL,    affinity_ip    },
+	{ 'f', "file:",   NULL,    affinity_file  },
+	{ 'b', "block:",  "block", affinity_class },
+	{ 'p', "pci:",    NULL,	   affinity_pci   },
+	{}
+};
+
+hidden int resolve_affinity(const char *id, struct bitmask *mask)
+{
+	struct handler *h;
+
+	for (h = &handlers[0]; h->first; h++) {
+		int len;
+		if (id[0] != h->first)
+			continue;
+		len = strlen(h->name);
+		if (!strncmp(id, h->name, len)) {
+			int ret = h->handler(mask, h->cls, id + len);
+			if (ret == -2) {
+				numa_warn(W_nonode, "Kernel does not know node for %s\n",
+					  id + len);
+			}
+			return ret;
+		}
+	}
+	return NO_IO_AFFINITY;
+}
diff --git a/affinity.h b/affinity.h
new file mode 100644
index 0000000..6fbd364
--- /dev/null
+++ b/affinity.h
@@ -0,0 +1,5 @@
+enum {
+	NO_IO_AFFINITY = -2
+};
+
+int resolve_affinity(const char *id, struct bitmask *mask);
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 0000000..a36375b
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -e
+
+autoreconf --install --symlink
diff --git a/clearcache.c b/clearcache.c
new file mode 100644
index 0000000..82469c1
--- /dev/null
+++ b/clearcache.c
@@ -0,0 +1,77 @@
+/* Clear the CPU cache for benchmark purposes. Pretty simple minded.
+ * Might not work in some complex cache topologies.
+ * When you switch CPUs it's a good idea to clear the cache after testing
+ * too.
+ */
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "clearcache.h"
+
+unsigned cache_size(void)
+{
+	unsigned cs = 0;
+#ifdef _SC_LEVEL1_DCACHE_SIZE
+	cs += sysconf(_SC_LEVEL1_DCACHE_SIZE);
+#endif
+#ifdef _SC_LEVEL2_DCACHE_SIZE
+	cs += sysconf(_SC_LEVEL2_DCACHE_SIZE);
+#endif
+#ifdef _SC_LEVEL3_DCACHE_SIZE
+	cs += sysconf(_SC_LEVEL3_DCACHE_SIZE);
+#endif
+#ifdef _SC_LEVEL4_DCACHE_SIZE
+	cs += sysconf(_SC_LEVEL4_DCACHE_SIZE);
+#endif
+	if (cs == 0) {
+		static int warned;
+		if (!warned) {
+			printf("Cannot determine CPU cache size\n");
+			warned = 1;
+		}
+		cs = 64*1024*1024;
+	}
+	cs *= 2; /* safety factor */
+
+	return cs;
+}
+
+void fallback_clearcache(void)
+{
+	static unsigned char *clearmem;
+	unsigned cs = cache_size();
+	unsigned i;
+
+	if (!clearmem)
+		clearmem = malloc(cs);
+	if (!clearmem) {
+		printf("Warning: cannot allocate %u bytes of clear cache buffer\n", cs);
+		return;
+	}
+	for (i = 0; i < cs; i += 32)
+		clearmem[i] = 1;
+}
+
+void clearcache(unsigned char *mem, unsigned size)
+{
+#if defined(__i386__) || defined(__x86_64__)
+	unsigned i, cl, eax, feat;
+	/* get clflush unit and feature */
+	asm("cpuid" : "=a" (eax), "=b" (cl), "=d" (feat) : "0" (1) : "cx");
+	if (!(feat & (1 << 19)))
+		fallback_clearcache();
+	cl = ((cl >> 8) & 0xff) * 8;
+	for (i = 0; i < size; i += cl)
+		asm("clflush %0" :: "m" (mem[i]));
+#elif defined(__ia64__)
+        unsigned long cl, endcl;
+        // flush probable 128 byte cache lines (but possibly 64 bytes)
+        cl = (unsigned long)mem;
+        endcl = (unsigned long)(mem + (size-1));
+        for (; cl <= endcl; cl += 64)
+                asm ("fc %0" :: "r"(cl) : "memory" );
+#else
+#warning "Consider adding a clearcache implementation for your architecture"
+	fallback_clearcache();
+#endif
+}
diff --git a/clearcache.h b/clearcache.h
new file mode 100644
index 0000000..258b576
--- /dev/null
+++ b/clearcache.h
@@ -0,0 +1 @@
+void clearcache(unsigned char *mem, unsigned size);
diff --git a/config.h b/config.h
new file mode 100644
index 0000000..f42d6b1
--- /dev/null
+++ b/config.h
@@ -0,0 +1,66 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "numactl"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "numactl"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "numactl 2.0.10"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "numactl"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "2.0.10"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* If the compiler supports a TLS storage class define it to that here */
+#define TLS __thread
+
+/* Version number of package */
+#define VERSION "2.0.10"
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..572b53d
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,27 @@
+AC_PREREQ([2.64])
+AC_INIT([numactl], [2.0.12])
+
+AC_CONFIG_SRCDIR([numactl.c])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_HEADERS([config.h])
+
+AM_INIT_AUTOMAKE([foreign 1.11 silent-rules subdir-objects parallel-tests])
+AM_SILENT_RULES([yes])
+
+LT_PREREQ([2.2])
+LT_INIT
+
+AC_PROG_CC
+
+# Override CFLAGS so that we can specify custom CFLAGS for numademo.
+AX_AM_OVERRIDE_VAR([CFLAGS])
+
+AX_TLS
+
+AX_CHECK_COMPILE_FLAG([-ftree-vectorize], [tree_vectorize="true"])
+AM_CONDITIONAL([HAVE_TREE_VECTORIZE], [test x"${tree_vectorize}" = x"true"])
+
+AC_CONFIG_FILES([Makefile])
+
+AC_OUTPUT
diff --git a/distance.c b/distance.c
new file mode 100644
index 0000000..8d472af
--- /dev/null
+++ b/distance.c
@@ -0,0 +1,120 @@
+/* Discover distances
+   Copyright (C) 2005 Andi Kleen, SuSE Labs.
+
+   libnuma 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; version
+   2.1.
+
+   libnuma 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 find a copy of v2.1 of the GNU Lesser General Public License
+   somewhere on your Linux system; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+   All calls are undefined when numa_available returns an error. */
+#define _GNU_SOURCE 1
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "numa.h"
+#include "numaint.h"
+
+static int distance_numnodes;
+static int *distance_table;
+
+static void parse_numbers(char *s, int *iptr)
+{
+	int i, d, j;
+	char *end;
+	int maxnode = numa_max_node();
+	int numnodes = 0;
+
+	for (i = 0; i <= maxnode; i++)
+		if (numa_bitmask_isbitset(numa_nodes_ptr, i))
+			numnodes++;
+
+	for (i = 0, j = 0; i <= maxnode; i++, j++) {
+		d = strtoul(s, &end, 0);
+		/* Skip unavailable nodes */
+		while (j<=maxnode && !numa_bitmask_isbitset(numa_nodes_ptr, j))
+			j++;
+		if (s == end)
+			break;
+		*(iptr+j) = d;
+		s = end;
+	}
+}
+
+static int read_distance_table(void)
+{
+	int nd, len;
+	char *line = NULL;
+	size_t linelen = 0;
+	int maxnode = numa_max_node() + 1;
+	int *table = NULL;
+	int err = -1;
+
+	for (nd = 0;; nd++) {
+		char fn[100];
+		FILE *dfh;
+		sprintf(fn, "/sys/devices/system/node/node%d/distance", nd);
+		dfh = fopen(fn, "r");
+		if (!dfh) {
+			if (errno == ENOENT)
+				err = 0;
+			if (!err && nd<maxnode)
+				continue;
+			else
+				break;
+		}
+		len = getdelim(&line, &linelen, '\n', dfh);
+		fclose(dfh);
+		if (len <= 0)
+			break;
+
+		if (!table) {
+			table = calloc(maxnode * maxnode, sizeof(int));
+			if (!table) {
+				errno = ENOMEM;
+				break;
+			}
+		}
+
+		parse_numbers(line, table + nd * maxnode);
+	}
+	free(line);
+	if (err)  {
+		numa_warn(W_distance,
+			  "Cannot parse distance information in sysfs: %s",
+			  strerror(errno));
+		free(table);
+		return err;
+	}
+	/* Update the global table pointer.  Race window here with
+	   other threads, but in the worst case we leak one distance
+	   array one time, which is tolerable. This avoids a
+	   dependency on pthreads. */
+	if (distance_table) {
+		free(table);
+		return 0;
+	}
+	distance_numnodes = maxnode;
+	distance_table = table;
+	return 0;
+}
+
+int numa_distance(int a, int b)
+{
+	if (!distance_table) {
+		int err = read_distance_table();
+		if (err < 0)
+			return 0;
+	}
+	if ((unsigned)a >= distance_numnodes || (unsigned)b >= distance_numnodes)
+		return 0;
+	return distance_table[a * distance_numnodes + b];
+}
diff --git a/libnuma.c b/libnuma.c
new file mode 100755
index 0000000..700b30c
--- /dev/null
+++ b/libnuma.c
@@ -0,0 +1,2047 @@
+/* Simple NUMA library.
+   Copyright (C) 2003,2004,2005,2008 Andi Kleen,SuSE Labs and
+   Cliff Wickman,SGI.
+
+   libnuma 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; version
+   2.1.
+
+   libnuma 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 find a copy of v2.1 of the GNU Lesser General Public License
+   somewhere on your Linux system; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+   All calls are undefined when numa_available returns an error. */
+#define _GNU_SOURCE 1
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sched.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+#include <sys/mman.h>
+#include <limits.h>
+
+#ifdef MEMORY_SANITIZER
+#include <sanitizer/msan_interface.h>
+#endif
+
+#include "config.h"
+#include "numa.h"
+#include "numaif.h"
+#include "numaint.h"
+#include "util.h"
+#include "affinity.h"
+
+#define WEAK __attribute__((weak))
+
+#define CPU_BUFFER_SIZE 4096     /* This limits you to 32768 CPUs */
+
+/* these are the old (version 1) masks */
+nodemask_t numa_no_nodes;
+nodemask_t numa_all_nodes;
+/* these are now the default bitmask (pointers to) (version 2) */
+struct bitmask *numa_no_nodes_ptr = NULL;
+struct bitmask *numa_all_nodes_ptr = NULL;
+struct bitmask *numa_possible_nodes_ptr = NULL;
+struct bitmask *numa_all_cpus_ptr = NULL;
+struct bitmask *numa_possible_cpus_ptr = NULL;
+/* I would prefer to use symbol versioning to create v1 and v2 versions
+   of numa_no_nodes and numa_all_nodes, but the loader does not correctly
+   handle versioning of BSS versus small data items */
+
+struct bitmask *numa_nodes_ptr = NULL;
+static struct bitmask *numa_memnode_ptr = NULL;
+static unsigned long *node_cpu_mask_v1[NUMA_NUM_NODES];
+static struct bitmask **node_cpu_mask_v2;
+
+WEAK void numa_error(const char *where);
+
+#ifndef TLS
+#warning "not threadsafe"
+#define __thread
+#endif
+
+static __thread int bind_policy = MPOL_BIND;
+static __thread unsigned int mbind_flags = 0;
+static int sizes_set=0;
+static int maxconfigurednode = -1;
+static int maxconfiguredcpu = -1;
+static int numprocnode = -1;
+static int numproccpu = -1;
+static int nodemask_sz = 0;
+static int cpumask_sz = 0;
+
+int numa_exit_on_error = 0;
+int numa_exit_on_warn = 0;
+static void set_sizes(void);
+
+/*
+ * There are two special functions, _init(void) and _fini(void), which
+ * are called automatically by the dynamic loader whenever a library is loaded.
+ *
+ * The v1 library depends upon nodemask_t's of all nodes and no nodes.
+ */
+void __attribute__((constructor))
+numa_init(void)
+{
+	int max,i;
+
+	if (sizes_set)
+		return;
+
+	set_sizes();
+	/* numa_all_nodes should represent existing nodes on this system */
+        max = numa_num_configured_nodes();
+        for (i = 0; i < max; i++)
+                nodemask_set_compat((nodemask_t *)&numa_all_nodes, i);
+	memset(&numa_no_nodes, 0, sizeof(numa_no_nodes));
+}
+
+#define FREE_AND_ZERO(x) if (x) {	\
+		numa_bitmask_free(x);	\
+		x = NULL;		\
+	}
+
+void __attribute__((destructor))
+numa_fini(void)
+{
+	FREE_AND_ZERO(numa_all_cpus_ptr);
+	FREE_AND_ZERO(numa_possible_cpus_ptr);
+	FREE_AND_ZERO(numa_all_nodes_ptr);
+	FREE_AND_ZERO(numa_possible_nodes_ptr);
+	FREE_AND_ZERO(numa_no_nodes_ptr);
+	FREE_AND_ZERO(numa_memnode_ptr);
+	FREE_AND_ZERO(numa_nodes_ptr);
+}
+
+/*
+ * The following bitmask declarations, bitmask_*() routines, and associated
+ * _setbit() and _getbit() routines are:
+ * Copyright (c) 2004_2007 Silicon Graphics, Inc. (SGI) All rights reserved.
+ * SGI publishes it under the terms of the GNU General Public License, v2,
+ * as published by the Free Software Foundation.
+ */
+static unsigned int
+_getbit(const struct bitmask *bmp, unsigned int n)
+{
+	if (n < bmp->size)
+		return (bmp->maskp[n/bitsperlong] >> (n % bitsperlong)) & 1;
+	else
+		return 0;
+}
+
+static void
+_setbit(struct bitmask *bmp, unsigned int n, unsigned int v)
+{
+	if (n < bmp->size) {
+		if (v)
+			bmp->maskp[n/bitsperlong] |= 1UL << (n % bitsperlong);
+		else
+			bmp->maskp[n/bitsperlong] &= ~(1UL << (n % bitsperlong));
+	}
+}
+
+int
+numa_bitmask_isbitset(const struct bitmask *bmp, unsigned int i)
+{
+	return _getbit(bmp, i);
+}
+
+struct bitmask *
+numa_bitmask_setall(struct bitmask *bmp)
+{
+	unsigned int i;
+	for (i = 0; i < bmp->size; i++)
+		_setbit(bmp, i, 1);
+	return bmp;
+}
+
+struct bitmask *
+numa_bitmask_clearall(struct bitmask *bmp)
+{
+	unsigned int i;
+	for (i = 0; i < bmp->size; i++)
+		_setbit(bmp, i, 0);
+	return bmp;
+}
+
+struct bitmask *
+numa_bitmask_setbit(struct bitmask *bmp, unsigned int i)
+{
+	_setbit(bmp, i, 1);
+	return bmp;
+}
+
+struct bitmask *
+numa_bitmask_clearbit(struct bitmask *bmp, unsigned int i)
+{
+	_setbit(bmp, i, 0);
+	return bmp;
+}
+
+unsigned int
+numa_bitmask_nbytes(struct bitmask *bmp)
+{
+	return longsperbits(bmp->size) * sizeof(unsigned long);
+}
+
+/* where n is the number of bits in the map */
+/* This function should not exit on failure, but right now we cannot really
+   recover from this. */
+struct bitmask *
+numa_bitmask_alloc(unsigned int n)
+{
+	struct bitmask *bmp;
+
+	if (n < 1) {
+		errno = EINVAL;
+		numa_error("request to allocate mask for invalid number");
+		exit(1);
+	}
+	bmp = malloc(sizeof(*bmp));
+	if (bmp == 0)
+		goto oom;
+	bmp->size = n;
+	bmp->maskp = calloc(longsperbits(n), sizeof(unsigned long));
+	if (bmp->maskp == 0) {
+		free(bmp);
+		goto oom;
+	}
+	return bmp;
+
+oom:
+	numa_error("Out of memory allocating bitmask");
+	exit(1);
+}
+
+void
+numa_bitmask_free(struct bitmask *bmp)
+{
+	if (bmp == 0)
+		return;
+	free(bmp->maskp);
+	bmp->maskp = (unsigned long *)0xdeadcdef;  /* double free tripwire */
+	free(bmp);
+	return;
+}
+
+/* True if two bitmasks are equal */
+int
+numa_bitmask_equal(const struct bitmask *bmp1, const struct bitmask *bmp2)
+{
+	unsigned int i;
+	for (i = 0; i < bmp1->size || i < bmp2->size; i++)
+		if (_getbit(bmp1, i) != _getbit(bmp2, i))
+			return 0;
+	return 1;
+}
+
+/* Hamming Weight: number of set bits */
+unsigned int numa_bitmask_weight(const struct bitmask *bmp)
+{
+	unsigned int i;
+	unsigned int w = 0;
+	for (i = 0; i < bmp->size; i++)
+		if (_getbit(bmp, i))
+			w++;
+	return w;
+}
+
+/* *****end of bitmask_  routines ************ */
+
+/* Next two can be overwritten by the application for different error handling */
+WEAK void numa_error(const char *where)
+{
+	int olde = errno;
+	perror(where);
+	if (numa_exit_on_error)
+		exit(1);
+	errno = olde;
+}
+
+WEAK void numa_warn(int num, const char *fmt, ...)
+{
+	static unsigned warned;
+	va_list ap;
+	int olde = errno;
+
+	/* Give each warning only once */
+	if ((1<<num) & warned)
+		return;
+	warned |= (1<<num);
+
+	va_start(ap,fmt);
+	fprintf(stderr, "libnuma: Warning: ");
+	vfprintf(stderr, fmt, ap);
+	fputc('\n', stderr);
+	va_end(ap);
+
+	errno = olde;
+}
+
+static void setpol(int policy, struct bitmask *bmp)
+{
+	if (set_mempolicy(policy, bmp->maskp, bmp->size + 1) < 0)
+		numa_error("set_mempolicy");
+}
+
+static void getpol(int *oldpolicy, struct bitmask *bmp)
+{
+	if (get_mempolicy(oldpolicy, bmp->maskp, bmp->size + 1, 0, 0) < 0)
+		numa_error("get_mempolicy");
+}
+
+static void dombind(void *mem, size_t size, int pol, struct bitmask *bmp)
+{
+	if (mbind(mem, size, pol, bmp ? bmp->maskp : NULL, bmp ? bmp->size + 1 : 0,
+		  mbind_flags) < 0)
+		numa_error("mbind");
+}
+
+/* (undocumented) */
+/* gives the wrong answer for hugetlbfs mappings. */
+int numa_pagesize(void)
+{
+	static int pagesize;
+	if (pagesize > 0)
+		return pagesize;
+	pagesize = getpagesize();
+	return pagesize;
+}
+
+make_internal_alias(numa_pagesize);
+
+/*
+ * Find nodes (numa_nodes_ptr), nodes with memory (numa_memnode_ptr)
+ * and the highest numbered existing node (maxconfigurednode).
+ */
+static void
+set_configured_nodes(void)
+{
+	DIR *d;
+	struct dirent *de;
+	long long freep;
+
+	numa_memnode_ptr = numa_allocate_nodemask();
+	numa_nodes_ptr = numa_allocate_nodemask();
+
+	d = opendir("/sys/devices/system/node");
+	if (!d) {
+		maxconfigurednode = 0;
+	} else {
+		while ((de = readdir(d)) != NULL) {
+			int nd;
+			if (strncmp(de->d_name, "node", 4))
+				continue;
+			nd = strtoul(de->d_name+4, NULL, 0);
+			numa_bitmask_setbit(numa_nodes_ptr, nd);
+			if (numa_node_size64(nd, &freep) > 0)
+				numa_bitmask_setbit(numa_memnode_ptr, nd);
+			if (maxconfigurednode < nd)
+				maxconfigurednode = nd;
+		}
+		closedir(d);
+	}
+}
+
+/*
+ * Convert the string length of an ascii hex mask to the number
+ * of bits represented by that mask.
+ */
+static int s2nbits(const char *s)
+{
+	return strlen(s) * 32 / 9;
+}
+
+/* Is string 'pre' a prefix of string 's'? */
+static int strprefix(const char *s, const char *pre)
+{
+	return strncmp(s, pre, strlen(pre)) == 0;
+}
+
+static const char *mask_size_file = "/proc/self/status";
+static const char *nodemask_prefix = "Mems_allowed:\t";
+/*
+ * (do this the way Paul Jackson's libcpuset does it)
+ * The nodemask values in /proc/self/status are in an
+ * ascii format that uses 9 characters for each 32 bits of mask.
+ * (this could also be used to find the cpumask size)
+ */
+static void
+set_nodemask_size(void)
+{
+	FILE *fp;
+	char *buf = NULL;
+	size_t bufsize = 0;
+
+	if ((fp = fopen(mask_size_file, "r")) == NULL)
+		goto done;
+
+	while (getline(&buf, &bufsize, fp) > 0) {
+#ifdef MEMORY_SANITIZER
+    __msan_unpoison_string(buf);
+#endif
+		if (strprefix(buf, nodemask_prefix)) {
+			nodemask_sz = s2nbits(buf + strlen(nodemask_prefix));
+			break;
+		}
+	}
+	free(buf);
+	fclose(fp);
+done:
+	if (nodemask_sz == 0) {/* fall back on error */
+		int pol;
+		unsigned long *mask = NULL;
+		nodemask_sz = 16;
+		do {
+			nodemask_sz <<= 1;
+			mask = realloc(mask, nodemask_sz / 8);
+			if (!mask)
+				return;
+		} while (get_mempolicy(&pol, mask, nodemask_sz + 1, 0, 0) < 0 && errno == EINVAL &&
+				nodemask_sz < 4096*8);
+		free(mask);
+	}
+}
+
+/*
+ * Read a mask consisting of a sequence of hexadecimal longs separated by
+ * commas. Order them correctly and return the number of bits set.
+ */
+static int
+read_mask(char *s, struct bitmask *bmp)
+{
+	char *end = s;
+	int tmplen = (bmp->size + bitsperint - 1) / bitsperint;
+	unsigned int tmp[tmplen];
+	unsigned int *start = tmp;
+	unsigned int i, n = 0, m = 0;
+
+	if (!s)
+		return 0;	/* shouldn't happen */
+
+	i = strtoul(s, &end, 16);
+
+	/* Skip leading zeros */
+	while (!i && *end++ == ',') {
+		i = strtoul(end, &end, 16);
+	}
+
+	if (!i)
+		/* End of string. No mask */
+		return -1;
+
+	start[n++] = i;
+	/* Read sequence of ints */
+	while (*end++ == ',') {
+		i = strtoul(end, &end, 16);
+		start[n++] = i;
+
+		/* buffer overflow */
+		if (n > tmplen)
+			return -1;
+	}
+
+	/*
+	 * Invert sequence of ints if necessary since the first int
+	 * is the highest and we put it first because we read it first.
+	 */
+	while (n) {
+		int w;
+		unsigned long x = 0;
+		/* read into long values in an endian-safe way */
+		for (w = 0; n && w < bitsperlong; w += bitsperint)
+			x |= ((unsigned long)start[n-- - 1] << w);
+
+		bmp->maskp[m++] = x;
+	}
+	/*
+	 * Return the number of bits set
+	 */
+	return numa_bitmask_weight(bmp);
+}
+
+/*
+ * Read a processes constraints in terms of nodes and cpus from
+ * /proc/self/status.
+ */
+static void
+set_task_constraints(void)
+{
+	int hicpu = maxconfiguredcpu;
+	int i;
+	char *buffer = NULL;
+	size_t buflen = 0;
+	FILE *f;
+
+	numa_all_cpus_ptr = numa_allocate_cpumask();
+	numa_possible_cpus_ptr = numa_allocate_cpumask();
+	numa_all_nodes_ptr = numa_allocate_nodemask();
+	numa_possible_nodes_ptr = numa_allocate_cpumask();
+	numa_no_nodes_ptr = numa_allocate_nodemask();
+
+	f = fopen(mask_size_file, "r");
+	if (!f) {
+		//numa_warn(W_cpumap, "Cannot parse %s", mask_size_file);
+		return;
+	}
+
+	while (getline(&buffer, &buflen, f) > 0) {
+#ifdef MEMORY_SANITIZER
+    __msan_unpoison_string(buffer);
+#endif
+		/* mask starts after [last] tab */
+		char  *mask = strrchr(buffer,'\t') + 1;
+
+		if (strncmp(buffer,"Cpus_allowed:",13) == 0)
+			numproccpu = read_mask(mask, numa_all_cpus_ptr);
+
+		if (strncmp(buffer,"Mems_allowed:",13) == 0) {
+			numprocnode = read_mask(mask, numa_all_nodes_ptr);
+		}
+	}
+	fclose(f);
+	free(buffer);
+
+	for (i = 0; i <= hicpu; i++)
+		numa_bitmask_setbit(numa_possible_cpus_ptr, i);
+	for (i = 0; i <= maxconfigurednode; i++)
+		numa_bitmask_setbit(numa_possible_nodes_ptr, i);
+
+	/*
+	 * Cpus_allowed in the kernel can be defined to all f's
+	 * i.e. it may be a superset of the actual available processors.
+	 * As such let's reduce numproccpu to the number of actual
+	 * available cpus.
+	 */
+	if (numproccpu <= 0) {
+		for (i = 0; i <= hicpu; i++)
+			numa_bitmask_setbit(numa_all_cpus_ptr, i);
+		numproccpu = hicpu+1;
+	}
+
+	if (numproccpu > hicpu+1) {
+		numproccpu = hicpu+1;
+		for (i=hicpu+1; i<numa_all_cpus_ptr->size; i++) {
+			numa_bitmask_clearbit(numa_all_cpus_ptr, i);
+		}
+	}
+
+	if (numprocnode <= 0) {
+		for (i = 0; i <= maxconfigurednode; i++)
+			numa_bitmask_setbit(numa_all_nodes_ptr, i);
+		numprocnode = maxconfigurednode + 1;
+	}
+
+	return;
+}
+
+/*
+ * Find the highest cpu number possible (in other words the size
+ * of a kernel cpumask_t (in bits) - 1)
+ */
+static void
+set_numa_max_cpu(void)
+{
+	int len = 4096;
+	int n;
+	int olde = errno;
+	struct bitmask *buffer;
+
+	do {
+		buffer = numa_bitmask_alloc(len);
+		n = numa_sched_getaffinity_v2_int(0, buffer);
+		/* on success, returns size of kernel cpumask_t, in bytes */
+		if (n < 0) {
+			if (errno == EINVAL) {
+				if (len >= 1024*1024)
+					break;
+				len *= 2;
+				numa_bitmask_free(buffer);
+				continue;
+			} else {
+				numa_warn(W_numcpus, "Unable to determine max cpu"
+					  " (sched_getaffinity: %s); guessing...",
+					  strerror(errno));
+				n = sizeof(cpu_set_t);
+				break;
+			}
+		}
+	} while (n < 0);
+	numa_bitmask_free(buffer);
+	errno = olde;
+	cpumask_sz = n*8;
+}
+
+/*
+ * get the total (configured) number of cpus - both online and offline
+ */
+static void
+set_configured_cpus(void)
+{
+	maxconfiguredcpu = sysconf(_SC_NPROCESSORS_CONF) - 1;
+	if (maxconfiguredcpu == -1)
+		numa_error("sysconf(NPROCESSORS_CONF) failed");
+}
+
+/*
+ * Initialize all the sizes.
+ */
+static void
+set_sizes(void)
+{
+	sizes_set++;
+	set_nodemask_size();	/* size of kernel nodemask_t */
+	set_configured_nodes();	/* configured nodes listed in /sys */
+	set_numa_max_cpu();	/* size of kernel cpumask_t */
+	set_configured_cpus();	/* cpus listed in /sys/devices/system/cpu */
+	set_task_constraints(); /* cpus and nodes for current task */
+}
+
+int
+numa_num_configured_nodes(void)
+{
+	/*
+	* NOTE: this function's behavior matches the documentation (ie: it
+	* returns a count of nodes with memory) despite the poor function
+	* naming.  We also cannot use the similarly poorly named
+	* numa_all_nodes_ptr as it only tracks nodes with memory from which
+	* the calling process can allocate.  Think sparse nodes, memory-less
+	* nodes, cpusets...
+	*/
+	int memnodecount=0, i;
+
+	for (i=0; i <= maxconfigurednode; i++) {
+		if (numa_bitmask_isbitset(numa_memnode_ptr, i))
+			memnodecount++;
+	}
+	return memnodecount;
+}
+
+int
+numa_num_configured_cpus(void)
+{
+
+	return maxconfiguredcpu+1;
+}
+
+int
+numa_num_possible_nodes(void)
+{
+	return nodemask_sz;
+}
+
+int
+numa_num_possible_cpus(void)
+{
+	return cpumask_sz;
+}
+
+int
+numa_num_task_nodes(void)
+{
+	return numprocnode;
+}
+
+/*
+ * for backward compatibility
+ */
+int
+numa_num_thread_nodes(void)
+{
+	return numa_num_task_nodes();
+}
+
+int
+numa_num_task_cpus(void)
+{
+	return numproccpu;
+}
+
+/*
+ * for backward compatibility
+ */
+int
+numa_num_thread_cpus(void)
+{
+	return numa_num_task_cpus();
+}
+
+/*
+ * Return the number of the highest node in this running system,
+ */
+int
+numa_max_node(void)
+{
+	return maxconfigurednode;
+}
+
+make_internal_alias(numa_max_node);
+
+/*
+ * Return the number of the highest possible node in a system,
+ * which for v1 is the size of a numa.h nodemask_t(in bits)-1.
+ * but for v2 is the size of a kernel nodemask_t(in bits)-1.
+ */
+int
+numa_max_possible_node_v1(void)
+{
+	return ((sizeof(nodemask_t)*8)-1);
+}
+backward_symver(numa_max_possible_node_v1,numa_max_possible_node);
+
+int
+numa_max_possible_node_v2(void)
+{
+	return numa_num_possible_nodes()-1;
+}
+symver(numa_max_possible_node_v2,numa_max_possible_node);
+
+make_internal_alias(numa_max_possible_node_v1);
+make_internal_alias(numa_max_possible_node_v2);
+
+/*
+ * Allocate a bitmask for cpus, of a size large enough to
+ * match the kernel's cpumask_t.
+ */
+struct bitmask *
+numa_allocate_cpumask()
+{
+	int ncpus = numa_num_possible_cpus();
+
+	return numa_bitmask_alloc(ncpus);
+}
+
+/*
+ * Allocate a bitmask the size of a libnuma nodemask_t
+ */
+static struct bitmask *
+allocate_nodemask_v1(void)
+{
+	int nnodes = numa_max_possible_node_v1_int()+1;
+
+	return numa_bitmask_alloc(nnodes);
+}
+
+/*
+ * Allocate a bitmask for nodes, of a size large enough to
+ * match the kernel's nodemask_t.
+ */
+struct bitmask *
+numa_allocate_nodemask(void)
+{
+	struct bitmask *bmp;
+	int nnodes = numa_max_possible_node_v2_int() + 1;
+
+	bmp = numa_bitmask_alloc(nnodes);
+	return bmp;
+}
+
+/* (cache the result?) */
+long long numa_node_size64(int node, long long *freep)
+{
+	size_t len = 0;
+	char *line = NULL;
+	long long size = -1;
+	FILE *f;
+	char fn[64];
+	int ok = 0;
+	int required = freep ? 2 : 1;
+
+	if (freep)
+		*freep = -1;
+	sprintf(fn,"/sys/devices/system/node/node%d/meminfo", node);
+	f = fopen(fn, "r");
+	if (!f)
+		return -1;
+	while (getdelim(&line, &len, '\n', f) > 0) {
+		char *end;
+		char *s = strcasestr(line, "kB");
+		if (!s)
+			continue;
+		--s;
+		while (s > line && isspace(*s))
+			--s;
+		while (s > line && isdigit(*s))
+			--s;
+		if (strstr(line, "MemTotal")) {
+			size = strtoull(s,&end,0) << 10;
+			if (end == s)
+				size = -1;
+			else
+				ok++;
+		}
+		if (freep && strstr(line, "MemFree")) {
+			*freep = strtoull(s,&end,0) << 10;
+			if (end == s)
+				*freep = -1;
+			else
+				ok++;
+		}
+	}
+	fclose(f);
+	free(line);
+	if (ok != required)
+		numa_warn(W_badmeminfo, "Cannot parse sysfs meminfo (%d)", ok);
+	return size;
+}
+
+make_internal_alias(numa_node_size64);
+
+long numa_node_size(int node, long *freep)
+{
+	long long f2;
+	long sz = numa_node_size64_int(node, &f2);
+	if (freep)
+		*freep = f2;
+	return sz;
+}
+
+int numa_available(void)
+{
+	if (get_mempolicy(NULL, NULL, 0, 0, 0) < 0 && errno == ENOSYS)
+		return -1;
+	return 0;
+}
+
+void
+numa_interleave_memory_v1(void *mem, size_t size, const nodemask_t *mask)
+{
+	struct bitmask bitmask;
+
+	bitmask.size = sizeof(nodemask_t) * 8;
+	bitmask.maskp = (unsigned long *)mask;
+	dombind(mem, size, MPOL_INTERLEAVE, &bitmask);
+}
+backward_symver(numa_interleave_memory_v1,numa_interleave_memory);
+
+void
+numa_interleave_memory_v2(void *mem, size_t size, struct bitmask *bmp)
+{
+	dombind(mem, size, MPOL_INTERLEAVE, bmp);
+}
+symver(numa_interleave_memory_v2,numa_interleave_memory);
+
+void numa_tonode_memory(void *mem, size_t size, int node)
+{
+	struct bitmask *nodes;
+
+	nodes = numa_allocate_nodemask();
+	numa_bitmask_setbit(nodes, node);
+	dombind(mem, size, bind_policy, nodes);
+	numa_bitmask_free(nodes);
+}
+
+void
+numa_tonodemask_memory_v1(void *mem, size_t size, const nodemask_t *mask)
+{
+	struct bitmask bitmask;
+
+	bitmask.maskp = (unsigned long *)mask;
+	bitmask.size  = sizeof(nodemask_t);
+	dombind(mem, size,  bind_policy, &bitmask);
+}
+backward_symver(numa_tonodemask_memory_v1,numa_tonodemask_memory);
+
+void
+numa_tonodemask_memory_v2(void *mem, size_t size, struct bitmask *bmp)
+{
+	dombind(mem, size,  bind_policy, bmp);
+}
+symver(numa_tonodemask_memory_v2,numa_tonodemask_memory);
+
+void numa_setlocal_memory(void *mem, size_t size)
+{
+	dombind(mem, size, MPOL_PREFERRED, NULL);
+}
+
+void numa_police_memory(void *mem, size_t size)
+{
+	int pagesize = numa_pagesize_int();
+	unsigned long i;
+	for (i = 0; i < size; i += pagesize)
+        ((volatile char*)mem)[i] = ((volatile char*)mem)[i];
+}
+
+make_internal_alias(numa_police_memory);
+
+void *numa_alloc(size_t size)
+{
+	char *mem;
+	mem = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,
+		   0, 0);
+	if (mem == (char *)-1)
+		return NULL;
+	numa_police_memory_int(mem, size);
+	return mem;
+}
+
+void *numa_realloc(void *old_addr, size_t old_size, size_t new_size)
+{
+	char *mem;
+	mem = mremap(old_addr, old_size, new_size, MREMAP_MAYMOVE);
+	if (mem == (char *)-1)
+		return NULL;
+	/*
+	 *	The memory policy of the allocated pages is preserved by mremap(), so
+	 *	there is no need to (re)set it here. If the policy of the original
+	 *	allocation is not set, the new pages will be allocated according to the
+	 *	process' mempolicy. Trying to allocate explicitly the new pages on the
+	 *	same node as the original ones would require changing the policy of the
+	 *	newly allocated pages, which violates the numa_realloc() semantics.
+	 */
+	return mem;
+}
+
+void *numa_alloc_interleaved_subset_v1(size_t size, const nodemask_t *mask)
+{
+	char *mem;
+	struct bitmask bitmask;
+
+	mem = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,
+			0, 0);
+	if (mem == (char *)-1)
+		return NULL;
+	bitmask.maskp = (unsigned long *)mask;
+	bitmask.size  = sizeof(nodemask_t);
+	dombind(mem, size, MPOL_INTERLEAVE, &bitmask);
+	return mem;
+}
+backward_symver(numa_alloc_interleaved_subset_v1,numa_alloc_interleaved_subset);
+
+void *numa_alloc_interleaved_subset_v2(size_t size, struct bitmask *bmp)
+{
+	char *mem;
+
+	mem = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,
+		   0, 0);
+	if (mem == (char *)-1)
+		return NULL;
+	dombind(mem, size, MPOL_INTERLEAVE, bmp);
+	return mem;
+}
+symver(numa_alloc_interleaved_subset_v2,numa_alloc_interleaved_subset);
+
+make_internal_alias(numa_alloc_interleaved_subset_v1);
+make_internal_alias(numa_alloc_interleaved_subset_v2);
+
+void *
+numa_alloc_interleaved(size_t size)
+{
+	return numa_alloc_interleaved_subset_v2_int(size, numa_all_nodes_ptr);
+}
+
+/*
+ * given a user node mask, set memory policy to use those nodes
+ */
+void
+numa_set_interleave_mask_v1(nodemask_t *mask)
+{
+	struct bitmask *bmp;
+	int nnodes = numa_max_possible_node_v1_int()+1;
+
+	bmp = numa_bitmask_alloc(nnodes);
+	copy_nodemask_to_bitmask(mask, bmp);
+	if (numa_bitmask_equal(bmp, numa_no_nodes_ptr))
+		setpol(MPOL_DEFAULT, bmp);
+	else
+		setpol(MPOL_INTERLEAVE, bmp);
+	numa_bitmask_free(bmp);
+}
+
+backward_symver(numa_set_interleave_mask_v1,numa_set_interleave_mask);
+
+void
+numa_set_interleave_mask_v2(struct bitmask *bmp)
+{
+	if (numa_bitmask_equal(bmp, numa_no_nodes_ptr))
+		setpol(MPOL_DEFAULT, bmp);
+	else
+		setpol(MPOL_INTERLEAVE, bmp);
+}
+symver(numa_set_interleave_mask_v2,numa_set_interleave_mask);
+
+nodemask_t
+numa_get_interleave_mask_v1(void)
+{
+	int oldpolicy = -1;
+	struct bitmask *bmp;
+	nodemask_t mask;
+
+	bmp = allocate_nodemask_v1();
+	getpol(&oldpolicy, bmp);
+	if (oldpolicy == MPOL_INTERLEAVE)
+		copy_bitmask_to_nodemask(bmp, &mask);
+	else
+		copy_bitmask_to_nodemask(numa_no_nodes_ptr, &mask);
+	numa_bitmask_free(bmp);
+	return mask;
+}
+backward_symver(numa_get_interleave_mask_v1,numa_get_interleave_mask);
+
+struct bitmask *
+numa_get_interleave_mask_v2(void)
+{
+	int oldpolicy = -1;
+	struct bitmask *bmp;
+
+	bmp = numa_allocate_nodemask();
+	getpol(&oldpolicy, bmp);
+	if (oldpolicy != MPOL_INTERLEAVE)
+		copy_bitmask_to_bitmask(numa_no_nodes_ptr, bmp);
+	return bmp;
+}
+symver(numa_get_interleave_mask_v2,numa_get_interleave_mask);
+
+/* (undocumented) */
+int numa_get_interleave_node(void)
+{
+	int nd;
+	if (get_mempolicy(&nd, NULL, 0, 0, MPOL_F_NODE) == 0)
+		return nd;
+	return 0;
+}
+
+void *numa_alloc_onnode(size_t size, int node)
+{
+	char *mem;
+	struct bitmask *bmp;
+
+	bmp = numa_allocate_nodemask();
+	numa_bitmask_setbit(bmp, node);
+	mem = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,
+		   0, 0);
+	if (mem == (char *)-1)
+		mem = NULL;
+	else
+		dombind(mem, size, bind_policy, bmp);
+	numa_bitmask_free(bmp);
+	return mem;
+}
+
+void *numa_alloc_local(size_t size)
+{
+	char *mem;
+	mem = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,
+		   0, 0);
+	if (mem == (char *)-1)
+		mem =  NULL;
+	else
+		dombind(mem, size, MPOL_PREFERRED, NULL);
+	return mem;
+}
+
+void numa_set_bind_policy(int strict)
+{
+	if (strict)
+		bind_policy = MPOL_BIND;
+	else
+		bind_policy = MPOL_PREFERRED;
+}
+
+void
+numa_set_membind_v1(const nodemask_t *mask)
+{
+	struct bitmask bitmask;
+
+	bitmask.maskp = (unsigned long *)mask;
+	bitmask.size  = sizeof(nodemask_t);
+	setpol(MPOL_BIND, &bitmask);
+}
+backward_symver(numa_set_membind_v1,numa_set_membind);
+
+void
+numa_set_membind_v2(struct bitmask *bmp)
+{
+	setpol(MPOL_BIND, bmp);
+}
+symver(numa_set_membind_v2,numa_set_membind);
+
+make_internal_alias(numa_set_membind_v2);
+
+/*
+ * copy a bitmask map body to a numa.h nodemask_t structure
+ */
+void
+copy_bitmask_to_nodemask(struct bitmask *bmp, nodemask_t *nmp)
+{
+	int max, i;
+
+	memset(nmp, 0, sizeof(nodemask_t));
+        max = (sizeof(nodemask_t)*8);
+	for (i=0; i<bmp->size; i++) {
+		if (i >= max)
+			break;
+		if (numa_bitmask_isbitset(bmp, i))
+			nodemask_set_compat((nodemask_t *)nmp, i);
+	}
+}
+
+/*
+ * copy a bitmask map body to another bitmask body
+ * fill a larger destination with zeroes
+ */
+void
+copy_bitmask_to_bitmask(struct bitmask *bmpfrom, struct bitmask *bmpto)
+{
+	int bytes;
+
+	if (bmpfrom->size >= bmpto->size) {
+		memcpy(bmpto->maskp, bmpfrom->maskp, CPU_BYTES(bmpto->size));
+	} else if (bmpfrom->size < bmpto->size) {
+		bytes = CPU_BYTES(bmpfrom->size);
+		memcpy(bmpto->maskp, bmpfrom->maskp, bytes);
+		memset(((char *)bmpto->maskp)+bytes, 0,
+					CPU_BYTES(bmpto->size)-bytes);
+	}
+}
+
+/*
+ * copy a numa.h nodemask_t structure to a bitmask map body
+ */
+void
+copy_nodemask_to_bitmask(nodemask_t *nmp, struct bitmask *bmp)
+{
+	int max, i;
+
+	numa_bitmask_clearall(bmp);
+        max = (sizeof(nodemask_t)*8);
+	if (max > bmp->size)
+		max = bmp->size;
+	for (i=0; i<max; i++) {
+		if (nodemask_isset_compat(nmp, i))
+			numa_bitmask_setbit(bmp, i);
+	}
+}
+
+nodemask_t
+numa_get_membind_v1(void)
+{
+	int oldpolicy = -1;
+	struct bitmask *bmp;
+	nodemask_t nmp;
+
+	bmp = allocate_nodemask_v1();
+	getpol(&oldpolicy, bmp);
+	if (oldpolicy == MPOL_BIND) {
+		copy_bitmask_to_nodemask(bmp, &nmp);
+	} else {
+		/* copy the body of the map to numa_all_nodes */
+		copy_bitmask_to_nodemask(bmp, &numa_all_nodes);
+		nmp = numa_all_nodes;
+	}
+	numa_bitmask_free(bmp);
+	return nmp;
+}
+backward_symver(numa_get_membind_v1,numa_get_membind);
+
+struct bitmask *
+numa_get_membind_v2(void)
+{
+	int oldpolicy = -1;
+	struct bitmask *bmp;
+
+	bmp = numa_allocate_nodemask();
+	getpol(&oldpolicy, bmp);
+	if (oldpolicy != MPOL_BIND)
+		copy_bitmask_to_bitmask(numa_all_nodes_ptr, bmp);
+	return bmp;
+}
+symver(numa_get_membind_v2,numa_get_membind);
+
+//TODO:  do we need a v1 nodemask_t version?
+struct bitmask *numa_get_mems_allowed(void)
+{
+	struct bitmask *bmp;
+
+	/*
+	 * can change, so query on each call.
+	 */
+	bmp = numa_allocate_nodemask();
+	if (get_mempolicy(NULL, bmp->maskp, bmp->size + 1, 0,
+				MPOL_F_MEMS_ALLOWED) < 0)
+		numa_error("get_mempolicy");
+	return bmp;
+}
+make_internal_alias(numa_get_mems_allowed);
+
+void numa_free(void *mem, size_t size)
+{
+	munmap(mem, size);
+}
+
+int
+numa_parse_bitmap_v1(char *line, unsigned long *mask, int ncpus)
+{
+	int i;
+	char *p = strchr(line, '\n');
+	if (!p)
+		return -1;
+
+	for (i = 0; p > line;i++) {
+		char *oldp, *endp;
+		oldp = p;
+		if (*p == ',')
+			--p;
+		while (p > line && *p != ',')
+			--p;
+		/* Eat two 32bit fields at a time to get longs */
+		if (p > line && sizeof(unsigned long) == 8) {
+			oldp--;
+			memmove(p, p+1, oldp-p+1);
+			while (p > line && *p != ',')
+				--p;
+		}
+		if (*p == ',')
+			p++;
+		if (i >= CPU_LONGS(ncpus))
+			return -1;
+		mask[i] = strtoul(p, &endp, 16);
+		if (endp != oldp)
+			return -1;
+		p--;
+	}
+	return 0;
+}
+backward_symver(numa_parse_bitmap_v1,numa_parse_bitmap);
+
+int
+numa_parse_bitmap_v2(char *line, struct bitmask *mask)
+{
+	int i, ncpus;
+	char *p = strchr(line, '\n');
+	if (!p)
+		return -1;
+	ncpus = mask->size;
+
+	for (i = 0; p > line;i++) {
+		char *oldp, *endp;
+		oldp = p;
+		if (*p == ',')
+			--p;
+		while (p > line && *p != ',')
+			--p;
+		/* Eat two 32bit fields at a time to get longs */
+		if (p > line && sizeof(unsigned long) == 8) {
+			oldp--;
+			memmove(p, p+1, oldp-p+1);
+			while (p > line && *p != ',')
+				--p;
+		}
+		if (*p == ',')
+			p++;
+		if (i >= CPU_LONGS(ncpus))
+			return -1;
+		mask->maskp[i] = strtoul(p, &endp, 16);
+		if (endp != oldp)
+			return -1;
+		p--;
+	}
+	return 0;
+}
+symver(numa_parse_bitmap_v2,numa_parse_bitmap);
+
+void
+static init_node_cpu_mask_v2(void)
+{
+	int nnodes = numa_max_possible_node_v2_int() + 1;
+	node_cpu_mask_v2 = calloc (nnodes, sizeof(struct bitmask *));
+}
+
+/* This would be better with some locking, but I don't want to make libnuma
+   dependent on pthreads right now. The races are relatively harmless. */
+int
+numa_node_to_cpus_v1(int node, unsigned long *buffer, int bufferlen)
+{
+	int err = 0;
+	char fn[64];
+	FILE *f;
+	char *line = NULL;
+	size_t len = 0;
+	struct bitmask bitmask;
+	int buflen_needed;
+	unsigned long *mask;
+	int ncpus = numa_num_possible_cpus();
+	int maxnode = numa_max_node_int();
+
+	buflen_needed = CPU_BYTES(ncpus);
+	if ((unsigned)node > maxnode || bufferlen < buflen_needed) {
+		errno = ERANGE;
+		return -1;
+	}
+	if (bufferlen > buflen_needed)
+		memset(buffer, 0, bufferlen);
+	if (node_cpu_mask_v1[node]) {
+		memcpy(buffer, node_cpu_mask_v1[node], buflen_needed);
+		return 0;
+	}
+
+	mask = malloc(buflen_needed);
+	if (!mask)
+		mask = (unsigned long *)buffer;
+	memset(mask, 0, buflen_needed);
+
+	sprintf(fn, "/sys/devices/system/node/node%d/cpumap", node);
+	f = fopen(fn, "r");
+	if (!f || getdelim(&line, &len, '\n', f) < 1) {
+		if (numa_bitmask_isbitset(numa_nodes_ptr, node)) {
+			numa_warn(W_nosysfs2,
+			   "/sys not mounted or invalid. Assuming one node: %s",
+				  strerror(errno));
+			numa_warn(W_nosysfs2,
+			   "(cannot open or correctly parse %s)", fn);
+		}
+		bitmask.maskp = (unsigned long *)mask;
+		bitmask.size  = buflen_needed * 8;
+		numa_bitmask_setall(&bitmask);
+		err = -1;
+	}
+	if (f)
+		fclose(f);
+
+	if (line && (numa_parse_bitmap_v1(line, mask, ncpus) < 0)) {
+		numa_warn(W_cpumap, "Cannot parse cpumap. Assuming one node");
+		bitmask.maskp = (unsigned long *)mask;
+		bitmask.size  = buflen_needed * 8;
+		numa_bitmask_setall(&bitmask);
+		err = -1;
+	}
+
+	free(line);
+	memcpy(buffer, mask, buflen_needed);
+
+	/* slightly racy, see above */
+	if (node_cpu_mask_v1[node]) {
+		if (mask != buffer)
+			free(mask);
+	} else {
+		node_cpu_mask_v1[node] = mask;
+	}
+	return err;
+}
+backward_symver(numa_node_to_cpus_v1,numa_node_to_cpus);
+
+/*
+ * test whether a node has cpus
+ */
+/* This would be better with some locking, but I don't want to make libnuma
+   dependent on pthreads right now. The races are relatively harmless. */
+/*
+ * deliver a bitmask of cpus representing the cpus on a given node
+ */
+int
+numa_node_to_cpus_v2(int node, struct bitmask *buffer)
+{
+	int err = 0;
+	int nnodes = numa_max_node();
+	char fn[64], *line = NULL;
+	FILE *f;
+	size_t len = 0;
+	struct bitmask *mask;
+
+	if (!node_cpu_mask_v2)
+		init_node_cpu_mask_v2();
+
+	if (node > nnodes) {
+		errno = ERANGE;
+		return -1;
+	}
+	numa_bitmask_clearall(buffer);
+
+	if (node_cpu_mask_v2[node]) {
+		/* have already constructed a mask for this node */
+		if (buffer->size < node_cpu_mask_v2[node]->size) {
+			errno = EINVAL;
+			numa_error("map size mismatch");
+			return -1;
+		}
+		copy_bitmask_to_bitmask(node_cpu_mask_v2[node], buffer);
+		return 0;
+	}
+
+	/* need a new mask for this node */
+	mask = numa_allocate_cpumask();
+
+	/* this is a kernel cpumask_t (see node_read_cpumap()) */
+	sprintf(fn, "/sys/devices/system/node/node%d/cpumap", node);
+	f = fopen(fn, "r");
+	if (!f || getdelim(&line, &len, '\n', f) < 1) {
+		if (numa_bitmask_isbitset(numa_nodes_ptr, node)) {
+			numa_warn(W_nosysfs2,
+			   "/sys not mounted or invalid. Assuming one node: %s",
+				  strerror(errno));
+			numa_warn(W_nosysfs2,
+			   "(cannot open or correctly parse %s)", fn);
+		}
+		numa_bitmask_setall(mask);
+		err = -1;
+	}
+	if (f)
+		fclose(f);
+
+	if (line && (numa_parse_bitmap_v2(line, mask) < 0)) {
+		numa_warn(W_cpumap, "Cannot parse cpumap. Assuming one node");
+		numa_bitmask_setall(mask);
+		err = -1;
+	}
+
+	free(line);
+	copy_bitmask_to_bitmask(mask, buffer);
+
+	/* slightly racy, see above */
+	/* save the mask we created */
+	if (node_cpu_mask_v2[node]) {
+		/* how could this be? */
+		if (mask != buffer)
+			numa_bitmask_free(mask);
+	} else {
+		/* we don't want to cache faulty result */
+		if (!err)
+			node_cpu_mask_v2[node] = mask;
+		else
+			numa_bitmask_free(mask);
+	}
+	return err;
+}
+symver(numa_node_to_cpus_v2,numa_node_to_cpus);
+
+make_internal_alias(numa_node_to_cpus_v1);
+make_internal_alias(numa_node_to_cpus_v2);
+
+/* report the node of the specified cpu */
+int numa_node_of_cpu(int cpu)
+{
+	struct bitmask *bmp;
+	int ncpus, nnodes, node, ret;
+
+	ncpus = numa_num_possible_cpus();
+	if (cpu > ncpus){
+		errno = EINVAL;
+		return -1;
+	}
+	bmp = numa_bitmask_alloc(ncpus);
+	nnodes = numa_max_node();
+	for (node = 0; node <= nnodes; node++){
+		if (numa_node_to_cpus_v2_int(node, bmp) < 0) {
+			/* It's possible for the node to not exist */
+			continue;
+		}
+		if (numa_bitmask_isbitset(bmp, cpu)){
+			ret = node;
+			goto end;
+		}
+	}
+	ret = -1;
+	errno = EINVAL;
+end:
+	numa_bitmask_free(bmp);
+	return ret;
+}
+
+int
+numa_run_on_node_mask_v1(const nodemask_t *mask)
+{
+	int ncpus = numa_num_possible_cpus();
+	int i, k, err;
+	unsigned long cpus[CPU_LONGS(ncpus)], nodecpus[CPU_LONGS(ncpus)];
+	memset(cpus, 0, CPU_BYTES(ncpus));
+	for (i = 0; i < NUMA_NUM_NODES; i++) {
+		if (mask->n[i / BITS_PER_LONG] == 0)
+			continue;
+		if (nodemask_isset_compat(mask, i)) {
+			if (numa_node_to_cpus_v1_int(i, nodecpus, CPU_BYTES(ncpus)) < 0) {
+				numa_warn(W_noderunmask,
+					  "Cannot read node cpumask from sysfs");
+				continue;
+			}
+			for (k = 0; k < CPU_LONGS(ncpus); k++)
+				cpus[k] |= nodecpus[k];
+		}
+	}
+	err = numa_sched_setaffinity_v1(0, CPU_BYTES(ncpus), cpus);
+
+	/* The sched_setaffinity API is broken because it expects
+	   the user to guess the kernel cpuset size. Do this in a
+	   brute force way. */
+	if (err < 0 && errno == EINVAL) {
+		int savederrno = errno;
+		char *bigbuf;
+		static int size = -1;
+		if (size == -1)
+			size = CPU_BYTES(ncpus) * 2;
+		bigbuf = malloc(CPU_BUFFER_SIZE);
+		if (!bigbuf) {
+			errno = ENOMEM;
+			return -1;
+		}
+		errno = savederrno;
+		while (size <= CPU_BUFFER_SIZE) {
+			memcpy(bigbuf, cpus, CPU_BYTES(ncpus));
+			memset(bigbuf + CPU_BYTES(ncpus), 0,
+			       CPU_BUFFER_SIZE - CPU_BYTES(ncpus));
+			err = numa_sched_setaffinity_v1_int(0, size, (unsigned long *)bigbuf);
+			if (err == 0 || errno != EINVAL)
+				break;
+			size *= 2;
+		}
+		savederrno = errno;
+		free(bigbuf);
+		errno = savederrno;
+	}
+	return err;
+}
+backward_symver(numa_run_on_node_mask_v1,numa_run_on_node_mask);
+
+/*
+ * Given a node mask (size of a kernel nodemask_t) (probably populated by
+ * a user argument list) set up a map of cpus (map "cpus") on those nodes.
+ * Then set affinity to those cpus.
+ */
+int
+numa_run_on_node_mask_v2(struct bitmask *bmp)
+{
+	int ncpus, i, k, err;
+	struct bitmask *cpus, *nodecpus;
+
+	cpus = numa_allocate_cpumask();
+	ncpus = cpus->size;
+	nodecpus = numa_allocate_cpumask();
+
+	for (i = 0; i < bmp->size; i++) {
+		if (bmp->maskp[i / BITS_PER_LONG] == 0)
+			continue;
+		if (numa_bitmask_isbitset(bmp, i)) {
+			/*
+			 * numa_all_nodes_ptr is cpuset aware; use only
+			 * these nodes
+			 */
+			if (!numa_bitmask_isbitset(numa_all_nodes_ptr, i)) {
+				numa_warn(W_noderunmask,
+					"node %d not allowed", i);
+				continue;
+			}
+			if (numa_node_to_cpus_v2_int(i, nodecpus) < 0) {
+				numa_warn(W_noderunmask,
+					"Cannot read node cpumask from sysfs");
+				continue;
+			}
+			for (k = 0; k < CPU_LONGS(ncpus); k++)
+				cpus->maskp[k] |= nodecpus->maskp[k];
+		}
+	}
+	err = numa_sched_setaffinity_v2_int(0, cpus);
+
+	numa_bitmask_free(cpus);
+	numa_bitmask_free(nodecpus);
+
+	/* used to have to consider that this could fail - it shouldn't now */
+	if (err < 0) {
+		numa_error("numa_sched_setaffinity_v2_int() failed; abort\n");
+	}
+
+	return err;
+}
+symver(numa_run_on_node_mask_v2,numa_run_on_node_mask);
+
+make_internal_alias(numa_run_on_node_mask_v2);
+
+/*
+ * Given a node mask (size of a kernel nodemask_t) (probably populated by
+ * a user argument list) set up a map of cpus (map "cpus") on those nodes
+ * without any cpuset awareness. Then set affinity to those cpus.
+ */
+int
+numa_run_on_node_mask_all(struct bitmask *bmp)
+{
+	int ncpus, i, k, err;
+	struct bitmask *cpus, *nodecpus;
+
+	cpus = numa_allocate_cpumask();
+	ncpus = cpus->size;
+	nodecpus = numa_allocate_cpumask();
+
+	for (i = 0; i < bmp->size; i++) {
+		if (bmp->maskp[i / BITS_PER_LONG] == 0)
+			continue;
+		if (numa_bitmask_isbitset(bmp, i)) {
+			if (!numa_bitmask_isbitset(numa_possible_nodes_ptr, i)) {
+				numa_warn(W_noderunmask,
+					"node %d not allowed", i);
+				continue;
+			}
+			if (numa_node_to_cpus_v2_int(i, nodecpus) < 0) {
+				numa_warn(W_noderunmask,
+					"Cannot read node cpumask from sysfs");
+				continue;
+			}
+			for (k = 0; k < CPU_LONGS(ncpus); k++)
+				cpus->maskp[k] |= nodecpus->maskp[k];
+		}
+	}
+	err = numa_sched_setaffinity_v2_int(0, cpus);
+
+	numa_bitmask_free(cpus);
+	numa_bitmask_free(nodecpus);
+
+	/* With possible nodes freedom it can happen easily now */
+	if (err < 0) {
+		numa_error("numa_sched_setaffinity_v2_int() failed");
+	}
+
+	return err;
+}
+
+nodemask_t
+numa_get_run_node_mask_v1(void)
+{
+	int ncpus = numa_num_configured_cpus();
+	int i, k;
+	int max = numa_max_node_int();
+	struct bitmask *bmp, *cpus, *nodecpus;
+	nodemask_t nmp;
+
+	cpus = numa_allocate_cpumask();
+	if (numa_sched_getaffinity_v2_int(0, cpus) < 0){
+		nmp = numa_no_nodes;
+		goto free_cpus;
+	}
+
+	nodecpus = numa_allocate_cpumask();
+	bmp = allocate_nodemask_v1(); /* the size of a nodemask_t */
+	for (i = 0; i <= max; i++) {
+		if (numa_node_to_cpus_v2_int(i, nodecpus) < 0) {
+			/* It's possible for the node to not exist */
+			continue;
+		}
+		for (k = 0; k < CPU_LONGS(ncpus); k++) {
+			if (nodecpus->maskp[k] & cpus->maskp[k])
+				numa_bitmask_setbit(bmp, i);
+		}
+	}
+	copy_bitmask_to_nodemask(bmp, &nmp);
+	numa_bitmask_free(bmp);
+	numa_bitmask_free(nodecpus);
+free_cpus:
+	numa_bitmask_free(cpus);
+	return nmp;
+}
+backward_symver(numa_get_run_node_mask_v1,numa_get_run_node_mask);
+
+struct bitmask *
+numa_get_run_node_mask_v2(void)
+{
+	int i, k;
+	int ncpus = numa_num_configured_cpus();
+	int max = numa_max_node_int();
+	struct bitmask *bmp, *cpus, *nodecpus;
+
+	bmp = numa_allocate_cpumask();
+	cpus = numa_allocate_cpumask();
+	if (numa_sched_getaffinity_v2_int(0, cpus) < 0){
+		copy_bitmask_to_bitmask(numa_no_nodes_ptr, bmp);
+		goto free_cpus;
+	}
+
+	nodecpus = numa_allocate_cpumask();
+	for (i = 0; i <= max; i++) {
+		/*
+		 * numa_all_nodes_ptr is cpuset aware; show only
+		 * these nodes
+		 */
+		if (!numa_bitmask_isbitset(numa_all_nodes_ptr, i)) {
+			continue;
+		}
+		if (numa_node_to_cpus_v2_int(i, nodecpus) < 0) {
+			/* It's possible for the node to not exist */
+			continue;
+		}
+		for (k = 0; k < CPU_LONGS(ncpus); k++) {
+			if (nodecpus->maskp[k] & cpus->maskp[k])
+				numa_bitmask_setbit(bmp, i);
+		}
+	}
+	numa_bitmask_free(nodecpus);
+free_cpus:
+	numa_bitmask_free(cpus);
+	return bmp;
+}
+symver(numa_get_run_node_mask_v2,numa_get_run_node_mask);
+
+int
+numa_migrate_pages(int pid, struct bitmask *fromnodes, struct bitmask *tonodes)
+{
+	int numa_num_nodes = numa_num_possible_nodes();
+
+	return migrate_pages(pid, numa_num_nodes + 1, fromnodes->maskp,
+							tonodes->maskp);
+}
+
+int numa_move_pages(int pid, unsigned long count,
+	void **pages, const int *nodes, int *status, int flags)
+{
+	return move_pages(pid, count, pages, nodes, status, flags);
+}
+
+int numa_run_on_node(int node)
+{
+	int numa_num_nodes = numa_num_possible_nodes();
+	int ret = -1;
+	struct bitmask *cpus;
+
+	if (node >= numa_num_nodes){
+		errno = EINVAL;
+		goto out;
+	}
+
+	cpus = numa_allocate_cpumask();
+
+	if (node == -1)
+		numa_bitmask_setall(cpus);
+	else if (numa_node_to_cpus_v2_int(node, cpus) < 0){
+		numa_warn(W_noderunmask, "Cannot read node cpumask from sysfs");
+		goto free;
+	}
+
+	ret = numa_sched_setaffinity_v2_int(0, cpus);
+free:
+	numa_bitmask_free(cpus);
+out:
+	return ret;
+}
+
+int numa_preferred(void)
+{
+	int policy;
+	int ret;
+	struct bitmask *bmp;
+
+	bmp = numa_allocate_nodemask();
+	getpol(&policy, bmp);
+	if (policy == MPOL_PREFERRED || policy == MPOL_BIND) {
+		int i;
+		int max = numa_num_possible_nodes();
+		for (i = 0; i < max ; i++)
+			if (numa_bitmask_isbitset(bmp, i)){
+				ret = i;
+				goto end;
+			}
+	}
+	/* could read the current CPU from /proc/self/status. Probably
+	   not worth it. */
+	ret = 0; /* or random one? */
+end:
+	numa_bitmask_free(bmp);
+	return ret;
+}
+
+void numa_set_preferred(int node)
+{
+	struct bitmask *bmp;
+
+	bmp = numa_allocate_nodemask();
+	if (node >= 0) {
+		numa_bitmask_setbit(bmp, node);
+		setpol(MPOL_PREFERRED, bmp);
+	} else
+		setpol(MPOL_DEFAULT, bmp);
+	numa_bitmask_free(bmp);
+}
+
+void numa_set_localalloc(void)
+{
+	setpol(MPOL_DEFAULT, numa_no_nodes_ptr);
+}
+
+void numa_bind_v1(const nodemask_t *nodemask)
+{
+	struct bitmask bitmask;
+
+	bitmask.maskp = (unsigned long *)nodemask;
+	bitmask.size  = sizeof(nodemask_t);
+	numa_run_on_node_mask_v2_int(&bitmask);
+	numa_set_membind_v2_int(&bitmask);
+}
+backward_symver(numa_bind_v1,numa_bind);
+
+void numa_bind_v2(struct bitmask *bmp)
+{
+	numa_run_on_node_mask_v2_int(bmp);
+	numa_set_membind_v2_int(bmp);
+}
+symver(numa_bind_v2,numa_bind);
+
+void numa_set_strict(int flag)
+{
+	if (flag)
+		mbind_flags |= MPOL_MF_STRICT;
+	else
+		mbind_flags &= ~MPOL_MF_STRICT;
+}
+
+/*
+ * Extract a node or processor number from the given string.
+ * Allow a relative node / processor specification within the allowed
+ * set if "relative" is nonzero
+ */
+static unsigned long get_nr(const char *s, char **end, struct bitmask *bmp, int relative)
+{
+	long i, nr;
+
+	if (!relative)
+		return strtoul(s, end, 0);
+
+	nr = strtoul(s, end, 0);
+	if (s == *end)
+		return nr;
+	/* Find the nth set bit */
+	for (i = 0; nr >= 0 && i <= bmp->size; i++)
+		if (numa_bitmask_isbitset(bmp, i))
+			nr--;
+	return i-1;
+}
+
+/*
+ * __numa_parse_nodestring() is called to create a node mask, given
+ * an ascii string such as 25 or 12-15 or 1,3,5-7 or +6-10.
+ * (the + indicates that the numbers are nodeset-relative)
+ *
+ * The nodes may be specified as absolute, or relative to the current nodeset.
+ * The list of available nodes is in a map pointed to by "allowed_nodes_ptr",
+ * which may represent all nodes or the nodes in the current nodeset.
+ *
+ * The caller must free the returned bitmask.
+ */
+static struct bitmask *
+__numa_parse_nodestring(const char *s, struct bitmask *allowed_nodes_ptr)
+{
+	int invert = 0, relative = 0;
+	int conf_nodes = numa_num_configured_nodes();
+	char *end;
+	struct bitmask *mask;
+
+	mask = numa_allocate_nodemask();
+
+	if (s[0] == 0){
+		copy_bitmask_to_bitmask(numa_no_nodes_ptr, mask);
+		return mask; /* return freeable mask */
+	}
+	if (*s == '!') {
+		invert = 1;
+		s++;
+	}
+	if (*s == '+') {
+		relative++;
+		s++;
+	}
+	do {
+		unsigned long arg;
+		int i;
+		if (isalpha(*s)) {
+			int n;
+			if (!strcmp(s,"all")) {
+				copy_bitmask_to_bitmask(allowed_nodes_ptr,
+							mask);
+				s+=4;
+				break;
+			}
+			n = resolve_affinity(s, mask);
+			if (n != NO_IO_AFFINITY) {
+				if (n < 0)
+					goto err;
+				s += strlen(s) + 1;
+				break;
+			}
+		}
+		arg = get_nr(s, &end, allowed_nodes_ptr, relative);
+		if (end == s) {
+			numa_warn(W_nodeparse, "unparseable node description `%s'\n", s);
+			goto err;
+		}
+		if (!numa_bitmask_isbitset(allowed_nodes_ptr, arg)) {
+			numa_warn(W_nodeparse, "node argument %d is out of range\n", arg);
+			goto err;
+		}
+		i = arg;
+		numa_bitmask_setbit(mask, i);
+		s = end;
+		if (*s == '-') {
+			char *end2;
+			unsigned long arg2;
+			arg2 = get_nr(++s, &end2, allowed_nodes_ptr, relative);
+			if (end2 == s) {
+				numa_warn(W_nodeparse, "missing node argument %s\n", s);
+				goto err;
+			}
+			if (!numa_bitmask_isbitset(allowed_nodes_ptr, arg2)) {
+				numa_warn(W_nodeparse, "node argument %d out of range\n", arg2);
+				goto err;
+			}
+			while (arg <= arg2) {
+				i = arg;
+				if (numa_bitmask_isbitset(allowed_nodes_ptr,i))
+					numa_bitmask_setbit(mask, i);
+				arg++;
+			}
+			s = end2;
+		}
+	} while (*s++ == ',');
+	if (s[-1] != '\0')
+		goto err;
+	if (invert) {
+		int i;
+		for (i = 0; i < conf_nodes; i++) {
+			if (numa_bitmask_isbitset(mask, i))
+				numa_bitmask_clearbit(mask, i);
+			else
+				numa_bitmask_setbit(mask, i);
+		}
+	}
+	return mask;
+
+err:
+	numa_bitmask_free(mask);
+	return NULL;
+}
+
+/*
+ * numa_parse_nodestring() is called to create a bitmask from nodes available
+ * for this task.
+ */
+
+struct bitmask * numa_parse_nodestring(const char *s)
+{
+	return __numa_parse_nodestring(s, numa_all_nodes_ptr);
+}
+
+/*
+ * numa_parse_nodestring_all() is called to create a bitmask from all nodes
+ * available.
+ */
+
+struct bitmask * numa_parse_nodestring_all(const char *s)
+{
+	return __numa_parse_nodestring(s, numa_possible_nodes_ptr);
+}
+
+/*
+ * __numa_parse_cpustring() is called to create a bitmask, given
+ * an ascii string such as 25 or 12-15 or 1,3,5-7 or +6-10.
+ * (the + indicates that the numbers are cpuset-relative)
+ *
+ * The cpus may be specified as absolute, or relative to the current cpuset.
+ * The list of available cpus for this task is in the map pointed to by
+ * "allowed_cpus_ptr", which may represent all cpus or the cpus in the
+ * current cpuset.
+ *
+ * The caller must free the returned bitmask.
+ */
+static struct bitmask *
+__numa_parse_cpustring(const char *s, struct bitmask *allowed_cpus_ptr)
+{
+	int invert = 0, relative=0;
+	int conf_cpus = numa_num_configured_cpus();
+	char *end;
+	struct bitmask *mask;
+
+	mask = numa_allocate_cpumask();
+
+	if (s[0] == 0)
+		return mask;
+	if (*s == '!') {
+		invert = 1;
+		s++;
+	}
+	if (*s == '+') {
+		relative++;
+		s++;
+	}
+	do {
+		unsigned long arg;
+		int i;
+
+		if (!strcmp(s,"all")) {
+			copy_bitmask_to_bitmask(allowed_cpus_ptr, mask);
+			s+=4;
+			break;
+		}
+		arg = get_nr(s, &end, allowed_cpus_ptr, relative);
+		if (end == s) {
+			numa_warn(W_cpuparse, "unparseable cpu description `%s'\n", s);
+			goto err;
+		}
+		if (!numa_bitmask_isbitset(allowed_cpus_ptr, arg)) {
+			numa_warn(W_cpuparse, "cpu argument %s is out of range\n", s);
+			goto err;
+		}
+		i = arg;
+		numa_bitmask_setbit(mask, i);
+		s = end;
+		if (*s == '-') {
+			char *end2;
+			unsigned long arg2;
+			int i;
+			arg2 = get_nr(++s, &end2, allowed_cpus_ptr, relative);
+			if (end2 == s) {
+				numa_warn(W_cpuparse, "missing cpu argument %s\n", s);
+				goto err;
+			}
+			if (!numa_bitmask_isbitset(allowed_cpus_ptr, arg2)) {
+				numa_warn(W_cpuparse, "cpu argument %s out of range\n", s);
+				goto err;
+			}
+			while (arg <= arg2) {
+				i = arg;
+				if (numa_bitmask_isbitset(allowed_cpus_ptr, i))
+					numa_bitmask_setbit(mask, i);
+				arg++;
+			}
+			s = end2;
+		}
+	} while (*s++ == ',');
+	if (s[-1] != '\0')
+		goto err;
+	if (invert) {
+		int i;
+		for (i = 0; i < conf_cpus; i++) {
+			if (numa_bitmask_isbitset(mask, i))
+				numa_bitmask_clearbit(mask, i);
+			else
+				numa_bitmask_setbit(mask, i);
+		}
+	}
+	return mask;
+
+err:
+	numa_bitmask_free(mask);
+	return NULL;
+}
+
+/*
+ * numa_parse_cpustring() is called to create a bitmask from cpus available
+ * for this task.
+ */
+
+struct bitmask * numa_parse_cpustring(const char *s)
+{
+	return __numa_parse_cpustring(s, numa_all_cpus_ptr);
+}
+
+/*
+ * numa_parse_cpustring_all() is called to create a bitmask from all cpus
+ * available.
+ */
+
+struct bitmask * numa_parse_cpustring_all(const char *s)
+{
+	return __numa_parse_cpustring(s, numa_possible_cpus_ptr);
+}
diff --git a/m4/ax_am_override_var.m4 b/m4/ax_am_override_var.m4
new file mode 100644
index 0000000..21803fa
--- /dev/null
+++ b/m4/ax_am_override_var.m4
@@ -0,0 +1,155 @@
+# ===========================================================================
+#    http://www.gnu.org/software/autoconf-archive/ax_am_override_var.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_AM_OVERRIDE_VAR([varname1 varname ... ])
+#   AX_AM_OVERRIDE_FINALIZE
+#
+# DESCRIPTION
+#
+#   This autoconf macro generalizes the approach given in
+#   <http://lists.gnu.org/archive/html/automake/2005-09/msg00108.html> which
+#   moves user specified values for variable 'varname' given at configure
+#   time into the corresponding AM_${varname} variable and clears out
+#   'varname', allowing further manipulation by the configure script so that
+#   target specific variables can be given specialized versions.  'varname
+#   may still be specified on the make command line and will be appended as
+#   usual.
+#
+#   As an example usage, consider a project which might benefit from
+#   different compiler flags for different components. Typically this is
+#   done via target specific flags, e.g.
+#
+#    libgtest_la_CXXFLAGS    =                        \
+#                     -I $(top_srcdir)/tests          \
+#                     -I $(top_builddir)/tests        \
+#                     $(GTEST_CXXFLAGS)
+#
+#   automake will automatically append $(CXXFLAGS) -- provided by the user
+#   -- to the build rule for libgtest_la.  That might be problematic, as
+#   CXXFLAGS may contain compiler options which are inappropriate for
+#   libgtest_la.
+#
+#   The approach laid out in the referenced mailing list message is to
+#   supply a base value for a variable during _configure_ time, during which
+#   it is possible to amend it for specific targets. The user may
+#   subsequently specify a value for the variable during _build_ time, which
+#   make will apply (via the standard automake rules) to all appropriate
+#   targets.
+#
+#   For example,
+#
+#    AX_AM_OVERRIDE_VAR([CXXFLAGS])
+#
+#   will store the value of CXXFLAGS specified at configure time into the
+#   AM_CXXFLAGS variable, AC_SUBST it, and clear CXXFLAGS. configure may
+#   then create a target specific set of flags based upon AM_CXXFLAGS, e.g.
+#
+#    # googletest uses variadic macros, which g++ -pedantic-errors
+#    # is very unhappy about
+#    AC_SUBST([GTEST_CXXFLAGS],
+#       [`AS_ECHO_N(["$AM_CXXFLAGS"]) \
+#             | sed s/-pedantic-errors/-pedantic/`
+#        ]
+#     )
+#
+#   which would be used in a Makefile.am as above.  Since CXXFLAGS is
+#   cleared, the configure time value will not affect the build for
+#   libgtest_la.
+#
+#   Prior to _any other command_ which may set ${varname}, call
+#
+#    AX_AM_OVERRIDE_VAR([varname])
+#
+#   This will preserve the value (if any) passed to configure in
+#   AM_${varname} and AC_SUBST([AM_${varname}).  You may pass a space
+#   separated list of variable names, or may call AX_AM_OVERRIDE_VAR
+#   multiple times for the same effect.
+#
+#   If any subsequent configure commands set ${varname} and you wish to
+#   capture the resultant value into AM_${varname} in the case where
+#   ${varname} was _not_ provided at configure time,  call
+#
+#    AX_AM_OVERRIDE_FINALIZE
+#
+#   after _all_ commands which might affect any of the variables specified
+#   in calls to AX_AM_OVERRIDE_VAR.  This need be done only once, but
+#   repeated calls will not cause harm.
+#
+#   There is a bit of trickery required to allow further manipulation of the
+#   AM_${varname} in a Makefile.am file.  If AM_CFLAGS is used as is in a
+#   Makefile.am, e.g.
+#
+#    libfoo_la_CFLAGS = $(AM_CFLAGS)
+#
+#   then automake will emit code in Makefile.in which sets AM_CFLAGS from
+#   the configure'd value.
+#
+#   If however, AM_CFLAGS is manipulated (i.e. appended to), you will have
+#   to explicitly arrange for the configure'd value to be substituted:
+#
+#    AM_CFLAGS = @AM_CFLAGS@
+#    AM_CFLAGS += -lfoo
+#
+#   or else automake will complain about using += before =.
+#
+# LICENSE
+#
+#   Copyright (c) 2013 Smithsonian Astrophysical Observatory
+#   Copyright (c) 2013 Diab Jerius <djerius@cfa.harvard.edu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 1
+
+AC_DEFUN([_AX_AM_OVERRIDE_INITIALIZE],
+[
+        m4_define([_mst_am_override_vars],[])
+])
+
+
+# _AX_AM_OVERRIDE_VAR(varname)
+AC_DEFUN([_AX_AM_OVERRIDE_VAR],
+[
+  m4_define([_mst_am_override_vars], m4_defn([_mst_am_override_vars]) $1 )
+  _mst_am_override_$1_set=false
+
+  AS_IF( [test "${$1+set}" = set],
+         [AC_SUBST([AM_$1],["$$1"])
+          $1=
+          _mst_am_override_$1_set=:
+         ]
+  )
+]) # _AX_AM_OVERRIDE_VAR
+
+# _AX_AM_OVERRIDE_FINALIZE(varname)
+AC_DEFUN([_AX_AM_OVERRIDE_FINALIZE],
+[
+  AS_IF([$_mst_am_override_$1_set = :],
+        [],
+        [AC_SUBST([AM_$1],["$$1"])
+         $1=
+         _mst_am_override_$1_set=
+        ]
+  )
+  AC_SUBST($1)
+]) # _AX_AM_OVERRIDE_FINALIZE
+
+AC_DEFUN([AX_AM_OVERRIDE_VAR],
+[
+  AC_REQUIRE([_AX_AM_OVERRIDE_INITIALIZE])
+  m4_map_args_w([$1],[_AX_AM_OVERRIDE_VAR(],[)])
+])# AX_OVERRIDE_VAR
+
+
+# AX_AM_OVERRIDE_FINALIZE
+AC_DEFUN([AX_AM_OVERRIDE_FINALIZE],
+[
+  AC_REQUIRE([_AX_AM_OVERRIDE_INITIALIZE])
+  m4_map_args_w(_mst_am_override_vars,[_AX_AM_OVERRIDE_FINALIZE(],[)])
+]) # AX_AM_OVERRIDE_FINALIZE
diff --git a/m4/ax_check_compile_flag.m4 b/m4/ax_check_compile_flag.m4
new file mode 100644
index 0000000..51df0c0
--- /dev/null
+++ b/m4/ax_check_compile_flag.m4
@@ -0,0 +1,74 @@
+# ===========================================================================
+#   http://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS], [INPUT])
+#
+# DESCRIPTION
+#
+#   Check whether the given FLAG works with the current language's compiler
+#   or gives an error.  (Warnings, however, are ignored)
+#
+#   ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
+#   success/failure.
+#
+#   If EXTRA-FLAGS is defined, it is added to the current language's default
+#   flags (e.g. CFLAGS) when the check is done.  The check is thus made with
+#   the flags: "CFLAGS EXTRA-FLAGS FLAG".  This can for example be used to
+#   force the compiler to issue an error when a bad flag is given.
+#
+#   INPUT gives an alternative input source to AC_COMPILE_IFELSE.
+#
+#   NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
+#   macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
+#   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
+#
+#   This program 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, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program 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.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 3
+
+AC_DEFUN([AX_CHECK_COMPILE_FLAG],
+[AC_PREREQ(2.59)dnl for _AC_LANG_PREFIX
+AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
+AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
+  ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
+  _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
+  AC_COMPILE_IFELSE([m4_default([$5],[AC_LANG_PROGRAM()])],
+    [AS_VAR_SET(CACHEVAR,[yes])],
+    [AS_VAR_SET(CACHEVAR,[no])])
+  _AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags])
+AS_IF([test x"AS_VAR_GET(CACHEVAR)" = xyes],
+  [m4_default([$2], :)],
+  [m4_default([$3], :)])
+AS_VAR_POPDEF([CACHEVAR])dnl
+])dnl AX_CHECK_COMPILE_FLAGS
diff --git a/m4/ax_tls.m4 b/m4/ax_tls.m4
new file mode 100644
index 0000000..033e3b1
--- /dev/null
+++ b/m4/ax_tls.m4
@@ -0,0 +1,76 @@
+# ===========================================================================
+#          http://www.gnu.org/software/autoconf-archive/ax_tls.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_TLS([action-if-found], [action-if-not-found])
+#
+# DESCRIPTION
+#
+#   Provides a test for the compiler support of thread local storage (TLS)
+#   extensions. Defines TLS if it is found. Currently knows about GCC/ICC
+#   and MSVC. I think SunPro uses the same as GCC, and Borland apparently
+#   supports either.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Alan Woodland <ajw05@aber.ac.uk>
+#   Copyright (c) 2010 Diego Elio Petteno` <flameeyes@gmail.com>
+#
+#   This program 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, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program 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.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 10
+
+AC_DEFUN([AX_TLS], [
+  AC_MSG_CHECKING(for thread local storage (TLS) class)
+  AC_CACHE_VAL(ac_cv_tls, [
+    ax_tls_keywords="__thread __declspec(thread) none"
+    for ax_tls_keyword in $ax_tls_keywords; do
+       AS_CASE([$ax_tls_keyword],
+          [none], [ac_cv_tls=none ; break],
+          [AC_TRY_COMPILE(
+              [#include <stdlib.h>
+               static void
+               foo(void) {
+               static ] $ax_tls_keyword [ int bar;
+               exit(1);
+               }],
+               [],
+               [ac_cv_tls=$ax_tls_keyword ; break],
+               ac_cv_tls=none
+           )])
+    done
+  ])
+  AC_MSG_RESULT($ac_cv_tls)
+
+  AS_IF([test "$ac_cv_tls" != "none"],
+    AC_DEFINE_UNQUOTED([TLS], $ac_cv_tls, [If the compiler supports a TLS storage class define it to that here])
+      m4_ifnblank([$1], [$1]),
+    m4_ifnblank([$2], [$2])
+  )
+])
diff --git a/manlinks b/manlinks
new file mode 100644
index 0000000..811c925
--- /dev/null
+++ b/manlinks
@@ -0,0 +1,5 @@
+#!/bin/sh
+# print names of all functions listed in numa.3
+# no globals
+
+grep '^\.BI.*numa.*(' numa.3  | sed -e 's/.*\(numa_.*\)(.*/\1/'
diff --git a/memhog.c b/memhog.c
new file mode 100644
index 0000000..361a2ed
--- /dev/null
+++ b/memhog.c
@@ -0,0 +1,145 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+   Allocate memory with policy for testing.
+
+   numactl 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
+   2.
+
+   numactl 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.
+
+   You should find a copy of v2 of the GNU General Public License somewhere
+   on your Linux system; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/fcntl.h>
+#include <string.h>
+#include <stdbool.h>
+#include "numa.h"
+#include "numaif.h"
+#include "util.h"
+
+#define terr(x) perror(x)
+
+enum {
+	UNIT = 10*1024*1024,
+};
+
+#ifndef MADV_NOHUGEPAGE
+#define MADV_NOHUGEPAGE 15
+#endif
+
+int repeat = 1;
+
+void usage(void)
+{
+	printf("memhog [-rNUM] size[kmg] [policy [nodeset]]\n");
+	printf("-rNUM repeat memset NUM times\n");
+	printf("-H disable transparent hugepages\n");
+	print_policies();
+	exit(1);
+}
+
+long length;
+
+void hog(void *map)
+{
+	long i;
+	for (i = 0;  i < length; i += UNIT) {
+		long left = length - i;
+		if (left > UNIT)
+			left = UNIT;
+		putchar('.');
+		fflush(stdout);
+		memset(map + i, 0xff, left);
+	}
+	putchar('\n');
+}
+
+int main(int ac, char **av)
+{
+	char *map;
+	struct bitmask *nodes, *gnodes;
+	int policy, gpolicy;
+	int ret = 0;
+	int loose = 0;
+	int i;
+	int fd = -1;
+	bool disable_hugepage = false;
+
+	nodes = numa_allocate_nodemask();
+	gnodes = numa_allocate_nodemask();
+
+	while (av[1] && av[1][0] == '-') {
+		switch (av[1][1]) {
+		case 'f':
+			fd = open(av[1]+2, O_RDWR);
+			if (fd < 0)
+				perror(av[1]+2);
+			break;
+		case 'r':
+			repeat = atoi(av[1] + 2);
+			break;
+		case 'H':
+			disable_hugepage = true;
+			break;
+		default:
+			usage();
+		}
+		av++;
+	}
+
+	if (!av[1]) usage();
+
+	length = memsize(av[1]);
+	if (av[2] && numa_available() < 0) {
+		printf("Kernel doesn't support NUMA policy\n");
+		exit(1);
+	} else
+		loose = 1;
+	policy = parse_policy(av[2], av[3]);
+	if (policy != MPOL_DEFAULT)
+		nodes = numa_parse_nodestring(av[3]);
+        if (!nodes) {
+		printf ("<%s> is invalid\n", av[3]);
+		exit(1);
+	}
+
+	if (fd >= 0)
+		map = mmap(NULL,length,PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+	else
+		map = mmap(NULL, length, PROT_READ|PROT_WRITE,
+				   MAP_PRIVATE|MAP_ANONYMOUS,
+				   0, 0);
+	if (map == (char*)-1)
+		err("mmap");
+
+	if (mbind(map, length, policy, nodes->maskp, nodes->size, 0) < 0)
+		terr("mbind");
+
+	if (disable_hugepage)
+		madvise(map, length, MADV_NOHUGEPAGE);
+
+	gpolicy = -1;
+	if (get_mempolicy(&gpolicy, gnodes->maskp, gnodes->size, map, MPOL_F_ADDR) < 0)
+		terr("get_mempolicy");
+	if (!loose && policy != gpolicy) {
+		ret = 1;
+		printf("policy %d gpolicy %d\n", policy, gpolicy);
+	}
+	if (!loose && !numa_bitmask_equal(gnodes, nodes)) {
+		printf("nodes differ %lx, %lx!\n",
+			gnodes->maskp[0], nodes->maskp[0]);
+		ret = 1;
+	}
+
+	for (i = 0; i < repeat; i++)
+		hog(map);
+	exit(ret);
+}
diff --git a/migratepages.8 b/migratepages.8
new file mode 100644
index 0000000..0f7a1d0
--- /dev/null
+++ b/migratepages.8
@@ -0,0 +1,75 @@
+.\" t
+.\" Copyright 2005-2006 Christoph Lameter, Silicon Graphics, Inc.
+.\"
+.\" based on Andi Kleen's numactl manpage
+.\"
+.TH MIGRATEPAGES 8 "Jan 2005" "SGI" "Linux Administrator's Manual"
+.SH NAME
+migratepages \- Migrate the physical location a processes pages
+.SH SYNOPSIS
+.B migratepages
+pid from-nodes to-nodes
+.SH DESCRIPTION
+.B migratepages
+moves the physical location of a processes pages without any changes of the
+virtual address space of the process. Moving the pages allows one to change
+the distances of a process to its memory. Performance may be optimized by moving
+a processes pages to the node where it is executing.
+
+If multiple nodes are specified for from-nodes or to-nodes then
+an attempt is made to preserve the relative location of
+each page in each nodeset.
+
+For example if we move from nodes 2-5 to 7,9,12-13 then the preferred mode of
+operation is to move pages from 2->7, 3->9, 4->12 and 5->13. However, this
+is only posssible if enough memory is available.
+.TP
+Valid node specifiers
+.TS
+tab(:);
+l l. 
+all:All nodes
+number:Node number
+number1{,number2}:Node number1 and Node number2
+number1-number2:Nodes from number1 to number2
+! nodes:Invert selection of the following specification.
+.TE
+.SH NOTES
+Requires an NUMA policy aware kernel with support for page migration
+(linux 2.6.16 and later).
+
+migratepages will only move pages that are not shared with other
+processes if called by a user without administrative priviledges (but
+with the right to modify the process).
+
+migratepages will move all pages if invoked from root (or a user with
+administrative priviledges).
+
+.SH FILES
+.I /proc/<pid>/numa_maps
+for information about the NUMA memory use of a process.
+.SH COPYRIGHT
+Copyright 2005-2006 Christoph Lameter, Silicon Graphics, Inc.
+migratepages is under the GNU General Public License, v.2
+
+.SH SEE ALSO
+.I numactl(8)
+,
+.I set_mempolicy(2)
+,
+.I get_mempolicy(2)
+,
+.I mbind(2)
+,
+.I sched_setaffinity(2)
+, 
+.I sched_getaffinity(2)
+,
+.I proc(5)
+, 
+.I ftok(3)
+,
+.I shmat(2)
+,
+.I taskset(1)
+
diff --git a/migratepages.c b/migratepages.c
new file mode 100644
index 0000000..61ba6cb
--- /dev/null
+++ b/migratepages.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2005 Christoph Lameter, Silicon Graphics, Incorporated.
+ * based on Andi Kleen's numactl.c.
+ *
+ * Manual process migration
+ *
+ * migratepages 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 2.
+ *
+ * migratepages 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.
+ *
+ * You should find a copy of v2 of the GNU General Public License somewhere
+ * on your Linux system; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define _GNU_SOURCE
+#include <getopt.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include "numa.h"
+#include "numaif.h"
+#include "numaint.h"
+#include "util.h"
+
+struct option opts[] = {
+	{"help", 0, 0, 'h' },
+	{ 0 }
+};
+
+void usage(void)
+{
+	fprintf(stderr,
+		"usage: migratepages pid from-nodes to-nodes\n"
+		"\n"
+		"nodes is a comma delimited list of node numbers or A-B ranges or all.\n"
+);
+	exit(1);
+}
+
+void checknuma(void)
+{
+	static int numa = -1;
+	if (numa < 0) {
+		if (numa_available() < 0)
+			complain("This system does not support NUMA functionality");
+	}
+	numa = 0;
+}
+
+int main(int argc, char *argv[])
+{
+	int c;
+	char *end;
+	int rc;
+	int pid;
+	struct bitmask *fromnodes;
+	struct bitmask *tonodes;
+
+	while ((c = getopt_long(argc,argv,"h", opts, NULL)) != -1) {
+		switch (c) {
+		default:
+			usage();
+		}
+	}
+
+	argv += optind;
+	argc -= optind;
+
+	if (argc != 3)
+		usage();
+
+	checknuma();
+
+	pid = strtoul(argv[0], &end, 0);
+	if (*end || end == argv[0])
+		usage();
+
+	fromnodes = numa_parse_nodestring(argv[1]);
+	if (!fromnodes) {
+		printf ("<%s> is invalid\n", argv[1]);
+		exit(1);
+	}
+	tonodes = numa_parse_nodestring(argv[2]);
+	if (!tonodes) {
+		printf ("<%s> is invalid\n", argv[2]);
+		exit(1);
+	}
+
+	rc = numa_migrate_pages(pid, fromnodes, tonodes);
+
+	if (rc < 0) {
+		perror("migrate_pages");
+		return 1;
+	}
+	return 0;
+}
diff --git a/migspeed.8 b/migspeed.8
new file mode 100644
index 0000000..6f4176e
--- /dev/null
+++ b/migspeed.8
@@ -0,0 +1,31 @@
+.\" t
+.\" Copyright 2005-2007 Christoph Lameter, Silicon Graphics, Inc.
+.\"
+.\" based on Andi Kleen's numactl manpage
+.\"
+.TH MIGSPEED 8 "April 2005" "SGI" "Linux Administrator's Manual"
+.SH NAME
+migspeed \- Test the speed of page migration
+.SH SYNOPSIS
+.B migspeed
+-p pages from-nodes to-nodes
+.SH DESCRIPTION
+.B migspeed
+attempts to move a sample of pages from the indicated node to the target node
+and measures the time it takes to perform the move.
+
+.B -p pages
+
+The default sample is 1000 pages. Override that with another number.
+
+.SH NOTES
+Requires an NUMA policy aware kernel with support for page migration
+(Linux 2.6.16 and later).
+
+.SH COPYRIGHT
+Copyright 2007 Christoph Lameter, Silicon Graphics, Inc.
+migratepages is under the GNU General Public License, v.2
+
+.SH SEE ALSO
+.I numactl(8)
+
diff --git a/migspeed.c b/migspeed.c
new file mode 100644
index 0000000..6260c24
--- /dev/null
+++ b/migspeed.c
@@ -0,0 +1,187 @@
+/*
+ * Migration test program
+ *
+ * (C) 2007 Silicon Graphics, Inc. Christoph Lameter <clameter@sgi.com>
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "numa.h"
+#include "numaif.h"
+#include <time.h>
+#include <errno.h>
+#include <malloc.h>
+#include <unistd.h>
+#include "util.h"
+
+char *memory;
+
+unsigned long pages = 1000;
+
+unsigned long pagesize;
+
+const char *optstr = "hvp:";
+
+char *cmd;
+
+int verbose;
+struct timespec start,end;
+
+void usage(void)
+{
+	printf("usage %s [-p pages] [-h] [-v] from-nodes to-nodes\n", cmd);
+	printf("      from and to nodes may specified in form N or N-N\n");
+	printf("      -p pages  number of pages to try (defaults to %ld)\n",
+			pages);
+	printf("      -v        verbose\n");
+	printf("      -h        usage\n");
+	exit(1);
+}
+
+void displaymap(void)
+{
+	FILE *f = fopen("/proc/self/numa_maps","r");
+
+	if (!f) {
+		printf("/proc/self/numa_maps not accessible.\n");
+		exit(1);
+	}
+
+	while (!feof(f))
+	{
+		char buffer[2000];
+
+		if (!fgets(buffer, sizeof(buffer), f))
+			break;
+		if (!strstr(buffer, "bind"))
+			continue ;
+		printf("%s", buffer);
+
+	}
+	fclose(f);
+}
+
+int main(int argc, char *argv[])
+{
+	char *p;
+	int option;
+	struct timespec result;
+	unsigned long bytes;
+	double duration, mbytes;
+	struct bitmask *from;
+	struct bitmask *to;
+
+	pagesize = getpagesize();
+
+	/* Command line processing */
+	opterr = 1;
+	cmd = argv[0];
+
+	while ((option = getopt(argc, argv, optstr)) != EOF)
+	switch (option) {
+	case 'h' :
+	case '?' :
+		usage();
+	case 'v' :
+		verbose++;
+		break;
+	case 'p' :
+		pages = strtoul(optarg, &p, 0);
+		if (p == optarg || *p)
+			usage();
+		break;
+	}
+
+	if (!argv[optind])
+		usage();
+
+	if (verbose > 1)
+		printf("numa_max_node = %d\n", numa_max_node());
+
+	numa_exit_on_error = 1;
+
+	from = numa_parse_nodestring(argv[optind]);
+	if (!from) {
+                printf ("<%s> is invalid\n", argv[optind]);
+		exit(1);
+	}
+	if (errno) {
+		perror("from mask");
+		exit(1);
+	}
+
+	if (verbose)
+		printmask("From", from);
+
+	if (!argv[optind+1])
+		usage();
+
+	to = numa_parse_nodestring(argv[optind+1]);
+	if (!to) {
+                printf ("<%s> is invalid\n", argv[optind+1]);
+		exit(1);
+	}
+	if (errno) {
+		perror("to mask");
+		exit(1);
+	}
+
+	if (verbose)
+		printmask("To", to);
+
+	bytes = pages * pagesize;
+
+	if (verbose)
+		printf("Allocating %lu pages of %lu bytes of memory\n",
+				pages, pagesize);
+
+	memory = memalign(pagesize, bytes);
+
+	if (!memory) {
+		printf("Out of Memory\n");
+		exit(2);
+	}
+
+	if (mbind(memory, bytes, MPOL_BIND, from->maskp, from->size, 0) < 0)
+		numa_error("mbind");
+
+	if (verbose)
+		printf("Dirtying memory....\n");
+
+	for (p = memory; p <= memory + bytes; p += pagesize)
+		*p = 1;
+
+	if (verbose)
+		printf("Starting test\n");
+
+	displaymap();
+	clock_gettime(CLOCK_REALTIME, &start);
+
+	if (mbind(memory, bytes, MPOL_BIND, to->maskp, to->size, MPOL_MF_MOVE) <0)
+		numa_error("memory move");
+
+	clock_gettime(CLOCK_REALTIME, &end);
+	displaymap();
+
+	result.tv_sec = end.tv_sec - start.tv_sec;
+	result.tv_nsec = end.tv_nsec - start.tv_nsec;
+
+	if (result.tv_nsec < 0) {
+		result.tv_sec--;
+		result.tv_nsec += 1000000000;
+	}
+
+	if (result.tv_nsec >= 1000000000) {
+		result.tv_sec++;
+		result.tv_nsec -= 1000000000;
+	}
+
+	duration = result.tv_sec + result.tv_nsec / 1000000000.0;
+	mbytes = bytes / (1024*1024.0);
+
+	printf("%1.1f Mbyte migrated in %1.2f secs. %3.1f Mbytes/second\n",
+			mbytes,
+			duration,
+			mbytes / duration);
+	return 0;
+}
diff --git a/mkolddemo b/mkolddemo
new file mode 100644
index 0000000..4bf4baf
--- /dev/null
+++ b/mkolddemo
@@ -0,0 +1,9 @@
+# test the numacompat1.h stuff by compiling an old version of numademo.c
+
+cc -L. -lnuma -I. -DNUMA_VERSION1_COMPATIBILITY -o olddemo olddemo.c
+
+
+export LD_LIBRARY_PATH=.
+echo "executing olddemo:"
+./olddemo
+
diff --git a/move_pages.2 b/move_pages.2
new file mode 100644
index 0000000..6c98fa8
--- /dev/null
+++ b/move_pages.2
@@ -0,0 +1,155 @@
+.\" Hey Emacs! This file is -*- nroff -*- source.
+.\"
+.\" This manpage is Copyright (C) 2006 Silicon Graphics, Inc.
+.\"                               Christoph Lameter
+.\"
+.\" Permission is granted to make and distribute verbatim copies of this
+.\" manual provided the copyright notice and this permission notice are
+.\" preserved on all copies.
+.\"
+.\" Permission is granted to copy and distribute modified versions of this
+.\" manual under the conditions for verbatim copying, provided that the
+.\" entire resulting derived work is distributed under the terms of a
+.\" permission notice identical to this one.
+.\"
+.TH MOVE_PAGES 2 2006-10-31 "Linux 2.6.18" "Linux Programmer's Manual"
+.SH NAME
+move_pages \- Move individual pages of a process to another node
+.SH SYNOPSIS
+.B #include <numaif.h>
+.sp
+.BI "long move_pages(int " pid ", unsigned long count, void ** " pages ", const int * " nodes ", int * " status ", int " flags );
+.SH DESCRIPTION
+.BR move_pages ()
+moves
+.I count
+pages to the
+.I nodes.
+The result of the move is reflected in
+.I status.
+The
+.I flags
+indicate constraints on the pages to be moved.
+
+.I pid
+is the process id in which pages are to be moved. Sufficient rights
+must exist to move pages of another process. This means the moving
+process either has root priviledges, has SYS_NICE administrative rights or
+the same owner. If pid is 0 then we move pages of the current process.
+
+.I count
+is the number of pages to move. It defines the size of the three
+arrays
+.I pages,
+.I nodes
+and
+.I status.
+
+.I pages
+is an array of pointers to the pages that should be moved. These are pointers
+that should be aligned to page boundaries. Addresses are specified as seen by
+the process specified by
+.I pid.
+
+.I nodes
+is either an array of integers that specify the desired location for each
+page or it is NULL. Each integer is a node number. If NULL is specified then
+move_pages will not move any pages but return the node of each page in
+the
+.I status
+array. Having the status of each page may be necessary to determine
+pages that need to be moved.
+
+.I status
+is an array of integers that return the status of each page. The array
+only contains valid values if
+.I move_pages
+did not return an error code.
+
+.I flags
+specify what types of pages to move.
+.B MPOL_MF_MOVE
+means that only pages that are in exclusive use by the process
+are to be moved.
+.B MPOL_MF_MOVE_ALL
+means that pages shared between multiple processes can also be moved.
+The process must have root priviledges or SYS_NICE priviledges.
+
+.SH Page states in the status array
+
+.TP
+.B 0..MAX_NUMNODES
+Indicates that the location of the page is on this node.
+.TP
+.B -ENOENT
+The page is not present.
+.TP
+.B -EACCES
+The page is mapped by multiple processes and can only be moved
+if
+.I MPOL_MF_MOVE_ALL
+is specified.
+.TP
+.B -EBUSY
+The page is currently busy and cannot be moved. Try again later.
+This occurs if a page is undergoing I/O or another kernel subsystem
+is holding a reference to the page.
+.TP
+.B -EFAULT
+This is a zero page or the memory area is not mapped by the process.
+.TP
+.B -ENOMEM
+Unable to allocate memory on target node.
+.TP
+.B -EIO
+Unable to write back a page. The page has to be written back
+in order to move ti since the page is dirty and the filesystem
+has not provide a migration function that would allow the move
+of dirty pages.
+.TP
+.B -EINVAL
+A dirty page cannot be moved. The filesystem does not
+provide a migration function and has no ability to write back pages.
+
+.SH "RETURN VALUE"
+On success
+.B move_pages
+returns zero.
+.SH ERRORS
+.TP
+.B -ENOENT
+No pages were found that require moving. All pages are either already
+on the target node, not present, had an invalid address or could not be
+moved because they were mapped by multiple processes.
+.TP
+.B -EINVAL
+Flags other than
+.I MPOL_MF_MOVE
+and
+.I MPOL_MF_MOVE_ALL
+was specified or an attempt was made to migrate pages of a kernel thread.
+.TP
+.B -EPERM
+.I MPOL_MF_MOVE_ALL
+specified without sufficient privileges or an attempt to move a process
+belonging to another user.
+.TP
+.B -EACCESS
+On of the target nodes is not allowed by the current cpuset.
+.TP
+.B -ENODEV
+On of the target nodes is not online.
+.TP
+.B -ESRCH
+Process does not exist.
+.TP
+.B -E2BIG
+Too many pages to move.
+.TP
+.B -EFAULT
+Parameter array could not be accessed.
+.SH "SEE ALSO"
+.BR numa_maps (5),
+.BR migratepages (8),
+.BR numa_stat (8),
+.BR numa (3)
diff --git a/mt.c b/mt.c
new file mode 100644
index 0000000..112399c
--- /dev/null
+++ b/mt.c
@@ -0,0 +1,46 @@
+/* Mersenne twister implementation from Michael Brundage. Public Domain.
+   MT is a very fast pseudo random number generator. This version works
+   on 32bit words.  Changes by AK. */
+#include <stdlib.h>
+#include "mt.h"
+
+int mt_index;
+unsigned int mt_buffer[MT_LEN];
+
+void mt_init(void)
+{
+    int i;
+    srand(1);
+    for (i = 0; i < MT_LEN; i++)
+        mt_buffer[i] = rand();
+    mt_index = 0;
+}
+
+#define MT_IA           397
+#define MT_IB           (MT_LEN - MT_IA)
+#define UPPER_MASK      0x80000000
+#define LOWER_MASK      0x7FFFFFFF
+#define MATRIX_A        0x9908B0DF
+#define TWIST(b,i,j)    ((b)[i] & UPPER_MASK) | ((b)[j] & LOWER_MASK)
+#define MAGIC(s)        (((s)&1)*MATRIX_A)
+
+void mt_refill(void)
+{
+	int i;
+	unsigned int s;
+	unsigned int * b = mt_buffer;
+
+	mt_index = 0;
+        i = 0;
+        for (; i < MT_IB; i++) {
+            s = TWIST(b, i, i+1);
+            b[i] = b[i + MT_IA] ^ (s >> 1) ^ MAGIC(s);
+        }
+        for (; i < MT_LEN-1; i++) {
+            s = TWIST(b, i, i+1);
+            b[i] = b[i - MT_IB] ^ (s >> 1) ^ MAGIC(s);
+        }
+
+        s = TWIST(b, MT_LEN-1, 0);
+        b[MT_LEN-1] = b[MT_IA-1] ^ (s >> 1) ^ MAGIC(s);
+}
diff --git a/mt.h b/mt.h
new file mode 100644
index 0000000..ffbf1c9
--- /dev/null
+++ b/mt.h
@@ -0,0 +1,20 @@
+#define MT_LEN	     624
+
+extern void mt_init(void);
+extern void mt_refill();
+
+extern int mt_index;
+extern unsigned int mt_buffer[MT_LEN];
+
+static inline unsigned int mt_random(void)
+{
+    unsigned int * b = mt_buffer;
+    int idx = mt_index;
+
+    if (idx == MT_LEN*sizeof(unsigned int)) {
+	    mt_refill();
+	    idx = 0;
+    }
+    mt_index += sizeof(unsigned int);
+    return *(unsigned int *)((unsigned char *)b + idx);
+}
diff --git a/numa.3 b/numa.3
new file mode 100644
index 0000000..ba00572
--- /dev/null
+++ b/numa.3
@@ -0,0 +1,1058 @@
+.\" Copyright 2003,2004 Andi Kleen, SuSE Labs.
+.\"
+.\" Permission is granted to make and distribute verbatim copies of this
+.\" manual provided the copyright notice and this permission notice are
+.\" preserved on all copies.
+.\"
+.\" Permission is granted to copy and distribute modified versions of this
+.\" manual under the conditions for verbatim copying, provided that the
+.\" entire resulting derived work is distributed under the terms of a
+.\" permission notice identical to this one.
+.\"
+.\" Since the Linux kernel and libraries are constantly changing, this
+.\" manual page may be incorrect or out-of-date.  The author(s) assume no
+.\" responsibility for errors or omissions, or for damages resulting from
+.\" the use of the information contained herein.
+.\"
+.\" Formatted or processed versions of this manual, if unaccompanied by
+.\" the source, must acknowledge the copyright and authors of this work.
+.TH NUMA 3 "December 2007" "SuSE Labs" "Linux Programmer's Manual"
+.SH NAME
+numa \- NUMA policy library
+.SH SYNOPSIS
+.B #include <numa.h>
+.sp
+.B cc ... \-lnuma
+.sp
+.B int numa_available(void);
+.sp
+.BI "int numa_max_possible_node(void);"
+.br
+.BI "int numa_num_possible_nodes();"
+.sp
+.B int numa_max_node(void);
+.br
+.BI "int numa_num_configured_nodes();"
+.br
+.B struct bitmask *numa_get_mems_allowed(void);
+.sp
+.BI "int numa_num_configured_cpus(void);"
+.br
+.BI "struct bitmask *numa_all_nodes_ptr;"
+.br
+.BI "struct bitmask *numa_no_nodes_ptr;"
+.br
+.BI "struct bitmask *numa_all_cpus_ptr;"
+.sp
+.BI "int numa_num_task_cpus();"
+.br
+.BI "int numa_num_task_nodes();"
+.sp
+.BI "int numa_parse_bitmap(char *" line " , struct bitmask *" mask ");
+.br
+.BI "struct bitmask *numa_parse_nodestring(const char *" string );
+.br
+.BI "struct bitmask *numa_parse_nodestring_all(const char *" string );
+.br
+.BI "struct bitmask *numa_parse_cpustring(const char *" string );
+.br
+.BI "struct bitmask *numa_parse_cpustring_all(const char *" string );
+.sp
+.BI "long numa_node_size(int " node ", long *" freep );
+.br
+.BI "long long numa_node_size64(int " node ", long long *" freep );
+.sp
+.B int numa_preferred(void);
+.br
+.BI "void numa_set_preferred(int " node );
+.br
+.BI "int numa_get_interleave_node(void);
+.br
+.B struct bitmask *numa_get_interleave_mask(void);
+.br
+.BI "void numa_set_interleave_mask(struct bitmask *" nodemask );
+.br
+.BI "void numa_interleave_memory(void *" start ", size_t " size ", struct bitmask *" nodemask );
+.br
+.BI "void numa_bind(struct bitmask *" nodemask );
+.br
+.BI "void numa_set_localalloc(void);
+.br
+.BI "void numa_set_membind(struct bitmask *" nodemask );
+.br
+.B struct bitmask *numa_get_membind(void);
+.sp
+.BI "void *numa_alloc_onnode(size_t " size ", int " node );
+.br
+.BI "void *numa_alloc_local(size_t " size );
+.br
+.BI "void *numa_alloc_interleaved(size_t " size );
+.br
+.BI "void *numa_alloc_interleaved_subset(size_t " size ",  struct bitmask *" nodemask );
+.BI "void *numa_alloc(size_t " size );
+.br
+.BI "void *numa_realloc(void *"old_addr ", size_t " old_size ", size_t " new_size );
+.br
+.BI "void numa_free(void *" start ", size_t " size );
+.sp
+.BI "int numa_run_on_node(int " node );
+.br
+.BI "int numa_run_on_node_mask(struct bitmask *" nodemask );
+.br
+.BI "int numa_run_on_node_mask_all(struct bitmask *" nodemask );
+.br
+.B struct bitmask *numa_get_run_node_mask(void);
+.sp
+.BI "void numa_tonode_memory(void *" start ", size_t " size ", int " node );
+.br
+.BI "void numa_tonodemask_memory(void *" start ", size_t " size ", struct bitmask *" nodemask );
+.br
+.BI "void numa_setlocal_memory(void *" start ", size_t " size );
+.br
+.BI "void numa_police_memory(void *" start ", size_t " size );
+.br
+.BI "void numa_set_bind_policy(int " strict );
+.br
+.BI "void numa_set_strict(int " strict );
+.sp
+.\" should be undocumented ??
+.BI "int numa_distance(int " node1 ", int " node2 );
+.sp
+.BI "int numa_sched_getaffinity(pid_t " pid ", struct bitmask *" mask );
+.br
+.BI "int numa_sched_setaffinity(pid_t " pid ", struct bitmask *" mask );
+.br
+.BI "int numa_node_to_cpus(int " node ", struct bitmask *" mask ");
+.br
+.BI "int numa_node_of_cpu(int " cpu ");
+.sp
+.BI "struct bitmask *numa_allocate_cpumask();"
+.sp
+.BI "void numa_free_cpumask();"
+.br
+.BI "struct bitmask *numa_allocate_nodemask();"
+.sp
+.BI "void numa_free_nodemask();"
+.br
+.BI "struct bitmask *numa_bitmask_alloc(unsigned int " n ");
+.br
+.BI "struct bitmask *numa_bitmask_clearall(struct bitmask *" bmp );
+.br
+.BI "struct bitmask *numa_bitmask_clearbit(struct bitmask *" bmp ", unsigned int " n );
+.br
+.BI "int numa_bitmask_equal(const struct bitmask *" bmp1 ", const struct bitmask *" bmp2 );
+.br
+.BI "void numa_bitmask_free(struct bitmask *" bmp );
+.br
+.BI "int numa_bitmask_isbitset(const struct bitmask *" bmp ", unsigned int " n ");"
+.br
+.BI "unsigned int numa_bitmask_nbytes(struct bitmask *" bmp );
+.br
+.BI "struct bitmask *numa_bitmask_setall(struct bitmask *" bmp );
+.br
+.BI "struct bitmask *numa_bitmask_setbit(struct bitmask *" bmp ", unsigned int " n );
+.br
+.BI "void copy_bitmask_to_nodemask(struct bitmask *" bmp ", nodemask_t *" nodemask )
+.br
+.BI "void copy_nodemask_to_bitmask(nodemask_t *" nodemask ", struct bitmask *" bmp )
+.br
+.BI "void copy_bitmask_to_bitmask(struct bitmask *" bmpfrom ", struct bitmask *" bmpto )
+.br
+.BI "unsigned int numa_bitmask_weight(const struct bitmask *bmp )
+.sp
+.BI "int numa_move_pages(int " pid ", unsigned long " count ", void **" pages ", const int *" nodes ", int *" status ", int " flags );
+.br
+.BI "int numa_migrate_pages(int " pid ", struct bitmask *" fromnodes ", struct bitmask *" tonodes );
+.sp
+.BI "void numa_error(char *" where );
+.sp
+.BI "extern int " numa_exit_on_error ;
+.br
+.BI "extern int " numa_exit_on_warn ;
+.br
+.BI "void numa_warn(int " number ", char *" where ", ...);"
+.br
+
+.SH DESCRIPTION
+The
+.I libnuma
+library offers a simple programming interface to the
+NUMA (Non Uniform Memory Access)
+policy supported by the
+Linux kernel. On a NUMA architecture some
+memory areas have different latency or bandwidth than others.
+
+Available policies are
+page interleaving (i.e., allocate in a round-robin fashion from all,
+or a subset, of the nodes on the system),
+preferred node allocation (i.e., preferably allocate on a particular node),
+local allocation (i.e., allocate on the node on which
+the task is currently executing),
+or allocation only on specific nodes (i.e., allocate on
+some subset of the available nodes).
+It is also possible to bind tasks to specific nodes.
+
+Numa memory allocation policy may be specified as a per-task attribute,
+that is inherited by children tasks and processes, or as an attribute
+of a range of process virtual address space.
+Numa memory policies specified for a range of virtual address space are
+shared by all tasks in the process.
+Furthermore, memory policies specified for a range of a shared memory
+attached using
+.I shmat(2)
+or
+.I mmap(2)
+from shmfs/hugetlbfs are shared by all processes that attach to that region.
+Memory policies for shared disk backed file mappings are currently ignored.
+
+The default memory allocation policy for tasks and all memory range
+is local allocation.
+This assumes that no ancestor has installed a non-default policy.
+
+For setting a specific policy globally for all memory allocations
+in a process and its children it is easiest
+to start it with the
+.BR numactl (8)
+utility. For more finegrained policy inside an application this library
+can be used.
+
+All numa memory allocation policy only takes effect when a page is actually
+faulted into the address space of a process by accessing it. The
+.B numa_alloc_*
+functions take care of this automatically.
+
+A
+.I node
+is defined as an area where all memory has the same speed as seen from
+a particular CPU.
+A node can contain multiple CPUs.
+Caches are ignored for this definition.
+
+Most functions in this library are only concerned about numa nodes and
+their memory.
+The exceptions to this are:
+.IR numa_node_to_cpus (),
+.IR numa_node_of_cpu (),
+.IR numa_bind (),
+.IR numa_run_on_node (),
+.IR numa_run_on_node_mask (),
+.IR numa_run_on_node_mask_all (),
+and
+.IR numa_get_run_node_mask ().
+These functions deal with the CPUs associated with numa nodes.
+See the descriptions below for more information.
+
+Some of these functions accept or return a pointer to struct bitmask.
+A struct bitmask controls a bit map of arbitrary length containing a bit
+representation of nodes.  The predefined variable
+.I numa_all_nodes_ptr
+points to a bit mask that has all available nodes set;
+.I numa_no_nodes_ptr
+points to the empty set.
+
+Before any other calls in this library can be used
+.BR numa_available ()
+must be called. If it returns \-1, all other functions in this
+library are undefined.
+
+.BR numa_max_possible_node()
+returns the number of the highest possible node in a system.
+In other words, the size of a kernel type nodemask_t (in bits) minus 1.
+This number can be gotten by calling
+.BR numa_num_possible_nodes()
+and subtracting 1.
+
+.BR numa_num_possible_nodes()
+returns the size of kernel's node mask (kernel type nodemask_t).
+In other words, large enough to represent the maximum number of nodes that
+the kernel can handle. This will match the kernel's MAX_NUMNODES value.
+This count is derived from /proc/self/status, field Mems_allowed.
+
+.BR numa_max_node ()
+returns the highest node number available on the current system.
+(See the node numbers in /sys/devices/system/node/ ).  Also see
+.BR numa_num_configured_nodes().
+
+.BR numa_num_configured_nodes()
+returns the number of memory nodes in the system. This count
+includes any nodes that are currently disabled. This count is derived from
+the node numbers in /sys/devices/system/node. (Depends on the kernel being
+configured with /sys (CONFIG_SYSFS)).
+
+.BR numa_get_mems_allowed()
+returns the mask of nodes from which the process is allowed to allocate
+memory in it's current cpuset context.
+Any nodes that are not included in the returned bitmask will be ignored
+in any of the following libnuma memory policy calls.
+
+.BR numa_num_configured_cpus()
+returns the number of cpus in the system.  This count includes
+any cpus that are currently disabled. This count is derived from the cpu
+numbers in /sys/devices/system/cpu. If the kernel is configured without
+/sys (CONFIG_SYSFS=n) then it falls back to using the number of online cpus.
+
+.BR numa_all_nodes_ptr
+points to a bitmask that is allocated by the library with bits
+representing all nodes on which the calling task may allocate memory.
+This set may be up to all nodes on the system, or up to the nodes in
+the current cpuset.
+The bitmask is allocated by a call to
+.BR numa_allocate_nodemask()
+using size
+.BR numa_max_possible_node().
+The set of nodes to record is derived from /proc/self/status, field
+"Mems_allowed".  The user should not alter this bitmask.
+
+.BR numa_no_nodes_ptr
+points to a bitmask that is allocated by the library and left all
+zeroes.  The bitmask is allocated by a call to
+.BR numa_allocate_nodemask()
+using size
+.BR numa_max_possible_node().
+The user should not alter this bitmask.
+
+.BR numa_all_cpus_ptr
+points to a bitmask that is allocated by the library with bits
+representing all cpus on which the calling task may execute.
+This set may be up to all cpus on the system, or up to the cpus in
+the current cpuset.
+The bitmask is allocated by a call to
+.BR numa_allocate_cpumask()
+using size
+.BR numa_num_possible_cpus().
+The set of cpus to record is derived from /proc/self/status, field
+"Cpus_allowed".  The user should not alter this bitmask.
+
+.BR numa_num_task_cpus()
+returns the number of cpus that the calling task is allowed
+to use.  This count is derived from the map /proc/self/status, field
+"Cpus_allowed". Also see the bitmask
+.BR numa_all_cpus_ptr.
+
+.BR numa_num_task_nodes()
+returns the number of nodes on which the calling task is
+allowed to allocate memory.  This count is derived from the map
+/proc/self/status, field "Mems_allowed".
+Also see the bitmask
+.BR numa_all_nodes_ptr.
+
+.BR numa_parse_bitmap()
+parses
+.I line
+, which is a character string such as found in
+/sys/devices/system/node/nodeN/cpumap into a bitmask structure.
+The string contains the hexadecimal representation of a bit map.
+The bitmask may be allocated with
+.BR numa_allocate_cpumask().
+Returns  0 on success.  Returns -1 on failure.
+This function is probably of little use to a user application, but
+it is used by
+.I libnuma
+internally.
+
+.BR numa_parse_nodestring()
+parses a character string list of nodes into a bit mask.
+The bit mask is allocated by
+.BR numa_allocate_nodemask().
+The string is a comma-separated list of node numbers or node ranges.
+A leading ! can be used to indicate "not" this list (in other words, all
+nodes except this list), and a leading + can be used to indicate that the
+node numbers in the list are relative to the task's cpuset.  The string can
+be "all" to specify all (
+.BR numa_num_task_nodes()
+) nodes.  Node numbers are limited by the number in the system.  See
+.BR numa_max_node()
+and
+.BR numa_num_configured_nodes().
+.br
+Examples:  1-5,7,10   !4-5   +0-3
+.br
+If the string is of 0 length, bitmask
+.BR numa_no_nodes_ptr
+is returned.  Returns 0 if the string is invalid.
+
+.BR numa_parse_nodestring_all()
+is similar to
+.BR numa_parse_nodestring
+, but can parse all possible nodes, not only current nodeset.
+
+.BR numa_parse_cpustring()
+parses a character string list of cpus into a bit mask.
+The bit mask is allocated by
+.BR numa_allocate_cpumask().
+The string is a comma-separated list of cpu numbers or cpu ranges.
+A leading ! can be used to indicate "not" this list (in other words, all
+cpus except this list), and a leading + can be used to indicate that the cpu
+numbers in the list are relative to the task's cpuset.  The string can be
+"all" to specify all (
+.BR numa_num_task_cpus()
+) cpus.
+Cpu numbers are limited by the number in the system.  See
+.BR numa_num_task_cpus()
+and
+.BR numa_num_configured_cpus().
+.br
+Examples:  1-5,7,10   !4-5   +0-3
+.br
+Returns 0 if the string is invalid.
+
+.BR numa_parse_cpustring_all()
+is similar to
+.BR numa_parse_cpustring
+, but can parse all possible cpus, not only current cpuset.
+
+.BR numa_node_size ()
+returns the memory size of a node. If the argument
+.I freep
+is not NULL, it used to return the amount of free memory on the node.
+On error it returns \-1.
+
+.BR numa_node_size64 ()
+works the same as
+.BR numa_node_size ()
+except that it returns values as
+.I long long
+instead of
+.IR long .
+This is useful on 32-bit architectures with large nodes.
+
+.BR numa_preferred ()
+returns the preferred node of the current task.
+This is the node on which the kernel preferably
+allocates memory, unless some other policy overrides this.
+.\" TODO:   results are misleading for MPOL_PREFERRED and may
+.\" be incorrect for MPOL_BIND when Mel Gorman's twozonelist
+.\" patches go in.  In the latter case, we'd need to know the
+.\" order of the current node's zonelist to return the correct
+.\" node.  Need to tighten this up with the syscall results.
+
+.BR numa_set_preferred ()
+sets the preferred node for the current task to
+.IR node .
+The system will attempt to allocate memory from the preferred node,
+but will fall back to other nodes if no memory is available on the
+the preferred node.
+Passing a
+.I node
+of \-1 argument specifies local allocation and is equivalent to
+calling
+.BR numa_set_localalloc ().
+
+.BR numa_get_interleave_mask ()
+returns the current interleave mask if the task's memory allocation policy
+is page interleaved.
+Otherwise, this function returns an empty mask.
+
+.BR numa_set_interleave_mask ()
+sets the memory interleave mask for the current task to
+.IR nodemask .
+All new memory allocations
+are page interleaved over all nodes in the interleave mask. Interleaving
+can be turned off again by passing an empty mask
+.RI ( numa_no_nodes ).
+The page interleaving only occurs on the actual page fault that puts a new
+page into the current address space. It is also only a hint: the kernel
+will fall back to other nodes if no memory is available on the interleave
+target.
+.\" NOTE:  the following is not really the case.  this function sets the
+.\" task policy for all future allocations, including stack,  bss, ...
+.\" The functions specified in this sentence actually allocate a new memory
+.\" range [via mmap()].  This is quite a different thing.  Suggest we drop
+.\" this.
+.\" This is a low level
+.\" function, it may be more convenient to use the higher level functions like
+.\" .BR numa_alloc_interleaved ()
+.\" or
+.\" .BR numa_alloc_interleaved_subset ().
+
+.BR numa_interleave_memory ()
+interleaves
+.I size
+bytes of memory page by page from
+.I start
+on nodes specified in
+.IR nodemask .
+The
+.I size
+argument will be rounded up to a multiple of the system page size.
+If
+.I nodemask
+contains nodes that are externally denied to this process,
+this call will fail.
+This is a lower level function to interleave allocated but not yet faulted in
+memory. Not yet faulted in means the memory is allocated using
+.BR mmap (2)
+or
+.BR shmat (2),
+but has not been accessed by the current process yet. The memory is page
+interleaved to all nodes specified in
+.IR nodemask .
+Normally
+.BR numa_alloc_interleaved ()
+should be used for private memory instead, but this function is useful to
+handle shared memory areas. To be useful the memory area should be
+several megabytes at least (or tens of megabytes of hugetlbfs mappings)
+If the
+.BR numa_set_strict ()
+flag is true then the operation will cause a numa_error if there were already
+pages in the mapping that do not follow the policy.
+
+.BR numa_bind ()
+binds the current task and its children to the nodes
+specified in
+.IR nodemask .
+They will only run on the CPUs of the specified nodes and only be able to allocate
+memory from them.
+This function is equivalent to calling
+.\" FIXME checkme
+.\" This is the case.  --lts
+.I numa_run_on_node_mask(nodemask)
+followed by
+.IR numa_set_membind(nodemask) .
+If tasks should be bound to individual CPUs inside nodes
+consider using
+.I numa_node_to_cpus
+and the
+.I sched_setaffinity(2)
+syscall.
+
+.BR numa_set_localalloc ()
+sets the memory allocation policy for the calling task to
+local allocation.
+In this mode, the preferred node for memory allocation is
+effectively the node where the task is executing at the
+time of a page allocation.
+
+.BR numa_set_membind ()
+sets the memory allocation mask.
+The task will only allocate memory from the nodes set in
+.IR nodemask .
+Passing an empty
+.I nodemask
+or a
+.I nodemask
+that contains nodes other than those in the mask returned by
+.IR numa_get_mems_allowed ()
+will result in an error.
+
+.BR numa_get_membind ()
+returns the mask of nodes from which memory can currently be allocated.
+If the returned mask is equal to
+.IR numa_all_nodes ,
+then memory allocation is allowed from all nodes.
+
+.BR numa_alloc_onnode ()
+allocates memory on a specific node.
+The
+.I size
+argument will be rounded up to a multiple of the system page size.
+if the specified
+.I node
+is externally denied to this process, this call will fail.
+This function is relatively slow compared to the
+.IR malloc (3),
+family of functions.
+The memory must be freed
+with
+.BR numa_free ().
+On errors NULL is returned.
+
+.BR numa_alloc_local ()
+allocates
+.I size
+bytes of memory on the local node.
+The
+.I size
+argument will be rounded up to a multiple of the system page size.
+This function is relatively slow compared to the
+.IR malloc (3)
+family of functions.
+The memory must be freed
+with
+.BR numa_free ().
+On errors NULL is returned.
+
+.BR numa_alloc_interleaved ()
+allocates
+.I size
+bytes of memory page interleaved on all nodes. This function is relatively slow
+and should only be used for large areas consisting of multiple pages. The
+interleaving works at page level and will only show an effect when the
+area is large.
+The allocated memory must be freed with
+.BR numa_free ().
+On error, NULL is returned.
+
+.BR numa_alloc_interleaved_subset ()
+attempts to allocate
+.I size
+bytes of memory page interleaved on all nodes.
+The
+.I size
+argument will be rounded up to a multiple of the system page size.
+The nodes on which a process is allowed to allocate memory may
+be constrained externally.
+If this is the case, this function may fail.
+This function is relatively slow compare to
+.IR malloc (3),
+family of functions and should only be used for large areas consisting
+of multiple pages.
+The interleaving works at page level and will only show an effect when the
+area is large.
+The allocated memory must be freed with
+.BR numa_free ().
+On error, NULL is returned.
+
+.BR numa_alloc ()
+allocates
+.I size
+bytes of memory with the current NUMA policy.
+The
+.I size
+argument will be rounded up to a multiple of the system page size.
+This function is relatively slow compare to the
+.IR malloc (3)
+family of functions.
+The memory must be freed
+with
+.BR numa_free ().
+On errors NULL is returned.
+
+.BR numa_realloc ()
+changes the size of the memory area pointed to by
+.I old_addr
+from
+.I old_size
+to
+.I new_size.
+The memory area pointed to by
+.I old_addr
+must have been allocated with one of the
+.BR numa_alloc*
+functions.
+The
+.I new_size
+will be rounded up to a multiple of the system page size. The contents of the
+memory area will be unchanged to the minimum of the old and new sizes; newly
+allocated memory will be uninitialized. The memory policy (and node bindings)
+associated with the original memory area will be preserved in the resized
+area. For example, if the initial area was allocated with a call to
+.BR numa_alloc_onnode(),
+then the new pages (if the area is enlarged) will be allocated on the same node.
+However, if no memory policy was set for the original area, then
+.BR numa_realloc ()
+cannot guarantee that the new pages will be allocated on the same node. On
+success, the address of the resized area is returned (which might be different
+from that of the initial area), otherwise NULL is returned and
+.I errno
+is set to indicate the error. The pointer returned by
+.BR numa_realloc ()
+is suitable for passing to
+.BR numa_free ().
+
+
+.BR numa_free ()
+frees
+.I size
+bytes of memory starting at
+.IR start ,
+allocated by the
+.B numa_alloc_*
+functions above.
+The
+.I size
+argument will be rounded up to a multiple of the system page size.
+
+.BR numa_run_on_node ()
+runs the current task and its children
+on a specific node. They will not migrate to CPUs of
+other nodes until the node affinity is reset with a new call to
+.BR numa_run_on_node_mask ().
+Passing \-1
+permits the kernel to schedule on all nodes again.
+On success, 0 is returned; on error \-1 is returned, and
+.I errno
+is set to indicate the error.
+
+.BR numa_run_on_node_mask ()
+runs the current task and its children only on nodes specified in
+.IR nodemask .
+They will not migrate to CPUs of
+other nodes until the node affinity is reset with a new call to
+.BR numa_run_on_node_mask ()
+or
+.BR numa_run_on_node ().
+Passing
+.I numa_all_nodes
+permits the kernel to schedule on all nodes again.
+On success, 0 is returned; on error \-1 is returned, and
+.I errno
+is set to indicate the error.
+
+.BR numa_run_on_node_mask_all ()
+runs the current task and its children only on nodes specified in
+.IR nodemask
+like
+.I numa_run_on_node_mask
+but without any cpuset awareness.
+
+.BR numa_get_run_node_mask ()
+returns a mask of CPUs on which the current task is allowed to run.
+
+.BR numa_tonode_memory ()
+put memory on a specific node. The constraints described for
+.BR numa_interleave_memory ()
+apply here too.
+
+.BR numa_tonodemask_memory ()
+put memory on a specific set of nodes. The constraints described for
+.BR numa_interleave_memory ()
+apply here too.
+
+.BR numa_setlocal_memory ()
+locates memory on the current node. The constraints described for
+.BR numa_interleave_memory ()
+apply here too.
+
+.BR numa_police_memory ()
+locates memory with the current NUMA policy. The constraints described for
+.BR numa_interleave_memory ()
+apply here too.
+
+.BR numa_distance ()
+reports the distance in the machine topology between two nodes.
+The factors are a multiple of 10. It returns 0 when the distance
+cannot be determined. A node has distance 10 to itself.
+Reporting the distance requires a Linux
+kernel version of
+.I 2.6.10
+or newer.
+
+.BR numa_set_bind_policy ()
+specifies whether calls that bind memory to a specific node should
+use the preferred policy or a strict policy.
+The preferred policy allows the kernel
+to allocate memory on other nodes when there isn't enough free
+on the target node. strict will fail the allocation in that case.
+Setting the argument to specifies strict, 0 preferred.
+Note that specifying more than one node non strict may only use
+the first node in some kernel versions.
+
+.BR numa_set_strict ()
+sets a flag that says whether the functions allocating on specific
+nodes should use use a strict policy. Strict means the allocation
+will fail if the memory cannot be allocated on the target node.
+Default operation is to fall back to other nodes.
+This doesn't apply to interleave and default.
+
+.BR numa_get_interleave_node()
+is used by
+.I libnuma
+internally. It is probably not useful for user applications.
+It uses the MPOL_F_NODE flag of the get_mempolicy system call, which is
+not intended for application use (its operation may change or be removed
+altogether in future kernel versions). See get_mempolicy(2).
+
+.BR numa_pagesize()
+returns the number of bytes in page. This function is simply a fast
+alternative to repeated calls to the getpagesize system call.
+See getpagesize(2).
+
+.BR numa_sched_getaffinity()
+retrieves a bitmask of the cpus on which a task may run.  The task is
+specified by
+.I pid.
+Returns the return value of the sched_getaffinity
+system call.  See sched_getaffinity(2).
+The bitmask must be at least the size of the kernel's cpu mask structure. Use
+.BR numa_allocate_cpumask()
+to allocate it.
+Test the bits in the mask by calling
+.BR numa_bitmask_isbitset().
+
+.BR numa_sched_setaffinity()
+sets a task's allowed cpu's to those cpu's specified in
+.I mask.
+The task is specified by
+.I pid.
+Returns the return value of the sched_setaffinity system call.
+See sched_setaffinity(2).  You may allocate the bitmask with
+.BR numa_allocate_cpumask().
+Or the bitmask may be smaller than the kernel's cpu mask structure. For
+example, call
+.BR numa_bitmask_alloc()
+using a maximum number of cpus from
+.BR numa_num_configured_cpus().
+Set the bits in the mask by calling
+.BR numa_bitmask_setbit().
+
+.BR numa_node_to_cpus ()
+converts a node number to a bitmask of CPUs. The user must pass a bitmask
+structure with a mask buffer long enough to represent all possible cpu's.
+Use numa_allocate_cpumask() to create it.  If the bitmask is not long enough
+.I errno
+will be set to
+.I ERANGE
+and \-1 returned. On success 0 is returned.
+
+.BR numa_node_of_cpu ()
+returns the node that a cpu belongs to. If the user supplies an invalid cpu
+.I errno
+will be set to
+.I EINVAL
+and \-1 will be returned.
+
+.BR numa_allocate_cpumask
+() returns a bitmask of a size equal to the kernel's cpu
+mask (kernel type cpumask_t).  In other words, large enough to represent
+NR_CPUS cpus.  This number of cpus can be gotten by calling
+.BR numa_num_possible_cpus().
+The bitmask is zero-filled.
+
+.BR numa_free_cpumask
+frees a cpumask previously allocate by
+.I numa_allocate_cpumask.
+
+.BR numa_allocate_nodemask()
+returns a bitmask of a size equal to the kernel's node
+mask (kernel type nodemask_t).  In other words, large enough to represent
+MAX_NUMNODES nodes.  This number of nodes can be gotten by calling
+.BR numa_num_possible_nodes().
+The bitmask is zero-filled.
+
+.BR numa_free_nodemask()
+frees a nodemask previous allocated by
+.I numa_allocate_nodemask().
+
+.BR numa_bitmask_alloc()
+allocates a bitmask structure and its associated bit mask.
+The memory allocated for the bit mask contains enough words (type unsigned
+long) to contain
+.I n
+bits.  The bit mask is zero-filled.  The bitmask
+structure points to the bit mask and contains the
+.I n
+value.
+
+.BR numa_bitmask_clearall()
+sets all bits in the bit mask to 0.  The bitmask structure
+points to the bit mask and contains its size (
+.I bmp
+->size).  The value of
+.I bmp
+is always returned.  Note that
+.BR numa_bitmask_alloc()
+creates a zero-filled bit mask.
+
+.BR numa_bitmask_clearbit()
+sets a specified bit in a bit mask to 0.  Nothing is done if
+the
+.I n
+value is greater than the size of the bitmask (and no error is
+returned). The value of
+.I bmp
+is always returned.
+
+.BR numa_bitmask_equal()
+returns 1 if two bitmasks are equal.  It returns 0 if they
+are not equal.  If the bitmask structures control bit masks of different
+sizes, the "missing" trailing bits of the smaller bit mask are considered
+to be 0.
+
+.BR numa_bitmask_free()
+deallocates the memory of both the bitmask structure pointed
+to by
+.I bmp
+and the bit mask.  It is an error to attempt to free this bitmask twice.
+
+.BR numa_bitmask_isbitset()
+returns the value of a specified bit in a bit mask.
+If the
+.I n
+value is greater than the size of the bit map, 0 is returned.
+
+.BR numa_bitmask_nbytes()
+returns the size (in bytes) of the bit mask controlled by
+.I bmp.
+The bit masks are always full words (type unsigned long), and the returned
+size is the actual size of all those words.
+
+.BR numa_bitmask_setall()
+sets all bits in the bit mask to 1.  The bitmask structure
+points to the bit mask and contains its size (
+.I bmp
+->size).
+The value of
+.I bmp
+is always returned.
+
+.BR numa_bitmask_setbit()
+sets a specified bit in a bit mask to 1.  Nothing is done if
+.I n
+is greater than the size of the bitmask (and no error is
+returned). The value of
+.I bmp
+is always returned.
+
+.BR copy_bitmask_to_nodemask()
+copies the body (the bit map itself) of the bitmask structure pointed
+to by
+.I bmp
+to the nodemask_t structure pointed to by the
+.I nodemask
+pointer. If the two areas differ in size, the copy is truncated to the size
+of the receiving field or zero-filled.
+
+.BR copy_nodemask_to_bitmask()
+copies the nodemask_t structure pointed to by the
+.I nodemask
+pointer to the body (the bit map itself) of the bitmask structure pointed
+to by the
+.I bmp
+pointer. If the two areas differ in size, the copy is truncated to the size
+of the receiving field or zero-filled.
+
+.BR copy_bitmask_to_bitmask()
+copies the body (the bit map itself) of the bitmask structure pointed
+to by the
+.I bmpfrom
+pointer to the body of the bitmask structure pointed to by the
+.I bmpto
+pointer. If the two areas differ in size, the copy is truncated to the size
+of the receiving field or zero-filled.
+
+.BR numa_bitmask_weight()
+returns a count of the bits that are set in the body of the bitmask pointed
+to by the
+.I bmp
+argument.
+
+.br
+.BR numa_move_pages()
+moves a list of pages in the address space of the currently
+executing or current process.
+It simply uses the move_pages system call.
+.br
+.I pid
+- ID of task.  If not valid, use the current task.
+.br
+.I count
+- Number of pages.
+.br
+.I pages
+- List of pages to move.
+.br
+.I nodes
+- List of nodes to which pages can be moved.
+.br
+.I status
+- Field to which status is to be returned.
+.br
+.I flags
+- MPOL_MF_MOVE or MPOL_MF_MOVE_ALL
+.br
+See move_pages(2).
+
+.BR numa_migrate_pages()
+simply uses the migrate_pages system call to cause the pages of the calling
+task, or a specified task, to be migated from one set of nodes to another.
+See migrate_pages(2).
+The bit masks representing the nodes should be allocated with
+.BR numa_allocate_nodemask()
+, or with
+.BR numa_bitmask_alloc()
+using an
+.I n
+value returned from
+.BR numa_num_possible_nodes().
+A task's current node set can be gotten by calling
+.BR numa_get_membind().
+Bits in the
+.I tonodes
+mask can be set by calls to
+.BR numa_bitmask_setbit().
+
+.BR numa_error ()
+is a
+.I libnuma
+internal function that can be overridden by the
+user program.
+This function is called with a
+.I char *
+argument when a
+.I libnuma
+function fails.
+Overriding the library internal definition
+makes it possible to specify a different error handling strategy
+when a
+.I libnuma
+function fails. It does not affect
+.BR numa_available ().
+The
+.BR numa_error ()
+function defined in
+.I libnuma
+prints an error on
+.I stderr
+and terminates
+the program if
+.I numa_exit_on_error
+is set to a non-zero value.
+The default value of
+.I numa_exit_on_error
+is zero.
+
+.BR numa_warn ()
+is a
+.I libnuma
+internal function that can be also overridden
+by the user program.
+It is called to warn the user when a
+.I libnuma
+function encounters a non-fatal error.
+The default implementation
+prints a warning to
+.IR stderr .
+The first argument is a unique
+number identifying each warning. After that there is a
+.BR printf (3)-style
+format string and a variable number of arguments.
+.I numa_warn
+exits the program when
+.I numa_exit_on_warn
+is set to a non-zero value.
+The default value of
+.I numa_exit_on_warn
+is zero.
+
+.SH Compatibility with libnuma version 1
+Binaries that were compiled for libnuma version 1 need not be re-compiled
+to run with libnuma version 2.
+.br
+Source codes written for libnuma version 1 may be re-compiled without
+change with version 2 installed. To do so, in the code's Makefile add
+this option to CFLAGS:  -DNUMA_VERSION1_COMPATIBILITY
+
+.SH THREAD SAFETY
+.I numa_set_bind_policy
+and
+.I numa_exit_on_error
+are process global. The other calls are thread safe.
+
+.SH COPYRIGHT
+Copyright 2002, 2004, 2007, 2008 Andi Kleen, SuSE Labs.
+.I libnuma
+is under the GNU Lesser General Public License, v2.1.
+
+.SH SEE ALSO
+.BR get_mempolicy (2),
+.BR set_mempolicy (2),
+.BR getpagesize (2),
+.BR mbind (2),
+.BR mmap (2),
+.BR shmat (2),
+.BR numactl (8),
+.BR sched_getaffinity (2)
+.BR sched_setaffinity (2)
+.BR move_pages (2)
+.BR migrate_pages (2)
diff --git a/numa.h b/numa.h
new file mode 100644
index 0000000..6ab3121
--- /dev/null
+++ b/numa.h
@@ -0,0 +1,511 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+
+   libnuma 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; version
+   2.1.
+
+   libnuma 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 find a copy of v2.1 of the GNU Lesser General Public License
+   somewhere on your Linux system; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#ifndef _NUMA_H
+#define _NUMA_H 1
+
+/* allow an application to test for the current programming interface: */
+#define LIBNUMA_API_VERSION 2
+
+/* Simple NUMA policy library */
+
+#include <stddef.h>
+#include <string.h>
+#include <sys/types.h>
+#include <stdlib.h>
+
+#if defined(__x86_64__) || defined(__i386__)
+#define NUMA_NUM_NODES  128
+#else
+#define NUMA_NUM_NODES  2048
+#endif
+
+#ifdef GOOGLE3_LIBNUMA_BUILD
+/* Google-local:
+   the version definitions below make sense when libnuma is built into
+   a shared library. In google3 builds that doesn't happen.
+
+   The version definitions are mostly harmless when libnuma.a is linked
+   into an executable.
+
+   But when libnuma.a is linked into a shared library (such as when there
+   is a dependency of some SWIG code on //third_party/libnuma:numa,
+   the version definitions cause actual errors:
+   http://sponge/2287a293-35c2-4a9a-80e5-1f0735320f02).  */
+
+/* Don't provide backward symbol at all:  */
+#define backward_symver(orig,new) /**/
+
+/* Provide unversioned alias: */
+#define symver(orig,new) extern __typeof (orig) new __attribute((alias(#orig), visibility("default")))
+
+#else  /* GOOGLE3_LIBNUMA_BUILD */
+
+#define backward_symver(orig,new) \
+  __asm__(".symver " #orig "," #new "@libnuma_1.1")
+#define symver(orig,new) __asm__(".symver " #orig "," #new "@@libnuma_1.2")
+
+#endif  /* GOOGLE3_LIBNUMA_BUILD */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+        unsigned long n[NUMA_NUM_NODES/(sizeof(unsigned long)*8)];
+} nodemask_t;
+
+struct bitmask {
+	unsigned long size; /* number of bits in the map */
+	unsigned long *maskp;
+};
+
+/* operations on struct bitmask */
+int numa_bitmask_isbitset(const struct bitmask *, unsigned int);
+struct bitmask *numa_bitmask_setall(struct bitmask *);
+struct bitmask *numa_bitmask_clearall(struct bitmask *);
+struct bitmask *numa_bitmask_setbit(struct bitmask *, unsigned int);
+struct bitmask *numa_bitmask_clearbit(struct bitmask *, unsigned int);
+unsigned int numa_bitmask_nbytes(struct bitmask *);
+unsigned int numa_bitmask_weight(const struct bitmask *);
+struct bitmask *numa_bitmask_alloc(unsigned int);
+void numa_bitmask_free(struct bitmask *);
+int numa_bitmask_equal(const struct bitmask *, const struct bitmask *);
+void copy_nodemask_to_bitmask(nodemask_t *, struct bitmask *);
+void copy_bitmask_to_nodemask(struct bitmask *, nodemask_t *);
+void copy_bitmask_to_bitmask(struct bitmask *, struct bitmask *);
+
+/* compatibility for codes that used them: */
+
+static inline void nodemask_zero(nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	numa_bitmask_clearall(&tmp);
+}
+
+static inline void nodemask_zero_compat(nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	numa_bitmask_clearall(&tmp);
+}
+
+static inline void nodemask_set_compat(nodemask_t *mask, int node)
+{
+	mask->n[node / (8*sizeof(unsigned long))] |=
+		(1UL<<(node%(8*sizeof(unsigned long))));
+}
+
+static inline void nodemask_clr_compat(nodemask_t *mask, int node)
+{
+	mask->n[node / (8*sizeof(unsigned long))] &=
+		~(1UL<<(node%(8*sizeof(unsigned long))));
+}
+
+static inline int nodemask_isset_compat(const nodemask_t *mask, int node)
+{
+	if ((unsigned)node >= NUMA_NUM_NODES)
+		return 0;
+	if (mask->n[node / (8*sizeof(unsigned long))] &
+		(1UL<<(node%(8*sizeof(unsigned long)))))
+		return 1;
+	return 0;
+}
+
+static inline int nodemask_equal(const nodemask_t *a, const nodemask_t *b)
+{
+	struct bitmask tmp_a, tmp_b;
+
+	tmp_a.maskp = (unsigned long *)a;
+	tmp_a.size = sizeof(nodemask_t) * 8;
+
+	tmp_b.maskp = (unsigned long *)b;
+	tmp_b.size = sizeof(nodemask_t) * 8;
+
+	return numa_bitmask_equal(&tmp_a, &tmp_b);
+}
+
+static inline int nodemask_equal_compat(const nodemask_t *a, const nodemask_t *b)
+{
+	struct bitmask tmp_a, tmp_b;
+
+	tmp_a.maskp = (unsigned long *)a;
+	tmp_a.size = sizeof(nodemask_t) * 8;
+
+	tmp_b.maskp = (unsigned long *)b;
+	tmp_b.size = sizeof(nodemask_t) * 8;
+
+	return numa_bitmask_equal(&tmp_a, &tmp_b);
+}
+
+/* numa_init must be called before any other operations.
+   If libnuma is linked dynamically, it will be called automatically. */
+void numa_init(void);
+
+/* NUMA support available. If this returns a negative value all other function
+   in this library are undefined. */
+int numa_available(void);
+
+/* Basic NUMA state */
+
+/* Get max available node */
+int numa_max_node(void);
+int numa_max_possible_node(void);
+/* Return preferred node */
+int numa_preferred(void);
+
+/* Return node size and free memory */
+long long numa_node_size64(int node, long long *freep);
+long numa_node_size(int node, long *freep);
+
+int numa_pagesize(void);
+
+/* Set with all nodes from which the calling process may allocate memory.
+   Only valid after numa_available. */
+extern struct bitmask *numa_all_nodes_ptr;
+
+/* Set with all nodes the kernel has exposed to userspace */
+extern struct bitmask *numa_nodes_ptr;
+
+/* For source compatibility */
+extern nodemask_t numa_all_nodes;
+
+/* Set with all cpus. */
+extern struct bitmask *numa_all_cpus_ptr;
+
+/* Set with no nodes */
+extern struct bitmask *numa_no_nodes_ptr;
+
+/* Source compatibility */
+extern nodemask_t numa_no_nodes;
+
+/* Only run and allocate memory from a specific set of nodes. */
+void numa_bind(struct bitmask *nodes);
+
+/* Set the NUMA node interleaving mask. 0 to turn off interleaving */
+void numa_set_interleave_mask(struct bitmask *nodemask);
+
+/* Return the current interleaving mask */
+struct bitmask *numa_get_interleave_mask(void);
+
+/* allocate a bitmask big enough for all nodes */
+struct bitmask *numa_allocate_nodemask(void);
+
+static inline void numa_free_nodemask(struct bitmask *b)
+{
+	numa_bitmask_free(b);
+}
+
+/* Some node to preferably allocate memory from for task. */
+void numa_set_preferred(int node);
+
+/* Set local memory allocation policy for task */
+void numa_set_localalloc(void);
+
+/* Only allocate memory from the nodes set in mask. 0 to turn off */
+void numa_set_membind(struct bitmask *nodemask);
+
+/* Return current membind */
+struct bitmask *numa_get_membind(void);
+
+/* Return allowed memories [nodes] */
+struct bitmask *numa_get_mems_allowed(void);
+
+int numa_get_interleave_node(void);
+
+/* NUMA memory allocation. These functions always round to page size
+   and are relatively slow. */
+
+/* Alloc memory page interleaved on nodes in mask */
+void *numa_alloc_interleaved_subset(size_t size, struct bitmask *nodemask);
+/* Alloc memory page interleaved on all nodes. */
+void *numa_alloc_interleaved(size_t size);
+/* Alloc memory located on node */
+void *numa_alloc_onnode(size_t size, int node);
+/* Alloc memory on local node */
+void *numa_alloc_local(size_t size);
+/* Allocation with current policy */
+void *numa_alloc(size_t size);
+/* Change the size of a memory area preserving the memory policy */
+void *numa_realloc(void *old_addr, size_t old_size, size_t new_size);
+/* Free memory allocated by the functions above */
+void numa_free(void *mem, size_t size);
+
+/* Low level functions, primarily for shared memory. All memory
+   processed by these must not be touched yet */
+
+/* Interleave an memory area. */
+void numa_interleave_memory(void *mem, size_t size, struct bitmask *mask);
+
+/* Allocate a memory area on a specific node. */
+void numa_tonode_memory(void *start, size_t size, int node);
+
+/* Allocate memory on a mask of nodes. */
+void numa_tonodemask_memory(void *mem, size_t size, struct bitmask *mask);
+
+/* Allocate a memory area on the current node. */
+void numa_setlocal_memory(void *start, size_t size);
+
+/* Allocate memory area with current memory policy */
+void numa_police_memory(void *start, size_t size);
+
+/* Run current task only on nodes in mask */
+int numa_run_on_node_mask(struct bitmask *mask);
+/* Run current task on nodes in mask without any cpuset awareness */
+int numa_run_on_node_mask_all(struct bitmask *mask);
+/* Run current task only on node */
+int numa_run_on_node(int node);
+/* Return current mask of nodes the task can run on */
+struct bitmask * numa_get_run_node_mask(void);
+
+/* When strict fail allocation when memory cannot be allocated in target node(s). */
+void numa_set_bind_policy(int strict);
+
+/* Fail when existing memory has incompatible policy */
+void numa_set_strict(int flag);
+
+/* maximum nodes (size of kernel nodemask_t) */
+int numa_num_possible_nodes();
+
+/* maximum cpus (size of kernel cpumask_t) */
+int numa_num_possible_cpus();
+
+/* nodes in the system */
+int numa_num_configured_nodes();
+
+/* maximum cpus */
+int numa_num_configured_cpus();
+
+/* maximum cpus allowed to current task */
+int numa_num_task_cpus();
+int numa_num_thread_cpus(); /* backward compatibility */
+
+/* maximum nodes allowed to current task */
+int numa_num_task_nodes();
+int numa_num_thread_nodes(); /* backward compatibility */
+
+/* allocate a bitmask the size of the kernel cpumask_t */
+struct bitmask *numa_allocate_cpumask();
+
+static inline void numa_free_cpumask(struct bitmask *b)
+{
+	numa_bitmask_free(b);
+}
+
+/* Convert node to CPU mask. -1/errno on failure, otherwise 0. */
+int numa_node_to_cpus(int, struct bitmask *);
+
+/* report the node of the specified cpu. -1/errno on invalid cpu. */
+int numa_node_of_cpu(int cpu);
+
+/* Report distance of node1 from node2. 0 on error.*/
+int numa_distance(int node1, int node2);
+
+/* Error handling. */
+/* This is an internal function in libnuma that can be overwritten by an user
+   program. Default is to print an error to stderr and exit if numa_exit_on_error
+   is true. */
+void numa_error(const char *where);
+
+/* When true exit the program when a NUMA system call (except numa_available)
+   fails */
+extern int numa_exit_on_error;
+/* Warning function. Can also be overwritten. Default is to print on stderr
+   once. */
+void numa_warn(int num, const char *fmt, ...);
+
+/* When true exit the program on a numa_warn() call */
+extern int numa_exit_on_warn;
+
+int numa_migrate_pages(int pid, struct bitmask *from, struct bitmask *to);
+
+int numa_move_pages(int pid, unsigned long count, void **pages,
+		const int *nodes, int *status, int flags);
+
+int numa_sched_getaffinity(pid_t, struct bitmask *);
+int numa_sched_setaffinity(pid_t, struct bitmask *);
+
+/* Convert an ascii list of nodes to a bitmask */
+struct bitmask *numa_parse_nodestring(const char *);
+
+/* Convert an ascii list of nodes to a bitmask without current nodeset
+ * dependency */
+struct bitmask *numa_parse_nodestring_all(const char *);
+
+/* Convert an ascii list of cpu to a bitmask */
+struct bitmask *numa_parse_cpustring(const char *);
+
+/* Convert an ascii list of cpu to a bitmask without current taskset
+ * dependency */
+struct bitmask *numa_parse_cpustring_all(const char *);
+
+/*
+ * The following functions are for source code compatibility
+ * with releases prior to version 2.
+ * Such codes should be compiled with NUMA_VERSION1_COMPATIBILITY defined.
+ */
+
+static inline void numa_set_interleave_mask_compat(nodemask_t *nodemask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)nodemask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	numa_set_interleave_mask(&tmp);
+}
+
+static inline nodemask_t numa_get_interleave_mask_compat()
+{
+	struct bitmask *tp;
+	nodemask_t mask;
+
+	tp = numa_get_interleave_mask();
+	copy_bitmask_to_nodemask(tp, &mask);
+	numa_bitmask_free(tp);
+	return mask;
+}
+
+static inline void numa_bind_compat(nodemask_t *mask)
+{
+	struct bitmask *tp;
+
+	tp = numa_allocate_nodemask();
+	copy_nodemask_to_bitmask(mask, tp);
+	numa_bind(tp);
+	numa_bitmask_free(tp);
+}
+
+static inline void numa_set_membind_compat(nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	numa_set_membind(&tmp);
+}
+
+static inline nodemask_t numa_get_membind_compat()
+{
+	struct bitmask *tp;
+	nodemask_t mask;
+
+	tp = numa_get_membind();
+	copy_bitmask_to_nodemask(tp, &mask);
+	numa_bitmask_free(tp);
+	return mask;
+}
+
+static inline void *numa_alloc_interleaved_subset_compat(size_t size,
+					const nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	return numa_alloc_interleaved_subset(size, &tmp);
+}
+
+static inline int numa_run_on_node_mask_compat(const nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	return numa_run_on_node_mask(&tmp);
+}
+
+static inline nodemask_t numa_get_run_node_mask_compat()
+{
+	struct bitmask *tp;
+	nodemask_t mask;
+
+	tp = numa_get_run_node_mask();
+	copy_bitmask_to_nodemask(tp, &mask);
+	numa_bitmask_free(tp);
+	return mask;
+}
+
+static inline void numa_interleave_memory_compat(void *mem, size_t size,
+						const nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	numa_interleave_memory(mem, size, &tmp);
+}
+
+static inline void numa_tonodemask_memory_compat(void *mem, size_t size,
+						const nodemask_t *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = sizeof(nodemask_t) * 8;
+	numa_tonodemask_memory(mem, size, &tmp);
+}
+
+static inline int numa_sched_getaffinity_compat(pid_t pid, unsigned len,
+						unsigned long *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = len * 8;
+	return numa_sched_getaffinity(pid, &tmp);
+}
+
+static inline int numa_sched_setaffinity_compat(pid_t pid, unsigned len,
+						unsigned long *mask)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)mask;
+	tmp.size = len * 8;
+	return numa_sched_setaffinity(pid, &tmp);
+}
+
+static inline int numa_node_to_cpus_compat(int node, unsigned long *buffer,
+							int buffer_len)
+{
+	struct bitmask tmp;
+
+	tmp.maskp = (unsigned long *)buffer;
+	tmp.size = buffer_len * 8;
+	return numa_node_to_cpus(node, &tmp);
+}
+
+/* end of version 1 compatibility functions */
+
+/*
+ * To compile an application that uses libnuma version 1:
+ *   add -DNUMA_VERSION1_COMPATIBILITY to your Makefile's CFLAGS
+ */
+#ifdef NUMA_VERSION1_COMPATIBILITY
+#include <numacompat1.h>
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/numacompat1.h b/numacompat1.h
new file mode 100644
index 0000000..d5af142
--- /dev/null
+++ b/numacompat1.h
@@ -0,0 +1,18 @@
+#define numa_set_interleave_mask(m)     numa_set_interleave_mask_compat(m)
+#define numa_get_interleave_mask()      numa_get_interleave_mask_compat()
+#define numa_bind(m)                    numa_bind_compat(m)
+#define numa_get_membind(m)             numa_get_membind_compat(m)
+#define numa_set_membind(m)             numa_set_membind_compat(m)
+#define numa_alloc_interleaved_subset(s,m) numa_alloc_interleaved_subset_compat(s,m)
+#define numa_run_on_node_mask(m)        numa_run_on_node_mask_compat(m)
+#define numa_get_run_node_mask()        numa_get_run_node_mask_compat()
+#define numa_interleave_memory(st,si,m) numa_interleave_memory_compat(st,si,m)
+#define numa_tonodemask_memory(st,si,m) numa_tonodemask_memory_compat(st,si,m)
+#define numa_sched_getaffinity(p,l,m)   numa_sched_getaffinity_compat(p,l,m)
+#define numa_sched_setaffinity(p,l,m)   numa_sched_setaffinity_compat(p,l,m)
+#define numa_node_to_cpus(n,b,bl)       numa_node_to_cpus_compat(n,b,bl)
+#define nodemask_zero(m)		nodemask_zero_compat(m)
+#define nodemask_set(m, n)		nodemask_set_compat(m, n)
+#define nodemask_clr(m, n)		nodemask_clr_compat(m, n)
+#define nodemask_isset(m, n)		nodemask_isset_compat(m, n)
+#define nodemask_equal(a, b)		nodemask_equal_compat(a, b)
diff --git a/numactl.8 b/numactl.8
new file mode 100644
index 0000000..7a001c0
--- /dev/null
+++ b/numactl.8
@@ -0,0 +1,354 @@
+.\" t
+.\" Copyright 2003,2004 Andi Kleen, SuSE Labs.
+.\"
+.\" Permission is granted to make and distribute verbatim copies of this
+.\" manual provided the copyright notice and this permission notice are
+.\" preserved on all copies.
+.\"
+.\" Permission is granted to copy and distribute modified versions of this
+.\" manual under the conditions for verbatim copying, provided that the
+.\" entire resulting derived work is distributed under the terms of a
+.\" permission notice identical to this one.
+.\" 
+.\" Since the Linux kernel and libraries are constantly changing, this
+.\" manual page may be incorrect or out-of-date.  The author(s) assume no
+.\" responsibility for errors or omissions, or for damages resulting from
+.\" the use of the information contained herein.  
+.\" 
+.\" Formatted or processed versions of this manual, if unaccompanied by
+.\" the source, must acknowledge the copyright and authors of this work.
+.TH NUMACTL 8 "Mar 2004" "SuSE Labs" "Linux Administrator's Manual"
+.SH NAME
+numactl \- Control NUMA policy for processes or shared memory 
+.SH SYNOPSIS
+.B numactl
+[
+.B \-\-all
+] [
+.B \-\-interleave nodes
+] [
+.B \-\-preferred node 
+] [
+.B \-\-membind nodes
+] [ 
+.B \-\-cpunodebind nodes
+] [
+.B \-\-physcpubind cpus
+] [
+.B \-\-localalloc
+] [\-\-] command {arguments ...}
+.br
+.B numactl \-\-show
+.br
+.B numactl \-\-hardware
+.br
+.B numactl 
+[
+.B \-\-huge
+] [
+.B \-\-offset offset
+] [
+.B \-\-shmmode shmmode
+] [
+.B \-\-length length
+] [
+.B \-\-strict
+]
+.br
+[
+.B \-\-shmid id
+]
+.B \-\-shm shmkeyfile
+|
+.B \-\-file tmpfsfile
+.br
+[
+.B \-\-touch
+] [
+.B \-\-dump
+] [
+.B \-\-dump-nodes
+]
+memory policy
+.SH DESCRIPTION
+.B numactl
+runs processes with a specific NUMA scheduling or memory placement policy.
+The policy is set for command and inherited by all of its children.
+In addition it can set persistent policy for shared memory segments or files.
+.PP
+Use -- before command if using command options that could be confused
+with numactl options.
+.PP
+.I nodes
+may be specified as N,N,N or  N-N or N,N-N or  N-N,N-N and so forth.
+Relative
+.I nodes
+may be specifed as +N,N,N or  +N-N or +N,N-N and so forth. The + indicates that
+the node numbers are relative to the process' set of allowed nodes in its
+current cpuset.
+A !N-N notation indicates the inverse of N-N, in other words all nodes
+except N-N.  If used with + notation, specify !+N-N. When
+.I same
+is specified the previous nodemask specified on the command line is used.
+all means all nodes in the current cpuset.
+.PP
+Instead of a number a node can also be:
+.TS
+tab(|);
+l l.
+netdev:DEV|The node connected to network device DEV.
+file:PATH |The node the block device of PATH.
+ip:HOST   |The node of the network device of HOST
+block:PATH|The node of block device PATH
+pci:[seg:]bus:dev[:func]|The node of a PCI device.
+.TE
+
+Note that block resolves the kernel block device names only
+for udev names in /dev use
+.I file:
+.TP
+Policy settings are:
+.TP
+.B \-\-all, \-a
+Unset default cpuset awareness, so user can use all possible CPUs/nodes
+for following policy settings.
+.TP
+.B \-\-interleave=nodes, \-i nodes
+Set a memory interleave policy. Memory will be allocated using round robin
+on
+.I nodes.
+When memory cannot be allocated on the current interleave target fall back
+to other nodes.
+Multiple nodes may be specified on --interleave, --membind and --cpunodebind.
+.TP
+.B \-\-membind=nodes, \-m nodes
+Only allocate memory from nodes.  Allocation will fail when there
+is not enough memory available on these nodes.
+.I nodes
+may be specified as noted above.
+.TP
+.B \-\-cpunodebind=nodes, \-N nodes
+Only execute
+.I command
+on the CPUs of
+.I nodes. 
+Note that nodes may consist of multiple CPUs.
+.I nodes
+may be specified as noted above.
+.TP
+.B \-\-physcpubind=cpus, \-C cpus
+Only execute
+.I process
+on
+.I cpus.
+This accepts cpu numbers as shown in the
+.I processor
+fields of 
+.I /proc/cpuinfo,
+or relative cpus as in relative to the current cpuset.
+You may specify "all", which means all cpus in the current cpuset.
+Physical
+.I cpus
+may be specified as N,N,N or  N-N or N,N-N or  N-N,N-N and so forth.
+Relative
+.I cpus
+may be specifed as +N,N,N or  +N-N or +N,N-N and so forth. The + indicates that
+the cpu numbers are relative to the process' set of allowed cpus in its
+current cpuset.
+A !N-N notation indicates the inverse of N-N, in other words all cpus
+except N-N.  If used with + notation, specify !+N-N.
+.TP
+.B \-\-localalloc, \-l 
+Always allocate on the current node.
+.TP
+.B \-\-preferred=node
+Preferably allocate memory on 
+.I node,
+but if memory cannot be allocated there fall back to other nodes.
+This option takes only a single node number.
+Relative notation may be used.
+.TP
+.B \-\-show, \-s
+Show NUMA policy settings of the current process. 
+.TP
+.B \-\-hardware, \-H
+Show inventory of available nodes on the system.
+.TP 0
+Numactl can set up policy for a SYSV shared memory segment or a file in shmfs/hugetlbfs.
+ 
+This policy is persistent and will be used by
+all mappings from that shared memory. The order of options matters here.
+The specification must at least include either of 
+.I \-\-shm, 
+.I \-\-shmid, 
+.I \-\-file
+to specify the shared memory segment or file and a memory policy like described 
+above (
+.I \-\-interleave, 
+.I \-\-localalloc, 
+.I \-\-preferred,
+.I \-\-membind
+).
+.TP
+.B \-\-huge
+When creating a SYSV shared memory segment use huge pages.
+Only valid before \-\-shmid or \-\-shm
+.TP 
+.B \-\-offset
+Specify offset into the shared memory segment. Default 0. 
+Valid units are 
+.I m
+(for MB), 
+.I g 
+(for GB), 
+.I k 
+(for KB),
+otherwise it specifies bytes.
+.TP
+.B \-\-strict
+Give an error when a page in the policied area in the shared memory
+segment already was faulted in with a conflicting policy. Default
+is to silently ignore this.
+.TP
+.B \-\-shmmode shmmode
+Only valid before \-\-shmid or \-\-shm
+When creating a shared memory segment set it to numeric mode 
+.I shmmode.
+.TP
+.B \-\-length length
+Apply policy to 
+.I length 
+range in the shared memory segment or make 
+the segment length long
+Default is to use the remaining length 
+Required when a shared memory segment is created and specifies the length
+of the new segment then. Valid units are 
+.I m
+(for MB), 
+.I g 
+(for GB), 
+.I k 
+(for KB),
+otherwise it specifies bytes.
+.TP
+.B \-\-shmid id
+Create or use an shared memory segment with numeric ID 
+.I id
+.TP 
+.B \-\-shm shmkeyfile
+Create or use an shared memory segment, with the ID generated
+using 
+.I ftok(3) 
+from shmkeyfile
+.TP
+.B \-\-file tmpfsfile
+Set policy for a file in tmpfs or hugetlbfs
+.TP
+.B \-\-touch
+Touch pages to enforce policy early. Default is to not touch them, the policy
+is applied when an applications maps and accesses a page.
+.TP
+.B \-\-dump
+Dump policy in the specified range.
+.TP
+.B \-\-dump-nodes
+Dump all nodes of the specific range (very verbose!)
+.TP
+Valid node specifiers
+.TS
+tab(:);
+l l. 
+all:All nodes
+number:Node number
+number1{,number2}:Node number1 and Node number2
+number1-number2:Nodes from number1 to number2
+! nodes:Invert selection of the following specification.
+.TE
+.SH EXAMPLES
+numactl \-\-physcpubind=+0-4,8-12 myapplic arguments
+Run myapplic on cpus 0-4 and 8-12 of the current cpuset.
+
+numactl \-\-interleave=all bigdatabase arguments
+Run big database with its memory interleaved on all CPUs.
+
+numactl \-\-cpunodebind=0 \-\-membind=0,1 process
+Run process on node 0 with memory allocated on node 0 and 1.
+
+numactl \-\-cpunodebind=0 \-\-membind=0,1 -- process -l
+Run process as above, but with an option (-l) that would be confused with
+a numactl option.
+
+numactl \-\-cpunodebind=netdev:eth0 \-\-membind=netdev:eth0 network-server
+Run network-server on the node of network device eth0 with its memory
+also in the same node.
+
+numactl \-\-preferred=1 numactl \-\-show
+Set preferred node 1 and show the resulting state.
+
+numactl --interleave=all --shm /tmp/shmkey 
+Interleave all of the sysv shared memory region specified by
+/tmp/shmkey over all nodes.
+
+Place a tmpfs file on 2 nodes:
+  numactl --membind=2 dd if=/dev/zero of=/dev/shm/A bs=1M count=1024
+  numactl --membind=3 dd if=/dev/zero of=/dev/shm/A seek=1024 bs=1M count=1024
+
+
+numactl --localalloc /dev/shm/file
+Reset the policy for the shared memory file 
+.I file
+to the default localalloc policy.
+.SH NOTES
+Requires an NUMA policy aware kernel.
+
+Command is not executed using a shell. If you want to use shell metacharacters
+in the child use sh -c as wrapper.
+
+Setting policy for a hugetlbfs file does currently not work because
+it cannot be extended by truncate.
+
+Shared memory segments larger than numactl's address space cannot 
+be completely policied. This could be a problem on 32bit architectures.
+Changing it piece by piece may work.
+
+The old
+.I --cpubind
+which accepts node numbers, not cpu numbers, is deprecated
+and replaced with the new 
+.I --cpunodebind
+and 
+.I --physcpubind
+options.
+
+.SH FILES
+.I /proc/cpuinfo
+for the listing of active CPUs. See 
+.I proc(5)
+for details.
+
+.I /sys/devices/system/node/node*/numastat
+for NUMA memory hit statistics.
+
+.SH COPYRIGHT
+Copyright 2002,2004 Andi Kleen, SuSE Labs.
+numactl and the demo programs are under the GNU General Public License, v.2
+
+.SH SEE ALSO
+.I set_mempolicy(2)
+,
+.I get_mempolicy(2)
+,
+.I mbind(2)
+,
+.I sched_setaffinity(2)
+, 
+.I sched_getaffinity(2)
+,
+.I proc(5)
+, 
+.I ftok(3)
+,
+.I shmat(2)
+,
+.I migratepages(8)
+
diff --git a/numactl.c b/numactl.c
new file mode 100644
index 0000000..a2b2d9d
--- /dev/null
+++ b/numactl.c
@@ -0,0 +1,662 @@
+/* Copyright (C) 2003,2004,2005 Andi Kleen, SuSE Labs.
+   Command line NUMA policy control.
+
+   numactl 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
+   2.
+
+   numactl 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.
+
+   You should find a copy of v2 of the GNU General Public License somewhere
+   on your Linux system; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#define _GNU_SOURCE
+#include <getopt.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include "numa.h"
+#include "numaif.h"
+#include "numaint.h"
+#include "util.h"
+#include "shm.h"
+
+#define CPUSET 0
+#define ALL 1
+
+int exitcode;
+
+struct option opts[] = {
+	{"all", 0, 0, 'a'},
+	{"interleave", 1, 0, 'i' },
+	{"preferred", 1, 0, 'p' },
+	{"cpubind", 1, 0, 'c' },
+	{"cpunodebind", 1, 0, 'N' },
+	{"physcpubind", 1, 0, 'C' },
+	{"membind", 1, 0, 'm'},
+	{"show", 0, 0, 's' },
+	{"localalloc", 0,0, 'l'},
+	{"hardware", 0,0,'H' },
+
+	{"shm", 1, 0, 'S'},
+	{"file", 1, 0, 'f'},
+	{"offset", 1, 0, 'o'},
+	{"length", 1, 0, 'L'},
+	{"strict", 0, 0, 't'},
+	{"shmmode", 1, 0, 'M'},
+	{"dump", 0, 0, 'd'},
+	{"dump-nodes", 0, 0, 'D'},
+	{"shmid", 1, 0, 'I'},
+	{"huge", 0, 0, 'u'},
+	{"touch", 0, 0, 'T'},
+	{"verify", 0, 0, 'V'}, /* undocumented - for debugging */
+	{ 0 }
+};
+
+void usage(void)
+{
+	fprintf(stderr,
+		"usage: numactl [--all | -a] [--interleave= | -i <nodes>] [--preferred= | -p <node>]\n"
+		"               [--physcpubind= | -C <cpus>] [--cpunodebind= | -N <nodes>]\n"
+		"               [--membind= | -m <nodes>] [--localalloc | -l] command args ...\n"
+		"       numactl [--show | -s]\n"
+		"       numactl [--hardware | -H]\n"
+		"       numactl [--length | -l <length>] [--offset | -o <offset>] [--shmmode | -M <shmmode>]\n"
+		"               [--strict | -t]\n"
+		"               [--shmid | -I <id>] --shm | -S <shmkeyfile>\n"
+		"               [--shmid | -I <id>] --file | -f <tmpfsfile>\n"
+		"               [--huge | -u] [--touch | -T] \n"
+		"               memory policy | --dump | -d | --dump-nodes | -D\n"
+		"\n"
+		"memory policy is --interleave | -i, --preferred | -p, --membind | -m, --localalloc | -l\n"
+		"<nodes> is a comma delimited list of node numbers or A-B ranges or all.\n"
+		"Instead of a number a node can also be:\n"
+		"  netdev:DEV the node connected to network device DEV\n"
+		"  file:PATH  the node the block device of path is connected to\n"
+		"  ip:HOST    the node of the network device host routes through\n"
+		"  block:PATH the node of block device path\n"
+		"  pci:[seg:]bus:dev[:func] The node of a PCI device\n"
+		"<cpus> is a comma delimited list of cpu numbers or A-B ranges or all\n"
+		"all ranges can be inverted with !\n"
+		"all numbers and ranges can be made cpuset-relative with +\n"
+		"the old --cpubind argument is deprecated.\n"
+		"use --cpunodebind or --physcpubind instead\n"
+		"<length> can have g (GB), m (MB) or k (KB) suffixes\n");
+	exit(1);
+}
+
+void usage_msg(char *msg, ...)
+{
+	va_list ap;
+	va_start(ap,msg);
+	fprintf(stderr, "numactl: ");
+	vfprintf(stderr, msg, ap);
+	putchar('\n');
+	usage();
+}
+
+void show_physcpubind(void)
+{
+	int ncpus = numa_num_configured_cpus();
+
+	for (;;) {
+		struct bitmask *cpubuf;
+
+		cpubuf = numa_bitmask_alloc(ncpus);
+
+		if (numa_sched_getaffinity(0, cpubuf) < 0) {
+			if (errno == EINVAL && ncpus < 1024*1024) {
+				ncpus *= 2;
+				continue;
+			}
+			err("sched_get_affinity");
+		}
+		printmask("physcpubind", cpubuf);
+		break;
+	}
+}
+
+void show(void)
+{
+	unsigned long prefnode;
+	struct bitmask *membind, *interleave, *cpubind;
+	unsigned long cur;
+	int policy;
+
+	if (numa_available() < 0) {
+		show_physcpubind();
+		printf("No NUMA support available on this system.\n");
+		exit(1);
+	}
+
+	cpubind = numa_get_run_node_mask();
+
+	prefnode = numa_preferred();
+	interleave = numa_get_interleave_mask();
+	membind = numa_get_membind();
+	cur = numa_get_interleave_node();
+
+	policy = 0;
+	if (get_mempolicy(&policy, NULL, 0, 0, 0) < 0)
+		perror("get_mempolicy");
+
+	printf("policy: %s\n", policy_name(policy));
+
+	printf("preferred node: ");
+	switch (policy) {
+	case MPOL_PREFERRED:
+		if (prefnode != -1) {
+			printf("%ld\n", prefnode);
+			break;
+		}
+		/*FALL THROUGH*/
+	case MPOL_DEFAULT:
+		printf("current\n");
+		break;
+	case MPOL_INTERLEAVE:
+		printf("%ld (interleave next)\n",cur);
+		break;
+	case MPOL_BIND:
+		printf("%d\n", find_first(membind));
+		break;
+	}
+	if (policy == MPOL_INTERLEAVE) {
+		printmask("interleavemask", interleave);
+		printf("interleavenode: %ld\n", cur);
+	}
+	show_physcpubind();
+	printmask("cpubind", cpubind);  // for compatibility
+	printmask("nodebind", cpubind);
+	printmask("membind", membind);
+}
+
+char *fmt_mem(unsigned long long mem, char *buf)
+{
+	if (mem == -1L)
+		sprintf(buf, "<not available>");
+	else
+		sprintf(buf, "%llu MB", mem >> 20);
+	return buf;
+}
+
+static void print_distances(int maxnode)
+{
+	int i,k;
+	int fst = 0;
+
+	for (i = 0; i <= maxnode; i++)
+		if (numa_bitmask_isbitset(numa_nodes_ptr, i)) {
+			fst = i;
+			break;
+		}
+	if (numa_distance(maxnode,fst) == 0) {
+		printf("No distance information available.\n");
+		return;
+	}
+	printf("node distances:\n");
+	printf("node ");
+	for (i = 0; i <= maxnode; i++)
+		if (numa_bitmask_isbitset(numa_nodes_ptr, i))
+			printf("% 3d ", i);
+	printf("\n");
+	for (i = 0; i <= maxnode; i++) {
+		if (!numa_bitmask_isbitset(numa_nodes_ptr, i))
+			continue;
+		printf("% 3d: ", i);
+		for (k = 0; k <= maxnode; k++)
+			if (numa_bitmask_isbitset(numa_nodes_ptr, i) &&
+			    numa_bitmask_isbitset(numa_nodes_ptr, k))
+				printf("% 3d ", numa_distance(i,k));
+		printf("\n");
+	}
+}
+
+void print_node_cpus(int node)
+{
+	int i, err;
+	struct bitmask *cpus;
+
+	cpus = numa_allocate_cpumask();
+	err = numa_node_to_cpus(node, cpus);
+	if (err >= 0) {
+		for (i = 0; i < cpus->size; i++)
+			if (numa_bitmask_isbitset(cpus, i))
+				printf(" %d", i);
+	}
+	putchar('\n');
+}
+
+void hardware(void)
+{
+	int i;
+	int numnodes=0;
+	int prevnode=-1;
+	int skip=0;
+	int maxnode = numa_max_node();
+
+	if (numa_available() < 0) {
+                printf("No NUMA available on this system\n");
+                exit(1);
+        }
+
+	for (i=0; i<=maxnode; i++)
+		if (numa_bitmask_isbitset(numa_nodes_ptr, i))
+			numnodes++;
+	printf("available: %d nodes (", numnodes);
+	for (i=0; i<=maxnode; i++) {
+		if (numa_bitmask_isbitset(numa_nodes_ptr, i)) {
+			if (prevnode == -1) {
+				printf("%d", i);
+				prevnode=i;
+				continue;
+			}
+
+			if (i > prevnode + 1) {
+				if (skip) {
+					printf("%d", prevnode);
+					skip=0;
+				}
+				printf(",%d", i);
+				prevnode=i;
+				continue;
+			}
+
+			if (i == prevnode + 1) {
+				if (!skip) {
+					printf("-");
+					skip=1;
+				}
+				prevnode=i;
+			}
+
+			if ((i == maxnode) && skip)
+				printf("%d", prevnode);
+		}
+	}
+	printf(")\n");
+
+	for (i = 0; i <= maxnode; i++) {
+		char buf[64];
+		long long fr;
+		unsigned long long sz = numa_node_size64(i, &fr);
+		if (!numa_bitmask_isbitset(numa_nodes_ptr, i))
+			continue;
+
+		printf("node %d cpus:", i);
+		print_node_cpus(i);
+		printf("node %d size: %s\n", i, fmt_mem(sz, buf));
+		printf("node %d free: %s\n", i, fmt_mem(fr, buf));
+	}
+	print_distances(maxnode);
+}
+
+void checkerror(char *s)
+{
+	if (errno) {
+		perror(s);
+		exit(1);
+	}
+}
+
+void checknuma(void)
+{
+	static int numa = -1;
+	if (numa < 0) {
+		if (numa_available() < 0)
+			complain("This system does not support NUMA policy");
+	}
+	numa = 0;
+}
+
+int set_policy = -1;
+
+void setpolicy(int pol)
+{
+	if (set_policy != -1)
+		usage_msg("Conflicting policies");
+	set_policy = pol;
+}
+
+void nopolicy(void)
+{
+	if (set_policy >= 0)
+		usage_msg("specify policy after --shm/--file");
+}
+
+int did_cpubind = 0;
+int did_strict = 0;
+int do_shm = 0;
+int do_dump = 0;
+int shmattached = 0;
+int did_node_cpu_parse = 0;
+int parse_all = 0;
+char *shmoption;
+
+void check_cpubind(int flag)
+{
+	if (flag)
+		usage_msg("cannot do --cpubind on shared memory\n");
+}
+
+void noshm(char *opt)
+{
+	if (shmattached)
+		usage_msg("%s must be before shared memory specification", opt);
+	shmoption = opt;
+}
+
+void dontshm(char *opt)
+{
+	if (shmoption)
+		usage_msg("%s shm option is not allowed before %s", shmoption, opt);
+}
+
+void needshm(char *opt)
+{
+	if (!shmattached)
+		usage_msg("%s must be after shared memory specification", opt);
+}
+
+void check_all_parse(int flag)
+{
+	if (did_node_cpu_parse)
+		usage_msg("--all/-a option must be before all cpu/node specifications");
+}
+
+void get_short_opts(struct option *o, char *s)
+{
+	*s++ = '+';
+	while (o->name) {
+		if (isprint(o->val)) {
+			*s++ = o->val;
+			if (o->has_arg)
+				*s++ = ':';
+		}
+		o++;
+	}
+	*s = '\0';
+}
+
+void check_shmbeyond(char *msg)
+{
+	if (shmoffset >= shmlen) {
+		fprintf(stderr,
+		"numactl: region offset %#llx beyond its length %#llx at %s\n",
+				shmoffset, shmlen, msg);
+		exit(1);
+	}
+}
+
+static struct bitmask *numactl_parse_nodestring(char *s, int flag)
+{
+	static char *last;
+
+	if (s[0] == 's' && !strcmp(s, "same")) {
+		if (!last)
+			usage_msg("same needs previous node specification");
+		s = last;
+	} else {
+		last = s;
+	}
+
+	if (flag == ALL)
+		return numa_parse_nodestring_all(s);
+	else
+		return numa_parse_nodestring(s);
+}
+
+int main(int ac, char **av)
+{
+	int c, i, nnodes=0;
+	long node=-1;
+	char *end;
+	char shortopts[array_len(opts)*2 + 1];
+	struct bitmask *mask = NULL;
+
+	get_short_opts(opts,shortopts);
+	while ((c = getopt_long(ac, av, shortopts, opts, NULL)) != -1) {
+		switch (c) {
+		case 's': /* --show */
+			show();
+			exit(0);
+		case 'H': /* --hardware */
+			nopolicy();
+			hardware();
+			exit(0);
+		case 'i': /* --interleave */
+			checknuma();
+			if (parse_all)
+				mask = numactl_parse_nodestring(optarg, ALL);
+			else
+				mask = numactl_parse_nodestring(optarg, CPUSET);
+			if (!mask) {
+				printf ("<%s> is invalid\n", optarg);
+				usage();
+			}
+
+			errno = 0;
+			did_node_cpu_parse = 1;
+			setpolicy(MPOL_INTERLEAVE);
+			if (shmfd >= 0)
+				numa_interleave_memory(shmptr, shmlen, mask);
+			else
+				numa_set_interleave_mask(mask);
+			checkerror("setting interleave mask");
+			break;
+		case 'N': /* --cpunodebind */
+		case 'c': /* --cpubind */
+			dontshm("-c/--cpubind/--cpunodebind");
+			checknuma();
+			if (parse_all)
+				mask = numactl_parse_nodestring(optarg, ALL);
+			else
+				mask = numactl_parse_nodestring(optarg, CPUSET);
+			if (!mask) {
+				printf ("<%s> is invalid\n", optarg);
+				usage();
+			}
+			errno = 0;
+			check_cpubind(do_shm);
+			did_cpubind = 1;
+			did_node_cpu_parse = 1;
+			numa_run_on_node_mask_all(mask);
+			checkerror("sched_setaffinity");
+			break;
+		case 'C': /* --physcpubind */
+		{
+			struct bitmask *cpubuf;
+			dontshm("-C/--physcpubind");
+			if (parse_all)
+				cpubuf = numa_parse_cpustring_all(optarg);
+			else
+				cpubuf = numa_parse_cpustring(optarg);
+			if (!cpubuf) {
+				printf ("<%s> is invalid\n", optarg);
+				usage();
+			}
+			errno = 0;
+			check_cpubind(do_shm);
+			did_cpubind = 1;
+			did_node_cpu_parse = 1;
+			numa_sched_setaffinity(0, cpubuf);
+			checkerror("sched_setaffinity");
+			free(cpubuf);
+			break;
+		}
+		case 'm': /* --membind */
+			checknuma();
+			setpolicy(MPOL_BIND);
+			if (parse_all)
+				mask = numactl_parse_nodestring(optarg, ALL);
+			else
+				mask = numactl_parse_nodestring(optarg, CPUSET);
+			if (!mask) {
+				printf ("<%s> is invalid\n", optarg);
+				usage();
+			}
+			errno = 0;
+			did_node_cpu_parse = 1;
+			numa_set_bind_policy(1);
+			if (shmfd >= 0) {
+				numa_tonodemask_memory(shmptr, shmlen, mask);
+			} else {
+				numa_set_membind(mask);
+			}
+			numa_set_bind_policy(0);
+			checkerror("setting membind");
+			break;
+		case 'p': /* --preferred */
+			checknuma();
+			setpolicy(MPOL_PREFERRED);
+			if (parse_all)
+				mask = numactl_parse_nodestring(optarg, ALL);
+			else
+				mask = numactl_parse_nodestring(optarg, CPUSET);
+			if (!mask) {
+				printf ("<%s> is invalid\n", optarg);
+				usage();
+			}
+			for (i=0; i<mask->size; i++) {
+				if (numa_bitmask_isbitset(mask, i)) {
+					node = i;
+					nnodes++;
+				}
+			}
+			if (nnodes != 1)
+				usage();
+			numa_bitmask_free(mask);
+			errno = 0;
+			did_node_cpu_parse = 1;
+			numa_set_bind_policy(0);
+			if (shmfd >= 0)
+				numa_tonode_memory(shmptr, shmlen, node);
+			else
+				numa_set_preferred(node);
+			checkerror("setting preferred node");
+			break;
+		case 'l': /* --local */
+			checknuma();
+			setpolicy(MPOL_DEFAULT);
+			errno = 0;
+			if (shmfd >= 0)
+				numa_setlocal_memory(shmptr, shmlen);
+			else
+				numa_set_localalloc();
+			checkerror("local allocation");
+			break;
+		case 'S': /* --shm */
+			check_cpubind(did_cpubind);
+			nopolicy();
+			attach_sysvshm(optarg, "--shm");
+			shmattached = 1;
+			break;
+		case 'f': /* --file */
+			check_cpubind(did_cpubind);
+			nopolicy();
+			attach_shared(optarg, "--file");
+			shmattached = 1;
+			break;
+		case 'L': /* --length */
+			noshm("--length");
+			shmlen = memsize(optarg);
+			break;
+		case 'M': /* --shmmode */
+			noshm("--shmmode");
+			shmmode = strtoul(optarg, &end, 8);
+			if (end == optarg || *end)
+				usage();
+			break;
+		case 'd': /* --dump */
+			if (shmfd < 0)
+				complain(
+				"Cannot do --dump without shared memory.\n");
+			dump_shm();
+			do_dump = 1;
+			break;
+		case 'D': /* --dump-nodes */
+			if (shmfd < 0)
+				complain(
+			    "Cannot do --dump-nodes without shared memory.\n");
+			dump_shm_nodes();
+			do_dump = 1;
+			break;
+		case 't': /* --strict */
+			did_strict = 1;
+			numa_set_strict(1);
+			break;
+		case 'I': /* --shmid */
+			shmid = strtoul(optarg, &end, 0);
+			if (end == optarg || *end)
+				usage();
+			break;
+
+		case 'u': /* --huge */
+			noshm("--huge");
+			shmflags |= SHM_HUGETLB;
+			break;
+
+		case 'o':  /* --offset */
+			noshm("--offset");
+			shmoffset = memsize(optarg);
+			break;
+
+		case 'T': /* --touch */
+			needshm("--touch");
+			check_shmbeyond("--touch");
+			numa_police_memory(shmptr, shmlen);
+			break;
+
+		case 'V': /* --verify */
+			needshm("--verify");
+			if (set_policy < 0)
+				complain("Need a policy first to verify");
+			check_shmbeyond("--verify");
+			numa_police_memory(shmptr, shmlen);
+			if (!mask)
+				complain("Need a mask to verify");
+			else
+				verify_shm(set_policy, mask);
+			break;
+
+		case 'a': /* --all */
+			check_all_parse(did_node_cpu_parse);
+			parse_all = 1;
+			break;
+		default:
+			usage();
+		}
+	}
+
+	av += optind;
+	ac -= optind;
+
+	if (shmfd >= 0) {
+		if (*av)
+			usage();
+		exit(exitcode);
+	}
+
+	if (did_strict)
+		fprintf(stderr,
+			"numactl: warning. Strict flag for process ignored.\n");
+
+	if (do_dump)
+		usage_msg("cannot do --dump|--dump-shm for process");
+
+	if (shmoption)
+		usage_msg("shm related option %s for process", shmoption);
+
+	if (*av == NULL)
+		usage();
+	execvp(*av, av);
+	complain("execution of `%s': %s\n", av[0], strerror(errno));
+	return 0; /* not reached */
+}
diff --git a/numademo.c b/numademo.c
new file mode 100644
index 0000000..b01e995
--- /dev/null
+++ b/numademo.c
@@ -0,0 +1,570 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+   Test/demo program for libnuma. This is also a more or less useful benchmark
+   of the NUMA characteristics of your machine. It benchmarks most possible
+   NUMA policy memory configurations with various benchmarks.
+   Compile standalone with cc -O2 numademo.c -o numademo -lnuma -lm
+
+   numactl 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
+   2.
+
+   numactl 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.
+
+   You should find a copy of v2 of the GNU General Public License somewhere
+   on your Linux system; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#define _GNU_SOURCE 1
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include "numa.h"
+#ifdef HAVE_STREAM_LIB
+#include "stream_lib.h"
+#endif
+#ifdef HAVE_MT
+#include "mt.h"
+#endif
+#ifdef HAVE_CLEAR_CACHE
+#include "clearcache.h"
+#else
+static inline void clearcache(void *a, unsigned size) {}
+#endif
+#define FRACT_NODES 8
+#define FRACT_MASKS 32
+int fract_nodes;
+int *node_to_use;
+unsigned long msize;
+
+/* Should get this from cpuinfo, but on !x86 it's not there */
+enum {
+	CACHELINESIZE = 64,
+};
+
+enum test {
+	MEMSET = 0,
+	MEMCPY,
+	FORWARD,
+	BACKWARD,
+	STREAM,
+	RANDOM2,
+	PTRCHASE,
+} thistest;
+
+char *delim = " ";
+int force;
+int regression_testing=0;
+
+char *testname[] = {
+	"memset",
+	"memcpy",
+	"forward",
+	"backward",
+#ifdef HAVE_STREAM_LIB
+	"stream",
+#endif
+#ifdef HAVE_MT
+	"random2",
+#endif
+	"ptrchase",
+	NULL,
+};
+
+void output(char *title, char *result)
+{
+	if (!isspace(delim[0]))
+		printf("%s%s%s\n", title,delim, result);
+	else
+		printf("%-42s%s\n", title, result);
+}
+
+#ifdef HAVE_STREAM_LIB
+void do_stream(char *name, unsigned char *mem)
+{
+	int i;
+	char title[100], buf[100];
+	double res[STREAM_NRESULTS];
+	stream_verbose = 0;
+	clearcache(mem, msize);
+	stream_init(mem);
+	stream_test(res);
+	sprintf(title, "%s%s%s", name, delim, "STREAM");
+	buf[0] = '\0';
+	for (i = 0; i < STREAM_NRESULTS; i++) {
+		if (buf[0])
+			strcat(buf,delim);
+		sprintf(buf+strlen(buf), "%s%s%.2f%sMB/s",
+			stream_names[i], delim, res[i], delim);
+	}
+	output(title, buf);
+	clearcache(mem, msize);
+}
+#endif
+
+/* Set up a randomly distributed list to fool prefetchers */
+union node {
+	union node *next;
+	struct {
+		unsigned nexti;
+		unsigned val;
+	};
+};
+
+static int cmp_node(const void *ap, const void *bp)
+{
+	union node *a = (union node *)ap;
+	union node *b = (union node *)bp;
+	return a->val - b->val;
+}
+
+void **ptrchase_init(unsigned char *mem)
+{
+	long i;
+	union node *nodes = (union node *)mem;
+	long nmemb = msize / sizeof(union node);
+	srand(1234);
+	for (i = 0; i < nmemb; i++) {
+		nodes[i].val = rand();
+		nodes[i].nexti = i + 1;
+	}
+	qsort(nodes, nmemb, sizeof(union node), cmp_node);
+	for (i = 0; i < nmemb; i++) {
+		union node *n = &nodes[i];
+		n->next = n->nexti >= nmemb ? NULL : &nodes[n->nexti];
+	}
+	return (void **)nodes;
+}
+
+static inline unsigned long long timerfold(struct timeval *tv)
+{
+	return tv->tv_sec * 1000000ULL + tv->tv_usec;
+}
+
+#define LOOPS 10
+
+void memtest(char *name, unsigned char *mem)
+{
+	long k;
+	struct timeval start, end, res;
+	unsigned long long max, min, sum, r;
+	int i;
+	char title[128], result[128];
+
+	if (!mem) {
+		fprintf(stderr,
+		"Failed to allocate %lu bytes of memory. Test \"%s\" exits.\n",
+			msize, name);
+		return;
+	}
+
+#ifdef HAVE_STREAM_LIB
+	if (thistest == STREAM) {
+		do_stream(name, mem);
+		goto out;
+	}
+#endif
+
+	max = 0;
+	min = ~0UL;
+	sum = 0;
+
+	/*
+	 * Note:  0th pass allocates the pages, don't measure
+	 */
+	for (i = 0; i < LOOPS+1; i++) {
+		clearcache(mem, msize);
+		switch (thistest) {
+		case PTRCHASE:
+		{
+			void **ptr;
+			ptr = ptrchase_init(mem);
+			gettimeofday(&start,NULL);
+			while (*ptr)
+				ptr = (void **)*ptr;
+			gettimeofday(&end,NULL);
+			/* Side effect to trick the optimizer */
+			*ptr = "bla";
+			break;
+		}
+
+		case MEMSET:
+			gettimeofday(&start,NULL);
+			memset(mem, 0xff, msize);
+			gettimeofday(&end,NULL);
+			break;
+
+		case MEMCPY:
+			gettimeofday(&start,NULL);
+			memcpy(mem, mem + msize/2, msize/2);
+			gettimeofday(&end,NULL);
+			break;
+
+		case FORWARD:
+			/* simple kernel to just fetch cachelines and write them back.
+			   will trigger hardware prefetch */
+			gettimeofday(&start,NULL);
+			for (k = 0; k < msize; k+=CACHELINESIZE)
+				mem[k]++;
+			gettimeofday(&end,NULL);
+			break;
+
+		case BACKWARD:
+			gettimeofday(&start,NULL);
+			for (k = msize-5; k > 0; k-=CACHELINESIZE)
+				mem[k]--;
+			gettimeofday(&end,NULL);
+			break;
+
+#ifdef HAVE_MT
+		case RANDOM2:
+		{
+			unsigned * __restrict m = (unsigned *)mem;
+			unsigned max = msize / sizeof(unsigned);
+			unsigned mask;
+
+			mt_init();
+			mask = 1;
+			while (mask < max)
+				mask = (mask << 1) | 1;
+			/*
+			 * There's no guarantee all memory is touched, but
+			 * we assume (hope) that the distribution of the MT
+			 * is good enough to touch most.
+			 */
+			gettimeofday(&start,NULL);
+			for (k = 0; k < max; k++) {
+				unsigned idx = mt_random() & mask;
+				if (idx >= max)
+					idx -= max;
+				m[idx]++;
+			}
+			gettimeofday(&end,NULL);
+		}
+
+#endif
+		default:
+			break;
+		}
+
+		if (!i)
+			continue;  /* don't count allocation pass */
+
+		timersub(&end, &start, &res);
+		r = timerfold(&res);
+		if (r > max) max = r;
+		if (r < min) min = r;
+		sum += r;
+	}
+	sprintf(title, "%s%s%s", name, delim, testname[thistest]);
+#define H(t) (((double)msize) / ((double)t))
+#define D3 delim,delim,delim
+	sprintf(result, "Avg%s%.2f%sMB/s%sMax%s%.2f%sMB/s%sMin%s%.2f%sMB/s",
+		delim,
+		H(sum/LOOPS),
+		D3,
+		H(min),
+		D3,
+		H(max),
+		delim);
+#undef H
+#undef D3
+	output(title,result);
+
+#ifdef HAVE_STREAM_LIB
+ out:
+#endif
+	/* Just to make sure that when we switch CPUs that the old guy
+	   doesn't still keep it around. */
+	clearcache(mem, msize);
+
+	numa_free(mem, msize);
+}
+
+int popcnt(unsigned long val)
+{
+	int i = 0, cnt = 0;
+	while (val >> i) {
+		if ((1UL << i) & val)
+			cnt++;
+		i++;
+	}
+	return cnt;
+}
+
+int max_node, numnodes;
+
+void get_node_list()
+{
+        int a, got_nodes = 0;
+        long free_node_sizes;
+
+        numnodes = numa_num_configured_nodes();
+        node_to_use = (int *)malloc(numnodes * sizeof(int));
+        max_node = numa_max_node();
+        for (a = 0; a <= max_node; a++) {
+                if(numa_node_size(a, &free_node_sizes) != -1)
+                        node_to_use[got_nodes++] = a;
+        }
+}
+
+void test(enum test type)
+{
+	unsigned long mask;
+	int i, k;
+	char buf[512];
+	struct bitmask *nodes;
+
+	nodes = numa_allocate_nodemask();
+	thistest = type;
+
+	if (regression_testing) {
+		printf("\nTest %s doing 1 of %d nodes and 1 of %d masks.\n",
+			testname[thistest], fract_nodes, FRACT_MASKS);
+	}
+
+	memtest("memory with no policy", numa_alloc(msize));
+	memtest("local memory", numa_alloc_local(msize));
+
+	memtest("memory interleaved on all nodes", numa_alloc_interleaved(msize));
+	for (i = 0; i < numnodes; i++) {
+		if (regression_testing && (node_to_use[i] % fract_nodes)) {
+		/* for regression testing (-t) do only every eighth node */
+			continue;
+		}
+		sprintf(buf, "memory on node %d", node_to_use[i]);
+		memtest(buf, numa_alloc_onnode(msize, node_to_use[i]));
+	}
+
+	for (mask = 1, i = 0; mask < (1UL<<numnodes); mask++, i++) {
+		int w;
+		char buf2[20];
+		if (popcnt(mask) == 1)
+			continue;
+		if (regression_testing && (i > 50)) {
+			break;
+		}
+		if (regression_testing && (i % FRACT_MASKS)) {
+		/* for regression testing (-t)
+			do only every 32nd mask permutation */
+			continue;
+		}
+		numa_bitmask_clearall(nodes);
+		for (w = 0; mask >> w; w++) {
+			if ((mask >> w) & 1)
+				numa_bitmask_setbit(nodes, w);
+		}
+
+		sprintf(buf, "memory interleaved on");
+		for (k = 0; k < numnodes; k++)
+			if ((1UL<<node_to_use[k]) & mask) {
+				sprintf(buf2, " %d", node_to_use[k]);
+				strcat(buf, buf2);
+			}
+		memtest(buf, numa_alloc_interleaved_subset(msize, nodes));
+	}
+
+	for (i = 0; i < numnodes; i++) {
+		if (regression_testing && (node_to_use[i] % fract_nodes)) {
+		/* for regression testing (-t) do only every eighth node */
+			continue;
+		}
+		printf("setting preferred node to %d\n", node_to_use[i]);
+		numa_set_preferred(node_to_use[i]);
+		memtest("memory without policy", numa_alloc(msize));
+	}
+
+	numa_set_interleave_mask(numa_all_nodes_ptr);
+	memtest("manual interleaving to all nodes", numa_alloc(msize));
+
+	if (numnodes > 0) {
+		numa_bitmask_clearall(nodes);
+		numa_bitmask_setbit(nodes, 0);
+		numa_bitmask_setbit(nodes, 1);
+		numa_set_interleave_mask(nodes);
+		memtest("manual interleaving on node 0/1", numa_alloc(msize));
+		printf("current interleave node %d\n", numa_get_interleave_node());
+	}
+
+	numa_set_interleave_mask(numa_no_nodes_ptr);
+
+	nodes = numa_allocate_nodemask();
+
+	for (i = 0; i < numnodes; i++) {
+		int oldhn = numa_preferred();
+
+		if (regression_testing && (node_to_use[i] % fract_nodes)) {
+		/* for regression testing (-t) do only every eighth node */
+			continue;
+		}
+		numa_run_on_node(node_to_use[i]);
+		printf("running on node %d, preferred node %d\n",node_to_use[i], oldhn);
+
+		memtest("local memory", numa_alloc_local(msize));
+
+		memtest("memory interleaved on all nodes",
+			numa_alloc_interleaved(msize));
+
+		if (numnodes >= 2) {
+			numa_bitmask_clearall(nodes);
+			numa_bitmask_setbit(nodes, 0);
+			numa_bitmask_setbit(nodes, 1);
+			memtest("memory interleaved on node 0/1",
+				numa_alloc_interleaved_subset(msize, nodes));
+		}
+
+		for (k = 0; k < numnodes; k++) {
+			if (node_to_use[k] == node_to_use[i])
+				continue;
+			if (regression_testing && (node_to_use[k] % fract_nodes)) {
+			/* for regression testing (-t)
+				do only every eighth node */
+				continue;
+			}
+			sprintf(buf, "alloc on node %d", node_to_use[k]);
+			numa_bitmask_clearall(nodes);
+			numa_bitmask_setbit(nodes, node_to_use[k]);
+			numa_set_membind(nodes);
+			memtest(buf, numa_alloc(msize));
+			numa_set_membind(numa_all_nodes_ptr);
+		}
+
+		numa_set_localalloc();
+		memtest("local allocation", numa_alloc(msize));
+
+		numa_set_preferred((node_to_use[i]+1) % numnodes );
+		memtest("setting wrong preferred node", numa_alloc(msize));
+		numa_set_preferred(node_to_use[i]);
+		memtest("setting correct preferred node", numa_alloc(msize));
+		numa_set_preferred(-1);
+		if (!delim[0])
+			printf("\n\n\n");
+	}
+
+	/* numa_run_on_node_mask is not tested */
+}
+
+void usage(void)
+{
+	int i;
+	printf("usage: numademo [-S] [-f] [-c] [-e] [-t] msize[kmg] {tests}\nNo tests means run all.\n");
+	printf("-c output CSV data. -f run even without NUMA API. -S run stupid tests. -e exit on error\n");
+	printf("-t regression test; do not run all node combinations\n");
+	printf("valid tests:");
+	for (i = 0; testname[i]; i++)
+		printf(" %s", testname[i]);
+	putchar('\n');
+	exit(1);
+}
+
+/* duplicated to make numademo standalone */
+long memsize(char *s)
+{
+	char *end;
+	long length = strtoul(s,&end,0);
+	switch (toupper(*end)) {
+	case 'G': length *= 1024;  /*FALL THROUGH*/
+	case 'M': length *= 1024;  /*FALL THROUGH*/
+	case 'K': length *= 1024; break;
+	}
+	return length;
+}
+
+int main(int ac, char **av)
+{
+	int simple_tests = 0;
+
+	while (av[1] && av[1][0] == '-') {
+		ac--;
+		switch (av[1][1]) {
+		case 'c':
+			delim = ",";
+			break;
+		case 'f':
+			force = 1;
+			break;
+		case 'S':
+			simple_tests = 1;
+			break;
+		case 'e':
+			numa_exit_on_error = 1;
+			numa_exit_on_warn = 1;
+			break;
+		case 't':
+			regression_testing = 1;
+			break;
+		default:
+			usage();
+			break;
+		}
+		++av;
+	}
+
+	if (!av[1])
+		usage();
+
+	if (numa_available() < 0) {
+		printf("your system does not support the numa API.\n");
+		if (!force)
+			exit(1);
+	}
+	get_node_list();
+	printf("%d nodes available\n", numnodes);
+	fract_nodes = (((numnodes-1)/8)*2) + FRACT_NODES;
+
+	if (numnodes <= 3)
+		regression_testing = 0; /* set -t auto-off for small systems */
+
+	msize = memsize(av[1]);
+
+	if (!msize)
+		usage();
+
+#ifdef HAVE_STREAM_LIB
+	stream_setmem(msize);
+#endif
+
+	if (av[2] == NULL) {
+		test(MEMSET);
+		test(MEMCPY);
+		if (simple_tests) {
+			test(FORWARD);
+			test(BACKWARD);
+		}
+#ifdef HAVE_MT
+		test(RANDOM2);
+#endif
+#ifdef HAVE_STREAM_LIB
+		test(STREAM);
+#endif
+		if (msize >= sizeof(union node)) {
+			test(PTRCHASE);
+		} else {
+			fprintf(stderr, "You must set msize at least %lu bytes for ptrchase test.\n",
+				sizeof(union node));
+			exit(1);
+		}
+	} else {
+		int k;
+		for (k = 2; k < ac; k++) {
+			int i;
+			int found = 0;
+			for (i = 0; testname[i]; i++) {
+				if (!strcmp(testname[i],av[k])) {
+					test(i);
+					found = 1;
+					break;
+				}
+			}
+			if (!found) {
+				fprintf(stderr,"unknown test `%s'\n", av[k]);
+				usage();
+			}
+		}
+	}
+	return 0;
+}
diff --git a/numaif.h b/numaif.h
new file mode 100644
index 0000000..d81d458
--- /dev/null
+++ b/numaif.h
@@ -0,0 +1,48 @@
+#ifndef NUMAIF_H
+#define NUMAIF_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Kernel interface for NUMA API */
+
+/* System calls */
+extern long get_mempolicy(int *policy, unsigned long *nmask,
+                          unsigned long maxnode, void *addr, unsigned flags);
+extern long mbind(void *start, unsigned long len, int mode,
+	const unsigned long *nmask, unsigned long maxnode, unsigned flags);
+extern long set_mempolicy(int mode, const unsigned long *nmask,
+			  unsigned long maxnode);
+extern long migrate_pages(int pid, unsigned long maxnode,
+			  const unsigned long *frommask,
+			  const unsigned long *tomask);
+
+extern long move_pages(int pid, unsigned long count,
+		void **pages, const int *nodes, int *status, int flags);
+
+/* Policies */
+#define MPOL_DEFAULT     0
+#define MPOL_PREFERRED    1
+#define MPOL_BIND        2
+#define MPOL_INTERLEAVE  3
+
+#define MPOL_MAX MPOL_INTERLEAVE
+
+/* Flags for get_mem_policy */
+#define MPOL_F_NODE    (1<<0)   /* return next il node or node of address */
+				/* Warning: MPOL_F_NODE is unsupported and
+				   subject to change. Don't use. */
+#define MPOL_F_ADDR     (1<<1)  /* look up vma using address */
+#define MPOL_F_MEMS_ALLOWED (1<<2) /* query nodes allowed in cpuset */
+
+/* Flags for mbind */
+#define MPOL_MF_STRICT  (1<<0)  /* Verify existing pages in the mapping */
+#define MPOL_MF_MOVE	(1<<1)  /* Move pages owned by this process to conform to mapping */
+#define MPOL_MF_MOVE_ALL (1<<2) /* Move every page to conform to mapping */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/numaint.h b/numaint.h
new file mode 100644
index 0000000..e9cd385
--- /dev/null
+++ b/numaint.h
@@ -0,0 +1,57 @@
+/* Internal interfaces of libnuma */
+
+extern int numa_sched_setaffinity_v1(pid_t pid, unsigned len, const unsigned long *mask);
+extern int numa_sched_getaffinity_v1(pid_t pid, unsigned len, const unsigned long *mask);
+extern int numa_sched_setaffinity_v1_int(pid_t pid, unsigned len,const unsigned long *mask);
+extern int numa_sched_getaffinity_v1_int(pid_t pid, unsigned len,const unsigned long *mask);
+extern int numa_sched_setaffinity_v2(pid_t pid, struct bitmask *mask);
+extern int numa_sched_getaffinity_v2(pid_t pid, struct bitmask *mask);
+extern int numa_sched_setaffinity_v2_int(pid_t pid, struct bitmask *mask);
+extern int numa_sched_getaffinity_v2_int(pid_t pid, struct bitmask *mask);
+
+#define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
+
+#define BITS_PER_LONG (sizeof(unsigned long) * 8)
+#define CPU_BYTES(x) (round_up(x, BITS_PER_LONG)/8)
+#define CPU_LONGS(x) (CPU_BYTES(x) / sizeof(long))
+
+#define make_internal_alias(x) extern __typeof (x) x##_int __attribute((alias(#x), visibility("hidden")))
+#define hidden __attribute__((visibility("hidden")))
+
+enum numa_warn {
+	W_nosysfs,
+	W_noproc,
+	W_badmeminfo,
+	W_nosysfs2,
+	W_cpumap,
+	W_numcpus,
+	W_noderunmask,
+	W_distance,
+	W_memory,
+	W_cpuparse,
+	W_nodeparse,
+	W_blockdev1,
+	W_blockdev2,
+	W_blockdev3,
+	W_blockdev4,
+	W_blockdev5,
+	W_netlink1,
+	W_netlink2,
+	W_netlink3,
+	W_net1,
+	W_net2,
+	W_class1,
+	W_class2,
+	W_pci1,
+	W_pci2,
+	W_node_parse1,
+	W_node_parse2,
+	W_nonode,
+	W_badchar,
+};
+
+#define howmany(x,y) (((x)+((y)-1))/(y))
+#define bitsperlong (8 * sizeof(unsigned long))
+#define bitsperint (8 * sizeof(unsigned int))
+#define longsperbits(n) howmany(n, bitsperlong)
+#define bytesperbits(x) ((x+7)/8)
diff --git a/numamon.c b/numamon.c
new file mode 100644
index 0000000..a118c5f
--- /dev/null
+++ b/numamon.c
@@ -0,0 +1,331 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+
+   numamon 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
+   2.
+
+   numamon 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.
+
+   You should find a copy of v2 of the GNU General Public License somewhere
+   on your Linux system; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+   Display some numa statistics collected by the CPU.
+   Opteron specific. Also not reliable because the counters
+   are not quite correct in hardware.  */
+
+#define _LARGE_FILE_SOURCE 1
+#define _GNU_SOURCE 1
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <sys/fcntl.h>
+
+enum { LOCALLOCAL = 0, LOCALREMOTE = 1, REMOTELOCAL = 2 };
+static int mem[] = { [LOCALLOCAL] = 0xa8, [LOCALREMOTE] = 0x98, [REMOTELOCAL] = 0x68 };
+static int io[] = {  [LOCALLOCAL] = 0xa4, [LOCALREMOTE] = 0x94, [REMOTELOCAL] = 0x64 };
+static int *masks = mem;
+
+#define err(x) perror(x),exit(1)
+
+#define PERFEVTSEL0 0xc0010000
+#define PERFEVTSEL1 0xc0010001
+#define PERFEVTSEL2 0xc0010002
+#define PERFEVTSEL3 0xc0010003
+
+#define PERFCTR0 0xc0010004
+#define PERFCTR1 0xc0010005
+#define PERFCTR2 0xc0010006
+#define PERFCTR3 0xc0010007
+
+#define EVENT 0xe9
+#define PERFEVTSEL_EN (1 << 22)
+#define PERFEVTSEL_OS (1 << 17)
+#define PERFEVTSEL_USR (1 << 16)
+
+#define BASE (EVENT | PERFEVTSEL_EN | PERFEVTSEL_OS | PERFEVTSEL_USR)
+
+#define MAXCPU 8
+
+int force = 0;
+int msrfd[MAXCPU];
+int delay;
+int absolute;
+char *cfilter;
+int verbose;
+
+void usage(void);
+
+void Vprintf(char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap,fmt);
+	if (verbose)
+		vfprintf(stderr,fmt,ap);
+	va_end(ap);
+}
+
+unsigned long long rdmsr(int cpu, unsigned long msr)
+{
+	unsigned long long val;
+	if (pread(msrfd[cpu], &val, 8, msr) != 8) {
+		fprintf(stderr, "rdmsr of %lx failed: %s\n", msr, strerror(errno));
+		exit(1);
+	}
+	return val;
+}
+
+void wrmsr(int cpu, unsigned long msr, unsigned long long value)
+{
+	if (pwrite(msrfd[cpu], &value, 8, msr) != 8) {
+		fprintf(stderr, "wdmsr of %lx failed: %s\n", msr, strerror(errno));
+		exit(1);
+	}
+}
+
+int cpufilter(int cpu)
+{
+	long num;
+	char *end;
+	char *s;
+
+	if (!cfilter)
+		return 1;
+	for (s = cfilter;;) {
+		num = strtoul(s, &end, 0);
+		if (end == s)
+			usage();
+		if (cpu == num)
+			return 1;
+		if (*end == ',')
+			s = end+1;
+		else if (*end == 0)
+			break;
+		else
+			usage();
+	}
+	return 0;
+}
+
+void checkcounter(int cpu, int clear)
+{
+	int i;
+	for (i = 1; i < 4; i++) {
+		int clear_this = clear;
+		unsigned long long evtsel = rdmsr(cpu, PERFEVTSEL0 + i);
+		Vprintf("%d: %x %Lx\n", cpu, PERFEVTSEL0 + i, evtsel);
+		if (!(evtsel & PERFEVTSEL_EN)) {
+			Vprintf("reinit %d\n", cpu);
+			wrmsr(cpu, PERFEVTSEL0 + i, BASE | masks[i - 1]);
+			clear_this = 1;
+		} else if (evtsel == (BASE | (masks[i-1] << 8))) {
+			/* everything fine */
+		} else if (force) {
+			Vprintf("reinit force %d\n", cpu);
+			wrmsr(cpu, PERFEVTSEL0 + i, BASE | (masks[i - 1] << 8));
+			clear_this = 1;
+		} else {
+			fprintf(stderr, "perfctr %d cpu %d already used with %Lx\n",
+				i, cpu, evtsel);
+			fprintf(stderr, "Consider using -f if you know what you're doing.\n");
+			exit(1);
+		}
+		if (clear_this) {
+			Vprintf("clearing %d\n", cpu);
+			wrmsr(cpu, PERFCTR0 + i, 0);
+		}
+	}
+}
+
+void setup(int clear)
+{
+	DIR *dir;
+	struct dirent *d;
+	int numcpus = 0;
+
+	memset(msrfd, -1, sizeof(msrfd));
+	dir = opendir("/dev/cpu");
+	if (!dir)
+		err("cannot open /dev/cpu");
+	while ((d = readdir(dir)) != NULL) {
+		char buf[64];
+		char *end;
+		long cpunum = strtoul(d->d_name, &end, 0);
+		if (*end != 0)
+			continue;
+		if (cpunum > MAXCPU) {
+			fprintf(stderr, "too many cpus %ld %s\n", cpunum, d->d_name);
+			continue;
+		}
+		if (!cpufilter(cpunum))
+			continue;
+		snprintf(buf, 63, "/dev/cpu/%ld/msr", cpunum);
+		msrfd[cpunum] = open64(buf, O_RDWR);
+		if (msrfd[cpunum] < 0)
+			continue;
+		numcpus++;
+		checkcounter(cpunum, clear);
+	}
+	closedir(dir);
+	if (numcpus == 0) {
+		fprintf(stderr, "No CPU found using MSR driver.\n");
+		exit(1);
+	}
+}
+
+void printf_padded(int pad, char *fmt, ...)
+{
+	char buf[pad + 1];
+	va_list ap;
+	va_start(ap, fmt);
+	vsnprintf(buf, pad, fmt, ap);
+	printf("%-*s", pad, buf);
+	va_end(ap);
+}
+
+void print_header(void)
+{
+	printf_padded(4, "CPU ");
+	printf_padded(16, "LOCAL");
+	printf_padded(16, "LOCAL->REMOTE");
+	printf_padded(16, "REMOTE->LOCAL");
+	putchar('\n');
+}
+
+void print_cpu(int cpu)
+{
+	int i;
+	static unsigned long long lastval[4];
+	printf_padded(4, "%d", cpu);
+	for (i = 1; i < 4; i++) {
+		unsigned long long val = rdmsr(cpu, PERFCTR0 + i);
+		if (absolute)
+			printf_padded(16, "%Lu", val);
+		else
+			printf_padded(16, "%Lu", val - lastval[i]);
+		lastval[i] = val;
+	}
+	putchar('\n');
+}
+
+void dumpall(void)
+{
+	int cnt = 0;
+	int cpu;
+	print_header();
+	for (;;) {
+		for (cpu = 0; cpu < MAXCPU; ++cpu) {
+			if (msrfd[cpu] < 0)
+				continue;
+			print_cpu(cpu);
+		}
+		if (!delay)
+			break;
+		sleep(delay);
+		if (++cnt > 40) {
+			cnt = 0;
+			print_header();
+		}
+	}
+}
+
+void checkk8(void)
+{
+	char *line = NULL;
+	size_t size = 0;
+	int bad = 0;
+	FILE *f = fopen("/proc/cpuinfo", "r");
+	if (!f)
+		return;
+	while (getline(&line, &size, f) > 0) {
+		if (!strncmp("vendor_id", line, 9)) {
+			if (!strstr(line, "AMD"))
+				bad++;
+		}
+		if (!strncmp("cpu family", line, 10)) {
+			char *s = line + strcspn(line,":");
+			int family;
+			if (*s == ':') ++s;
+			family = strtoul(s, NULL, 0);
+			if (family != 15)
+				bad++;
+		}
+	}
+	if (bad) {
+		printf("not a opteron cpu\n");
+		exit(1);
+	}
+	free(line);
+	fclose(f);
+}
+
+void usage(void)
+{
+	fprintf(stderr, "usage: numamon [args] [delay]\n");
+	fprintf(stderr, "       -f forcibly overwrite counters\n");
+	fprintf(stderr, "       -i count IO (default memory)\n");
+	fprintf(stderr, "       -a print absolute counter values (with delay)\n");
+	fprintf(stderr, "       -s setup counters and exit\n");
+	fprintf(stderr, "       -c clear counters and exit\n");
+	fprintf(stderr, "       -m Print memory traffic (default)\n");
+	fprintf(stderr, "       -C cpu{,cpu} only print for cpus\n");
+	fprintf(stderr, "       -v Be verbose\n");
+	exit(1);
+}
+
+int main(int ac, char **av)
+{
+	int opt;
+	checkk8();
+	while ((opt = getopt(ac,av,"ifscmaC:v")) != -1) {
+		switch (opt) {
+		case 'f':
+			force = 1;
+			break;
+		case 'c':
+			setup(1);
+			exit(0);
+		case 's':
+			setup(0);
+			exit(0);
+		case 'm':
+			masks = mem;
+			break;
+		case 'i':
+			masks = io;
+			break;
+		case 'a':
+			absolute = 1;
+			break;
+		case 'C':
+			cfilter = optarg;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		default:
+			usage();
+		}
+	}
+	if (av[optind]) {
+		char *end;
+		delay = strtoul(av[optind], &end, 10);
+		if (*end)
+			usage();
+		if (av[optind+1])
+			usage();
+	}
+
+	setup(0);
+	dumpall();
+	return 0;
+}
diff --git a/numastat.8 b/numastat.8
new file mode 100644
index 0000000..4dcddf3
--- /dev/null
+++ b/numastat.8
@@ -0,0 +1,158 @@
+.TH "numastat" "8" "1.0.0" "Bill Gray" "Administration"
+.SH NAME
+.LP
+\fBnumastat\fP \- Show per-NUMA-node memory statistics for processes and the operating system
+.SH "SYNTAX"
+.LP
+\fBnumastat\fP
+.br
+.LP
+\fBnumastat\fP [\fI\-V\fP]
+.br
+.LP
+\fBnumastat\fP [\fI\<PID>|<pattern>...\fP]
+.br
+.LP
+\fBnumastat\fP [\fI\-c\fP] [\fI\-m\fP] [\fI\-n\fP] [\fI\-p <PID>|<pattern>\fP] [\fI\-s[<node>]\fP] [\fI\-v\fP] [\fI\-z\fP] [\fI\<PID>|<pattern>...\fP]
+.br
+.SH "DESCRIPTION"
+.LP
+.B numastat 
+with no command options or arguments at all, displays per-node NUMA hit and
+miss system statistics from the kernel memory allocator.  This default
+\fBnumastat\fP behavior is strictly compatible with the previous long-standing
+\fBnumastat\fP perl script, written by Andi Kleen.  The default \fBnumastat\fP
+statistics shows per-node numbers (in units of pages of memory) in these categories:
+.LP
+.B numa_hit 
+is memory successfully allocated on this node as intended.
+.LP
+.B numa_miss
+is memory allocated on this node despite the process preferring some different node. Each
+.I numa_miss
+has a
+.I numa_foreign
+on another node.
+.LP
+.B numa_foreign
+is memory intended for this node, but actually allocated on some different node.  Each
+.I numa_foreign
+has a
+.I numa_miss
+on another node.
+.LP
+.B interleave_hit
+is interleaved memory successfully allocated on this node as intended.
+.LP
+.B local_node
+is memory allocated on this node while a process was running on it.
+.LP
+.B other_node
+is memory allocated on this node while a process was running on some other node.
+.LP
+Any supplied options or arguments with the \fBnumastat\fP command will
+significantly change both the content and the format of the display.  Specified
+options will cause display units to change to megabytes of memory, and will
+change other specific behaviors of \fBnumastat\fP as described below.
+.SH "OPTIONS"
+.LP
+.TP
+\fB\-c\fR
+Minimize table display width by dynamically shrinking column widths based on
+data contents.  With this option, amounts of memory will be rounded to the
+nearest megabyte (rather than the usual display with two decimal places).
+Column width and inter-column spacing will be somewhat unpredictable with this
+option, but the more dense display will be very useful on systems with many
+NUMA nodes.
+.TP
+\fB\-m\fR
+Show the meminfo-like system-wide memory usage information.  This option
+produces a per-node breakdown of memory usage information similar to that found
+in /proc/meminfo.
+.TP
+\fB\-n\fR
+Show the original \fBnumastat\fP statistics info.  This will show the same
+information as the default \fBnumastat\fP behavior but the units will be megabytes of
+memory, and there will be other formatting and layout changes versus the
+original \fBnumastat\fP behavior.
+.TP
+\fB\-p\fR <\fBPID\fP> or <\fBpattern\fP>
+Show per-node memory allocation information for the specified PID or pattern.
+If the \-p argument is only digits, it is assumed to be a numerical PID.  If
+the argument characters are not only digits, it is assumed to be a text
+fragment pattern to search for in process command lines.  For example,
+\fBnumastat -p qemu\fP will attempt to find and show information for processes
+with "qemu" in the command line.  Any command line arguments remaining after
+\fBnumastat\fP option flag processing is completed, are assumed to be
+additional <\fBPID\fP> or <\fBpattern\fP> process specifiers.  In this sense,
+the \fB\-p\fP option flag is optional: \fBnumastat qemu\fP is equivalent to
+\fBnumastat -p qemu\fP
+.TP
+\fB\-s[<node>]\fR
+Sort the table data in descending order before displaying it, so the biggest
+memory consumers are listed first.  With no specified <node>, the table will be
+sorted by the total column.  If the optional <node> argument is supplied, the
+data will be sorted by the <node> column.  Note that <node> must follow the
+\fB\-s\fP immediately with no intermediate white space (e.g., \fBnumastat
+\-s2\fP). Because \fB\-s\fP can allow an optional argument, it must always be
+the last option character in a compound option character string. For example,
+instead of \fBnumastat \-msc\fP (which probably will not work as you expect),
+use \fBnumastat \-mcs\fP
+.TP
+\fB\-v\fR
+Make some reports more verbose.  In particular, process information for
+multiple processes will display detailed information for each process.
+Normally when per-node information for multiple processes is displayed, only
+the total lines are shown.
+.TP
+\fB\-V\fR
+Display \fBnumastat\fP version information and exit.
+.TP
+\fB\-z\fR
+Skip display of table rows and columns of only zero valuess.  This can be used
+to greatly reduce the amount of uninteresting zero data on systems with many
+NUMA nodes.  Note that when rows or columns of zeros are still displayed with
+this option, that probably means there is at least one value in the row or
+column that is actually non-zero, but rounded to zero for display.
+.SH NOTES 
+\fBnumastat\fP attempts to fold each table display so it will be conveniently
+readable on the output terminal.  Normally a terminal width of 80 characters is
+assumed.  When the \fBresize\fP command is available, \fBnumastat\fP attempts
+to dynamically determine and fine tune the output tty width from \fBresize\fP
+output.  If \fBnumastat\fP output is not to a tty, very long output lines can
+be produced, depending on how many NUMA nodes are present.  In all cases,
+output width can be explicitly specified via the \fBNUMASTAT_WIDTH\fP
+environment variable.  For example, \fBNUMASTAT_WIDTH=100  numastat\fP.  On
+systems with many NUMA nodes, \fBnumastat \-c \-z ....\fP can be very helpful
+to selectively reduce the amount of displayed information.
+.SH "ENVIRONMENT VARIABLES"
+.LP
+.TP
+NUMASTAT_WIDTH
+.SH "FILES"
+.LP
+\fI/proc/*/numa_maps\fP
+.br
+\fI/sys/devices/system/node/node*/meminfo\fP
+.br
+\fI/sys/devices/system/node/node*/numastat\fP
+.SH "EXAMPLES"
+.I numastat \-c \-z \-m \-n
+.br
+.I numastat \-czs libvirt kvm qemu
+.br
+.I watch \-n1 numastat
+.br
+.I watch \-n1 \-\-differences=cumulative numastat
+.SH "AUTHORS"
+.LP
+The original \fBnumastat\fP perl script was written circa 2003 by Andi Kleen
+<andi.kleen@intel.com>.  The current \fBnumastat\fP program was written in 2012
+by Bill Gray <bgray@redhat.com> to be compatible by default with the original,
+and to add options to display per-node system memory usage and per-node process
+memory allocation.
+.SH "SEE ALSO"
+.LP
+.BR numactl (8),
+.BR set_mempolicy( 2),
+.BR numa (3)
diff --git a/numastat.c b/numastat.c
new file mode 100644
index 0000000..92d8496
--- /dev/null
+++ b/numastat.c
@@ -0,0 +1,1480 @@
+/*
+
+numastat - NUMA monitoring tool to show per-node usage of memory
+Copyright (C) 2012 Bill Gray (bgray@redhat.com), Red Hat Inc
+
+numastat 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; version 2.1.
+
+numastat 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 find a copy of v2.1 of the GNU Lesser General Public License
+somewhere on your Linux system; if not, write to the Free Software Foundation,
+Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+*/
+
+/*
+
+Historical note: From approximately 2003 to 2012, numastat was a perl script
+written by Andi Kleen to display the /sys/devices/system/node/node<N>/numastat
+statistics. In 2012, numastat was rewritten as a C program by Red Hat to
+display per-node memory data for applications and the system in general,
+while also remaining strictly compatible by default with the original numastat.
+A copy of the original numastat perl script is included for reference at the
+end of this file.
+
+*/
+
+// Compile with: gcc -O -std=gnu99 -Wall -o numastat numastat.c
+
+#define __USE_MISC
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define STRINGIZE(s) #s
+#define STRINGIFY(s) STRINGIZE(s)
+
+#define KILOBYTE (1024)
+#define MEGABYTE (1024 * 1024)
+
+#define BUF_SIZE 2048
+#define SMALL_BUF_SIZE 128
+
+// Don't assume nodes are sequential or contiguous.
+// Need to discover and map node numbers.
+
+int *node_ix_map = NULL;
+char **node_header;
+
+// Structure to organize memory info from /proc/<PID>/numa_maps for a specific
+// process, or from /sys/devices/system/node/node?/meminfo for system-wide
+// data. Tables are defined below for each process and for system-wide data.
+
+typedef struct meminfo {
+	int index;
+	char *token;
+	char *label;
+} meminfo_t, *meminfo_p;
+
+#define PROCESS_HUGE_INDEX    0
+#define PROCESS_PRIVATE_INDEX 3
+
+meminfo_t process_meminfo[] = {
+	{ PROCESS_HUGE_INDEX,  "huge", "Huge" },
+	{        1,            "heap", "Heap" },
+	{        2,            "stack", "Stack" },
+	{ PROCESS_PRIVATE_INDEX, "N", "Private" }
+};
+
+#define PROCESS_MEMINFO_ROWS (sizeof(process_meminfo) / sizeof(process_meminfo[0]))
+
+meminfo_t numastat_meminfo[] = {
+	{ 0, "numa_hit", "Numa_Hit" },
+	{ 1, "numa_miss", "Numa_Miss" },
+	{ 2, "numa_foreign", "Numa_Foreign" },
+	{ 3, "interleave_hit", "Interleave_Hit" },
+	{ 4, "local_node", "Local_Node" },
+	{ 5, "other_node", "Other_Node" },
+};
+
+#define NUMASTAT_MEMINFO_ROWS (sizeof(numastat_meminfo) / sizeof(numastat_meminfo[0]))
+
+meminfo_t system_meminfo[] = {
+	{  0, "MemTotal", "MemTotal" },
+	{  1, "MemFree", "MemFree" },
+	{  2, "MemUsed", "MemUsed" },
+	{  3, "HighTotal", "HighTotal" },
+	{  4, "HighFree", "HighFree" },
+	{  5, "LowTotal", "LowTotal" },
+	{  6, "LowFree", "LowFree" },
+	{  7, "Active", "Active" },
+	{  8, "Inactive", "Inactive" },
+	{  9, "Active(anon)", "Active(anon)" },
+	{ 10, "Inactive(anon)", "Inactive(anon)" },
+	{ 11, "Active(file)", "Active(file)" },
+	{ 12, "Inactive(file)", "Inactive(file)" },
+	{ 13, "Unevictable", "Unevictable" },
+	{ 14, "Mlocked", "Mlocked" },
+	{ 15, "Dirty", "Dirty" },
+	{ 16, "Writeback", "Writeback" },
+	{ 17, "FilePages", "FilePages" },
+	{ 18, "Mapped", "Mapped" },
+	{ 19, "AnonPages", "AnonPages" },
+	{ 20, "Shmem", "Shmem" },
+	{ 21, "KernelStack", "KernelStack" },
+	{ 22, "PageTables", "PageTables" },
+	{ 23, "NFS_Unstable", "NFS_Unstable" },
+	{ 24, "Bounce", "Bounce" },
+	{ 25, "WritebackTmp", "WritebackTmp" },
+	{ 26, "Slab", "Slab" },
+	{ 27, "SReclaimable", "SReclaimable" },
+	{ 28, "SUnreclaim", "SUnreclaim" },
+	{ 29, "AnonHugePages", "AnonHugePages" },
+	{ 30, "HugePages_Total", "HugePages_Total" },
+	{ 31, "HugePages_Free", "HugePages_Free" },
+	{ 32, "HugePages_Surp", "HugePages_Surp" }
+};
+
+#define SYSTEM_MEMINFO_ROWS (sizeof(system_meminfo) / sizeof(system_meminfo[0]))
+
+// To allow re-ordering the meminfo memory categories in system_meminfo and
+// numastat_meminfo relative to order in /proc, etc., a simple hash index is
+// used to look up the meminfo categories. The allocated hash table size must
+// be bigger than necessary to reduce collisions (and because these specific
+// hash algorithms depend on having some unused buckets.
+
+#define HASH_TABLE_SIZE 151
+int hash_collisions = 0;
+
+struct hash_entry {
+	char *name;
+	int index;
+} hash_table[HASH_TABLE_SIZE];
+
+void init_hash_table() {
+	memset(hash_table, 0, sizeof(hash_table));
+}
+
+int hash_ix(char *s) {
+	unsigned int h = 17;
+	while (*s) {
+		// h * 33 + *s++
+		h = ((h << 5) + h) + *s++;
+	}
+	return (h % HASH_TABLE_SIZE);
+}
+
+int hash_lookup(char *s) {
+	int ix = hash_ix(s);
+	while (hash_table[ix].name) {	// Assumes big table with blank entries
+		if (!strcmp(s, hash_table[ix].name)) {
+			return hash_table[ix].index;	// found it
+		}
+		ix += 1;
+		if (ix >= HASH_TABLE_SIZE) {
+			ix = 0;
+		}
+	}
+	return -1;
+}
+
+int hash_insert(char *s, int i) {
+	int ix = hash_ix(s);
+	while (hash_table[ix].name) {	// assumes no duplicate entries
+		hash_collisions += 1;
+		ix += 1;
+		if (ix >= HASH_TABLE_SIZE) {
+			ix = 0;
+		}
+	}
+	hash_table[ix].name = s;
+	hash_table[ix].index = i;
+	return ix;
+}
+
+// To decouple details of table display (e.g. column width, line folding for
+// display screen width, et cetera) from acquiring the data and populating the
+// tables, this semi-general table handling code is used.  There are various
+// routines to set table attributes, assign and test some cell contents,
+// initialize and actually display the table.
+
+#define CELL_TYPE_NULL     0
+#define CELL_TYPE_LONG     1
+#define CELL_TYPE_DOUBLE   2
+#define CELL_TYPE_STRING   3
+#define CELL_TYPE_CHAR8    4
+#define CELL_TYPE_REPCHAR  5
+
+#define CELL_FLAG_FREEABLE (1 << 0)
+#define CELL_FLAG_ROWSPAN  (1 << 1)
+#define CELL_FLAG_COLSPAN  (1 << 2)
+
+#define COL_JUSTIFY_LEFT       (1 << 0)
+#define COL_JUSTIFY_RIGHT      (1 << 1)
+#define COL_JUSTIFY_CENTER     3
+#define COL_JUSTIFY_MASK       0x3
+#define COL_FLAG_SEEN_DATA     (1 << 2)
+#define COL_FLAG_NON_ZERO_DATA (1 << 3)
+#define COL_FLAG_ALWAYS_SHOW   (1 << 4)
+
+#define ROW_FLAG_SEEN_DATA     COL_FLAG_SEEN_DATA
+#define ROW_FLAG_NON_ZERO_DATA COL_FLAG_NON_ZERO_DATA
+#define ROW_FLAG_ALWAYS_SHOW   COL_FLAG_ALWAYS_SHOW
+
+typedef struct cell {
+	uint32_t type;
+	uint32_t flags;
+	union {
+		char *s;
+		double d;
+		int64_t l;
+		char c[8];
+	};
+} cell_t, *cell_p;
+
+typedef struct vtab {
+	int header_rows;
+	int header_cols;
+	int data_rows;
+	int data_cols;
+	cell_p cell;
+	int *row_ix_map;
+	uint8_t *row_flags;
+	uint8_t *col_flags;
+	uint8_t *col_width;
+	uint8_t *col_decimal_places;
+} vtab_t, *vtab_p;
+
+#define ALL_TABLE_ROWS (table->header_rows + table->data_rows)
+#define ALL_TABLE_COLS (table->header_cols + table->data_cols)
+#define GET_CELL_PTR(row, col) (&table->cell[(row * ALL_TABLE_COLS) + col])
+
+#define USUAL_GUTTER_WIDTH 1
+
+void set_row_flag(vtab_p table, int row, int flag) {
+	table->row_flags[row] |= (uint8_t)flag;
+}
+
+void set_col_flag(vtab_p table, int col, int flag) {
+	table->col_flags[col] |= (uint8_t)flag;
+}
+
+void clear_row_flag(vtab_p table, int row, int flag) {
+	table->row_flags[row] &= (uint8_t)~flag;
+}
+
+void clear_col_flag(vtab_p table, int col, int flag) {
+	table->col_flags[col] &= (uint8_t)~flag;
+}
+
+int test_row_flag(vtab_p table, int row, int flag) {
+	return ((table->row_flags[row] & (uint8_t)flag) != 0);
+}
+
+int test_col_flag(vtab_p table, int col, int flag) {
+	return ((table->col_flags[col] & (uint8_t)flag) != 0);
+}
+
+void set_col_justification(vtab_p table, int col, int justify) {
+	table->col_flags[col] &= (uint8_t)~COL_JUSTIFY_MASK;
+	table->col_flags[col] |= (uint8_t)(justify & COL_JUSTIFY_MASK);
+}
+
+void set_col_width(vtab_p table, int col, uint8_t width) {
+	if (width >= SMALL_BUF_SIZE) {
+		width = SMALL_BUF_SIZE - 1;
+	}
+	table->col_width[col] = width;
+}
+
+void set_col_decimal_places(vtab_p table, int col, uint8_t places) {
+	table->col_decimal_places[col] = places;
+}
+
+void set_cell_flag(vtab_p table, int row, int col, int flag) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->flags |= (uint32_t)flag;
+}
+
+void clear_cell_flag(vtab_p table, int row, int col, int flag) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->flags &= (uint32_t)~flag;
+}
+
+int test_cell_flag(vtab_p table, int row, int col, int flag) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	return ((c_ptr->flags & (uint32_t)flag) != 0);
+}
+
+void string_assign(vtab_p table, int row, int col, char *s) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->type = CELL_TYPE_STRING;
+	c_ptr->s = s;
+}
+
+void repchar_assign(vtab_p table, int row, int col, char c) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->type = CELL_TYPE_REPCHAR;
+	c_ptr->c[0] = c;
+}
+
+void double_assign(vtab_p table, int row, int col, double d) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->type = CELL_TYPE_DOUBLE;
+	c_ptr->d = d;
+}
+
+void long_assign(vtab_p table, int row, int col, int64_t l) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->type = CELL_TYPE_LONG;
+	c_ptr->l = l;
+}
+
+void double_addto(vtab_p table, int row, int col, double d) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->type = CELL_TYPE_DOUBLE;
+	c_ptr->d += d;
+}
+
+void long_addto(vtab_p table, int row, int col, int64_t l) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	c_ptr->type = CELL_TYPE_LONG;
+	c_ptr->l += l;
+}
+
+void clear_assign(vtab_p table, int row, int col) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	memset(c_ptr, 0, sizeof(cell_t));
+}
+
+void zero_table_data(vtab_p table, int type) {
+	// Sets data area of table to zeros of specified type
+	for (int row = table->header_rows; (row < ALL_TABLE_ROWS); row++) {
+		for (int col = table->header_cols; (col < ALL_TABLE_COLS); col++) {
+			cell_p c_ptr = GET_CELL_PTR(row, col);
+			memset(c_ptr, 0, sizeof(cell_t));
+			c_ptr->type = type;
+		}
+	}
+}
+
+void sort_rows_descending_by_col(vtab_p table, int start_row, int stop_row, int col) {
+	// Rearrange row_ix_map[] indices so the rows will be in
+	// descending order by the value in the specified column
+	for (int ix = start_row; (ix <= stop_row); ix++) {
+		int biggest_ix = ix;
+		cell_p biggest_ix_c_ptr = GET_CELL_PTR(table->row_ix_map[ix], col);
+		for (int iy = ix + 1; (iy <= stop_row); iy++) {
+			cell_p iy_c_ptr = GET_CELL_PTR(table->row_ix_map[iy], col);
+			if (biggest_ix_c_ptr->d < iy_c_ptr->d) {
+				biggest_ix_c_ptr = iy_c_ptr;
+				biggest_ix = iy;
+			}
+		}
+		if (biggest_ix != ix) {
+			int tmp = table->row_ix_map[ix];
+			table->row_ix_map[ix] = table->row_ix_map[biggest_ix];
+			table->row_ix_map[biggest_ix] = tmp;
+		}
+	}
+}
+
+void span(vtab_p table, int first_row, int first_col, int last_row, int last_col) {
+	// FIXME: implement row / col spannnig someday?
+}
+
+void init_table(vtab_p table, int header_rows, int header_cols, int data_rows, int data_cols) {
+	// init table sizes
+	table->header_rows = header_rows;
+	table->header_cols = header_cols;
+	table->data_rows = data_rows;
+	table->data_cols = data_cols;
+	// allocate memory for all the cells
+	int alloc_size = ALL_TABLE_ROWS * ALL_TABLE_COLS * sizeof(cell_t);
+	table->cell = malloc(alloc_size);
+	if (table->cell == NULL) {
+		perror("malloc failed line: " STRINGIFY(__LINE__));
+		exit(EXIT_FAILURE);
+	}
+	memset(table->cell, 0, alloc_size);
+	// allocate memory for the row map vector
+	alloc_size = ALL_TABLE_ROWS * sizeof(int);
+	table->row_ix_map = malloc(alloc_size);
+	if (table->row_ix_map == NULL) {
+		perror("malloc failed line: " STRINGIFY(__LINE__));
+		exit(EXIT_FAILURE);
+	}
+	for (int row = 0; (row < ALL_TABLE_ROWS); row++) {
+		table->row_ix_map[row] = row;
+	}
+	// allocate memory for the row flags vector
+	alloc_size = ALL_TABLE_ROWS * sizeof(uint8_t);
+	table->row_flags = malloc(alloc_size);
+	if (table->row_flags == NULL) {
+		perror("malloc failed line: " STRINGIFY(__LINE__));
+		exit(EXIT_FAILURE);
+	}
+	memset(table->row_flags, 0, alloc_size);
+	// allocate memory for the column flags vector
+	alloc_size = ALL_TABLE_COLS * sizeof(uint8_t);
+	table->col_flags = malloc(alloc_size);
+	if (table->col_flags == NULL) {
+		perror("malloc failed line: " STRINGIFY(__LINE__));
+		exit(EXIT_FAILURE);
+	}
+	memset(table->col_flags, 0, alloc_size);
+	// allocate memory for the column width vector
+	alloc_size = ALL_TABLE_COLS * sizeof(uint8_t);
+	table->col_width = malloc(alloc_size);
+	if (table->col_width == NULL) {
+		perror("malloc failed line: " STRINGIFY(__LINE__));
+		exit(EXIT_FAILURE);
+	}
+	memset(table->col_width, 0, alloc_size);
+	// allocate memory for the column precision vector
+	alloc_size = ALL_TABLE_COLS * sizeof(uint8_t);
+	table->col_decimal_places = malloc(alloc_size);
+	if (table->col_decimal_places == NULL) {
+		perror("malloc failed line: " STRINGIFY(__LINE__));
+		exit(EXIT_FAILURE);
+	}
+	memset(table->col_decimal_places, 0, alloc_size);
+}
+
+void free_cell(vtab_p table, int row, int col) {
+	cell_p c_ptr = GET_CELL_PTR(row, col);
+	if ((c_ptr->type == CELL_TYPE_STRING)
+	    && (c_ptr->flags & CELL_FLAG_FREEABLE)
+	    && (c_ptr->s != NULL)) {
+		free(c_ptr->s);
+	}
+	memset(c_ptr, 0, sizeof(cell_t));
+}
+
+void free_table(vtab_p table) {
+	if (table->cell != NULL) {
+		for (int row = 0; (row < ALL_TABLE_ROWS); row++) {
+			for (int col = 0; (col < ALL_TABLE_COLS); col++) {
+				free_cell(table, row, col);
+			}
+		}
+		free(table->cell);
+	}
+	if (table->row_ix_map != NULL) {
+		free(table->row_ix_map);
+	}
+	if (table->row_flags != NULL) {
+		free(table->row_flags);
+	}
+	if (table->col_flags != NULL) {
+		free(table->col_flags);
+	}
+	if (table->col_width != NULL) {
+		free(table->col_width);
+	}
+	if (table->col_decimal_places != NULL) {
+		free(table->col_decimal_places);
+	}
+}
+
+char *fmt_cell_data(cell_p c_ptr, int max_width, int decimal_places) {
+	// Returns pointer to a static buffer, expecting caller to
+	// immediately use or copy the contents before calling again.
+	int rep_width = max_width - USUAL_GUTTER_WIDTH;
+	static char buf[SMALL_BUF_SIZE];
+	switch (c_ptr->type) {
+	case CELL_TYPE_NULL:
+		buf[0] = '\0';
+		break;
+	case CELL_TYPE_LONG:
+		snprintf(buf, SMALL_BUF_SIZE, "%ld", c_ptr->l);
+		break;
+	case CELL_TYPE_DOUBLE:
+		snprintf(buf, SMALL_BUF_SIZE, "%.*f", decimal_places, c_ptr->d);
+		break;
+	case CELL_TYPE_STRING:
+		snprintf(buf, SMALL_BUF_SIZE, "%s", c_ptr->s);
+		break;
+	case CELL_TYPE_CHAR8:
+		strncpy(buf, c_ptr->c, 8);
+		buf[8] = '\0';
+		break;
+	case CELL_TYPE_REPCHAR:
+		memset(buf, c_ptr->c[0], rep_width);
+		buf[rep_width] = '\0';
+		break;
+	default:
+		strcpy(buf, "Unknown");
+		break;
+	}
+	buf[max_width] = '\0';
+	return buf;
+}
+
+void auto_set_col_width(vtab_p table, int col, int min_width, int max_width) {
+	int width = min_width;
+	for (int row = 0; (row < ALL_TABLE_ROWS); row++) {
+		cell_p c_ptr = GET_CELL_PTR(row, col);
+		if (c_ptr->type == CELL_TYPE_REPCHAR) {
+			continue;
+		}
+		char *p = fmt_cell_data(c_ptr, max_width, (int)(table->col_decimal_places[col]));
+		int l = strlen(p);
+		if (width < l) {
+			width = l;
+		}
+	}
+	width += USUAL_GUTTER_WIDTH;
+	if (width > max_width) {
+		width = max_width;
+	}
+	table->col_width[col] = (uint8_t)width;
+}
+
+void display_justified_cell(cell_p c_ptr, int row_flags, int col_flags, int width, int decimal_places) {
+	char *p = fmt_cell_data(c_ptr, width, decimal_places);
+	int l = strlen(p);
+	char buf[SMALL_BUF_SIZE];
+	switch (col_flags & COL_JUSTIFY_MASK) {
+	case COL_JUSTIFY_LEFT:
+		memcpy(buf, p, l);
+		if (l < width) {
+			memset(&buf[l], ' ', width - l);
+		}
+		break;
+	case COL_JUSTIFY_RIGHT:
+		if (l < width) {
+			memset(buf, ' ', width - l);
+		}
+		memcpy(&buf[width - l], p, l);
+		break;
+	case COL_JUSTIFY_CENTER:
+	default:
+		memset(buf, ' ', width);
+		memcpy(&buf[(width - l + 1) / 2], p, l);
+		break;
+	}
+	buf[width] = '\0';
+	printf("%s", buf);
+}
+
+void display_table(vtab_p table,
+		      int screen_width,
+		      int show_unseen_rows,
+		      int show_unseen_cols,
+		      int show_zero_rows,
+		      int show_zero_cols)
+{
+	// Set row and column flags according to whether data in rows and cols
+	// has been assigned, and is currently non-zero.
+	int some_seen_data = 0;
+	int some_non_zero_data = 0;
+	for (int row = table->header_rows; (row < ALL_TABLE_ROWS); row++) {
+		for (int col = table->header_cols; (col < ALL_TABLE_COLS); col++) {
+			cell_p c_ptr = GET_CELL_PTR(row, col);
+			// Currently, "seen data" includes not only numeric data, but also
+			// any strings, etc -- anything non-NULL (other than rephcars).
+			if ((c_ptr->type != CELL_TYPE_NULL) && (c_ptr->type != CELL_TYPE_REPCHAR)) {
+				some_seen_data = 1;
+				set_row_flag(table, row, ROW_FLAG_SEEN_DATA);
+				set_col_flag(table, col, COL_FLAG_SEEN_DATA);
+				// Currently, "non-zero data" includes not only numeric data,
+				// but also any strings, etc -- anything non-zero (other than
+				// repchars, which are already excluded above).  So, note a
+				// valid non-NULL pointer to an empty string would still be
+				// counted as non-zero data.
+				if (c_ptr->l != (int64_t)0) {
+					some_non_zero_data = 1;
+					set_row_flag(table, row, ROW_FLAG_NON_ZERO_DATA);
+					set_col_flag(table, col, COL_FLAG_NON_ZERO_DATA);
+				}
+			}
+		}
+	}
+	if (!some_seen_data) {
+		printf("Table has no data.\n");
+		return;
+	}
+	if (!some_non_zero_data && !show_zero_rows && !show_zero_cols) {
+		printf("Table has no non-zero data.\n");
+		return;
+	}
+	// Start with first data column and try to display table,
+	// folding lines as necessary per screen_width
+	int col = -1;
+	int data_col = table->header_cols;
+	while (data_col < ALL_TABLE_COLS) {
+		// Skip data columns until we have one to display
+		if ((!test_col_flag(table, data_col, COL_FLAG_ALWAYS_SHOW)) &&
+		    (((!show_unseen_cols) && (!test_col_flag(table, data_col, COL_FLAG_SEEN_DATA))) ||
+		     ((!show_zero_cols)   && (!test_col_flag(table, data_col, COL_FLAG_NON_ZERO_DATA))))) {
+			data_col += 1;
+			continue;
+		}
+		// Display blank line between table sections
+		if (col > 0) {
+			printf("\n");
+		}
+		// For each row, display as many columns as possible
+		for (int row_ix = 0; (row_ix < ALL_TABLE_ROWS); row_ix++) {
+			int row = table->row_ix_map[row_ix];
+			// If past the header rows, conditionally skip rows
+			if ((row >= table->header_rows) && (!test_row_flag(table, row, ROW_FLAG_ALWAYS_SHOW))) {
+				// Optionally skip row if no data seen or if all zeros
+				if (((!show_unseen_rows) && (!test_row_flag(table, row, ROW_FLAG_SEEN_DATA))) ||
+				    ((!show_zero_rows)   && (!test_row_flag(table, row, ROW_FLAG_NON_ZERO_DATA)))) {
+					continue;
+				}
+			}
+			// Begin a new row...
+			int cur_line_width = 0;
+			// All lines start with the left header columns
+			for (col = 0; (col < table->header_cols); col++) {
+				display_justified_cell(GET_CELL_PTR(row, col),
+						       (int)(table->row_flags[row]),
+						       (int)(table->col_flags[col]),
+						       (int)(table->col_width[col]),
+						       (int)(table->col_decimal_places[col]));
+				cur_line_width += (int)(table->col_width[col]);
+			}
+			// Reset column index to starting data column for each new row
+			col = data_col;
+			// Try to display as many data columns as possible in every section
+			for (;;) {
+				// See if we should print this column
+				if (test_col_flag(table, col, COL_FLAG_ALWAYS_SHOW) ||
+				    (((show_unseen_cols) || (test_col_flag(table, col, COL_FLAG_SEEN_DATA))) &&
+				     ((show_zero_cols)   || (test_col_flag(table, col, COL_FLAG_NON_ZERO_DATA))))) {
+					display_justified_cell(GET_CELL_PTR(row, col),
+							       (int)(table->row_flags[row]),
+							       (int)(table->col_flags[col]),
+							       (int)(table->col_width[col]),
+							       (int)(table->col_decimal_places[col]));
+					cur_line_width += (int)(table->col_width[col]);
+				}
+				col += 1;
+				// End the line if no more columns or next column would exceed screen width
+				if ((col >= ALL_TABLE_COLS) ||
+				    ((cur_line_width + (int)(table->col_width[col])) > screen_width)) {
+					break;
+				}
+			}
+			printf("\n");
+		}
+		// Remember next starting data column for next section
+		data_col = col;
+	}
+}
+
+int verbose = 0;
+int num_pids = 0;
+int num_nodes = 0;
+int screen_width = 0;
+int show_zero_data = 1;
+int compress_display = 0;
+int sort_table = 0;
+int sort_table_node = -1;
+int compatibility_mode = 0;
+int pid_array_max_pids = 0;
+int *pid_array = NULL;
+char *prog_name = NULL;
+double page_size_in_bytes = 0;
+double huge_page_size_in_bytes = 0;
+
+void display_version_and_exit() {
+	char *version_string = "20130723";
+	printf("%s version: %s: %s\n", prog_name, version_string, __DATE__);
+	exit(EXIT_SUCCESS);
+}
+
+void display_usage_and_exit() {
+	fprintf(stderr, "Usage: %s [-c] [-m] [-n] [-p <PID>|<pattern>] [-s[<node>]] [-v] [-V] [-z] [ <PID>|<pattern>... ]\n", prog_name);
+	fprintf(stderr, "-c to minimize column widths\n");
+	fprintf(stderr, "-m to show meminfo-like system-wide memory usage\n");
+	fprintf(stderr, "-n to show the numastat statistics info\n");
+	fprintf(stderr, "-p <PID>|<pattern> to show process info\n");
+	fprintf(stderr, "-s[<node>] to sort data by total column or <node>\n");
+	fprintf(stderr, "-v to make some reports more verbose\n");
+	fprintf(stderr, "-V to show the %s code version\n", prog_name);
+	fprintf(stderr, "-z to skip rows and columns of zeros\n");
+	exit(EXIT_FAILURE);
+}
+
+int get_screen_width() {
+	int width = 80;
+	char *p = getenv("NUMASTAT_WIDTH");
+	if (p != NULL) {
+		width = atoi(p);
+		if ((width < 1) || (width > 10000000)) {
+			width = 80;
+		}
+	} else if (isatty(fileno(stdout))) {
+		FILE *fs = popen("resize 2>/dev/null", "r");
+		if (fs != NULL) {
+			char buf[72];
+			char *columns;
+			columns = fgets(buf, sizeof(columns), fs);
+			pclose(fs);
+			if (columns && strncmp(columns, "COLUMNS=", 8) == 0) {
+				width = atoi(&columns[8]);
+				if ((width < 1) || (width > 10000000)) {
+					width = 80;
+				}
+			}
+		}
+	} else {
+		// Not a tty, so allow a really long line
+		width = 10000000;
+	}
+	if (width < 32) {
+		width = 32;
+	}
+	return width;
+}
+
+char *command_name_for_pid(int pid) {
+	// Get the PID command name field from /proc/PID/status file.  Return
+	// pointer to a static buffer, expecting caller to immediately copy result.
+	static char buf[SMALL_BUF_SIZE];
+	char fname[64];
+	snprintf(fname, sizeof(fname), "/proc/%d/status", pid);
+	FILE *fs = fopen(fname, "r");
+	if (!fs) {
+		return NULL;
+	} else {
+		while (fgets(buf, SMALL_BUF_SIZE, fs)) {
+			if (strstr(buf, "Name:") == buf) {
+				char *p = &buf[5];
+				while (isspace(*p)) {
+					p++;
+				}
+				if (p[strlen(p) - 1] == '\n') {
+					p[strlen(p) - 1] = '\0';
+				}
+				fclose(fs);
+				return p;
+			}
+		}
+		fclose(fs);
+	}
+	return NULL;
+}
+
+void show_info_from_system_file(char *file, meminfo_p meminfo, int meminfo_rows, int tok_offset) {
+	// Setup and init table
+	vtab_t table;
+	int header_rows = 2 - compatibility_mode;
+	int header_cols = 1;
+	// Add an extra data column for a total column
+	init_table(&table, header_rows, header_cols, meminfo_rows, num_nodes + 1);
+	int total_col_ix = header_cols + num_nodes;
+	// Insert token mapping in hash table and assign left header column label for each row in table
+	init_hash_table();
+	for (int row = 0; (row < meminfo_rows); row++) {
+		hash_insert(meminfo[row].token, meminfo[row].index);
+		if (compatibility_mode) {
+			string_assign(&table, (header_rows + row), 0, meminfo[row].token);
+		} else {
+			string_assign(&table, (header_rows + row), 0, meminfo[row].label);
+		}
+	}
+	// printf("There are %d table hash collisions.\n", hash_collisions);
+	// Set left header column width and left justify it
+	set_col_width(&table, 0, 16);
+	set_col_justification(&table, 0, COL_JUSTIFY_LEFT);
+	// Open /sys/devices/system/node/node?/<file> for each node and store data
+	// in table.  If not compatibility_mode, do approximately first third of
+	// this loop also for (node_ix == num_nodes) to get "Total" column header.
+	for (int node_ix = 0; (node_ix < (num_nodes + (1 - compatibility_mode))); node_ix++) {
+		int col = header_cols + node_ix;
+		// Assign header row label and horizontal line for this column...
+		string_assign(&table, 0, col, node_header[node_ix]);
+		if (!compatibility_mode) {
+			repchar_assign(&table, 1, col, '-');
+			int decimal_places = 2;
+			if (compress_display) {
+				decimal_places = 0;
+			}
+			set_col_decimal_places(&table, col, decimal_places);
+		}
+		// Set column width and right justify data
+		set_col_width(&table, col, 16);
+		set_col_justification(&table, col, COL_JUSTIFY_RIGHT);
+		if (node_ix == num_nodes) {
+			break;
+		}
+		// Open /sys/.../node<N>/numstast file for this node...
+		char buf[SMALL_BUF_SIZE];
+		char fname[64];
+		snprintf(fname, sizeof(fname), "/sys/devices/system/node/node%d/%s", node_ix_map[node_ix], file);
+		FILE *fs = fopen(fname, "r");
+		if (!fs) {
+			sprintf(buf, "cannot open %s", fname);
+			perror(buf);
+			exit(EXIT_FAILURE);
+		}
+		// Get table values for this node...
+		while (fgets(buf, SMALL_BUF_SIZE, fs)) {
+			char *tok[64];
+			int tokens = 0;
+			const char *delimiters = " \t\r\n:";
+			char *p = strtok(buf, delimiters);
+			if (p == NULL) {
+				continue;	// Skip blank lines;
+			}
+			while (p) {
+				tok[tokens++] = p;
+				p = strtok(NULL, delimiters);
+			}
+			// example line from numastat file: "numa_miss 16463"
+			// example line from meminfo  file: "Node 3 Inactive:  210680 kB"
+			int index = hash_lookup(tok[0 + tok_offset]);
+			if (index < 0) {
+				printf("Token %s not in hash table.\n", tok[0]);
+			} else {
+				double value = (double)atol(tok[1 + tok_offset]);
+				if (!compatibility_mode) {
+					double multiplier = 1.0;
+					if (tokens < 4) {
+						multiplier = page_size_in_bytes;
+					} else if (!strncmp("HugePages", tok[2], 9)) {
+						multiplier = huge_page_size_in_bytes;
+					} else if (!strncmp("kB", tok[4], 2)) {
+						multiplier = KILOBYTE;
+					}
+					value *= multiplier;
+					value /= (double)MEGABYTE;
+				}
+				double_assign(&table, header_rows + index, col, value);
+				double_addto(&table, header_rows + index, total_col_ix, value);
+			}
+		}
+		fclose(fs);
+	}
+	// Crompress display column widths, if requested
+	if (compress_display) {
+		for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
+			auto_set_col_width(&table, col, 4, 16);
+		}
+	}
+	// Optionally sort the table data
+	if (sort_table) {
+		int sort_col;
+		if ((sort_table_node < 0) || (sort_table_node >= num_nodes)) {
+			sort_col = total_col_ix;
+		} else {
+			sort_col = header_cols + node_ix_map[sort_table_node];
+		}
+		sort_rows_descending_by_col(&table, header_rows, header_rows + meminfo_rows - 1, sort_col);
+	}
+	// Actually display the table now, doing line-folding as necessary
+	display_table(&table, screen_width, 0, 0, show_zero_data, show_zero_data);
+	free_table(&table);
+}
+
+void show_numastat_info() {
+	if (!compatibility_mode) {
+		printf("\nPer-node numastat info (in MBs):\n");
+	}
+	show_info_from_system_file("numastat", numastat_meminfo, NUMASTAT_MEMINFO_ROWS, 0);
+}
+
+void show_system_info() {
+	printf("\nPer-node system memory usage (in MBs):\n");
+	show_info_from_system_file("meminfo", system_meminfo, SYSTEM_MEMINFO_ROWS, 2);
+}
+
+void show_process_info() {
+	vtab_t table;
+	int header_rows = 2;
+	int header_cols = 1;
+	int data_rows;
+	int show_sub_categories = (verbose || (num_pids == 1));
+	if (show_sub_categories) {
+		data_rows = PROCESS_MEMINFO_ROWS;
+	} else {
+		data_rows = num_pids;
+	}
+	// Add two extra rows for a horizontal rule followed by a total row
+	// Add one extra data column for a total column
+	init_table(&table, header_rows, header_cols, data_rows + 2, num_nodes + 1);
+	int total_col_ix = header_cols + num_nodes;
+	int total_row_ix = header_rows + data_rows + 1;
+	string_assign(&table, total_row_ix, 0, "Total");
+	if (show_sub_categories) {
+		// Assign left header column label for each row in table
+		for (int row = 0; (row < PROCESS_MEMINFO_ROWS); row++) {
+			string_assign(&table, (header_rows + row), 0, process_meminfo[row].label);
+		}
+	} else {
+		string_assign(&table, 0, 0, "PID");
+		repchar_assign(&table, 1, 0, '-');
+		printf("\nPer-node process memory usage (in MBs)\n");
+	}
+	// Set left header column width and left justify it
+	set_col_width(&table, 0, 16);
+	set_col_justification(&table, 0, COL_JUSTIFY_LEFT);
+	// Set up "Node <N>" column headers over data columns, plus "Total" column
+	for (int node_ix = 0; (node_ix <= num_nodes); node_ix++) {
+		int col = header_cols + node_ix;
+		// Assign header row label and horizontal line for this column...
+		string_assign(&table, 0, col, node_header[node_ix]);
+		repchar_assign(&table, 1, col, '-');
+		// Set column width, decimal places, and right justify data
+		set_col_width(&table, col, 16);
+		int decimal_places = 2;
+		if (compress_display) {
+			decimal_places = 0;
+		}
+		set_col_decimal_places(&table, col, decimal_places);
+		set_col_justification(&table, col, COL_JUSTIFY_RIGHT);
+	}
+	// Initialize data in table to all zeros
+	zero_table_data(&table, CELL_TYPE_DOUBLE);
+	// If (show_sub_categories), show individual process tables for each PID,
+	// Otherwise show one big table of process total lines from all the PIDs.
+	for (int pid_ix = 0; (pid_ix < num_pids); pid_ix++) {
+		int pid = pid_array[pid_ix];
+		if (show_sub_categories) {
+			printf("\nPer-node process memory usage (in MBs) for PID %d (%s)\n", pid, command_name_for_pid(pid));
+			if (pid_ix > 0) {
+				// Re-initialize show_sub_categories table, because we re-use it for each PID.
+				zero_table_data(&table, CELL_TYPE_DOUBLE);
+			}
+		} else {
+			// Put this row's "PID (cmd)" label in left header column for this PID total row
+			char tmp_buf[64];
+			snprintf(tmp_buf, sizeof(tmp_buf), "%d (%s)", pid, command_name_for_pid(pid));
+			char *p = strdup(tmp_buf);
+			if (p == NULL) {
+				perror("malloc failed line: " STRINGIFY(__LINE__));
+				exit(EXIT_FAILURE);
+			}
+			string_assign(&table, header_rows + pid_ix, 0, p);
+			set_cell_flag(&table, header_rows + pid_ix, 0, CELL_FLAG_FREEABLE);
+		}
+		// Open numa_map for this PID to get per-node data
+		char fname[64];
+		snprintf(fname, sizeof(fname), "/proc/%d/numa_maps", pid);
+		char buf[BUF_SIZE];
+		FILE *fs = fopen(fname, "r");
+		if (!fs) {
+			sprintf(buf, "Can't read /proc/%d/numa_maps", pid);
+			perror(buf);
+			continue;
+		}
+		// Add up sub-category memory used from each node.  Must go line by line
+		// through the numa_map figuring out which category memory, node, and the
+		// amount.
+		while (fgets(buf, BUF_SIZE, fs)) {
+			int category = PROCESS_PRIVATE_INDEX;	// init category to the catch-all...
+			const char *delimiters = " \t\r\n";
+			char *p = strtok(buf, delimiters);
+			while (p) {
+				// If the memory category for this line is still the catch-all
+				// (i.e.  private), then see if the current token is a special
+				// keyword for a specific memory sub-category.
+				if (category == PROCESS_PRIVATE_INDEX) {
+					for (int ix = 0; (ix < PROCESS_PRIVATE_INDEX); ix++) {
+						if (!strncmp(p, process_meminfo[ix].token, strlen(process_meminfo[ix].token))) {
+							category = ix;
+							break;
+						}
+					}
+				}
+				// If the current token is a per-node pages quantity, parse the
+				// node number and accumulate the number of pages in the specific
+				// category (and also add to the total).
+				if (p[0] == 'N') {
+					int node_num = (int)strtol(&p[1], &p, 10);
+					if (p[0] != '=') {
+						perror("node value parse error");
+						exit(EXIT_FAILURE);
+					}
+					double value = (double)strtol(&p[1], &p, 10);
+					double multiplier = page_size_in_bytes;
+					if (category == PROCESS_HUGE_INDEX) {
+						multiplier = huge_page_size_in_bytes;
+					}
+					value *= multiplier;
+					value /= (double)MEGABYTE;
+					// Add value to data cell, total_col, and total_row
+					int tmp_row;
+					if (show_sub_categories) {
+						tmp_row = header_rows + category;
+					} else {
+						tmp_row = header_rows + pid_ix;
+					}
+					// Don't assume nodes are sequential or contiguous.
+					// Need to find correct tmp_col from node_ix_map
+					int i = 0;
+					while(node_ix_map[i++] != node_num)
+						;
+					int tmp_col = header_cols + i - 1;
+					double_addto(&table, tmp_row, tmp_col, value);
+					double_addto(&table, tmp_row, total_col_ix, value);
+					double_addto(&table, total_row_ix, tmp_col, value);
+					double_addto(&table, total_row_ix, total_col_ix, value);
+				}
+				// Get next token on the line
+				p = strtok(NULL, delimiters);
+			}
+		}
+		// Currently, a non-root user can open some numa_map files successfully
+		// without error, but can't actually read the contents -- despite the
+		// 444 file permissions.  So, use ferror() to check here to see if we
+		// actually got a read error, and if so, alert the user so they know
+		// not to trust the zero in the table.
+		if (ferror(fs)) {
+			sprintf(buf, "Can't read /proc/%d/numa_maps", pid);
+			perror(buf);
+		}
+		fclose(fs);
+		// If showing individual tables, or we just added the last total line,
+		// prepare the table for display and display it...
+		if ((show_sub_categories) || (pid_ix + 1 == num_pids)) {
+			// Crompress display column widths, if requested
+			if (compress_display) {
+				for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
+					auto_set_col_width(&table, col, 4, 16);
+				}
+			} else {
+				// Since not compressing the display, allow the left header
+				// column to be wider.  Otherwise, sometimes process command
+				// name instance numbers can be truncated in an annoying way.
+				auto_set_col_width(&table, 0, 16, 24);
+			}
+			// Put dashes above Total line...
+			set_row_flag(&table, total_row_ix - 1, COL_FLAG_ALWAYS_SHOW);
+			for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
+				repchar_assign(&table, total_row_ix - 1, col, '-');
+			}
+			// Optionally sort the table data
+			if (sort_table) {
+				int sort_col;
+				if ((sort_table_node < 0) || (sort_table_node >= num_nodes)) {
+					sort_col = total_col_ix;
+				} else {
+					sort_col = header_cols + node_ix_map[sort_table_node];
+				}
+				sort_rows_descending_by_col(&table, header_rows, header_rows + data_rows - 1, sort_col);
+			}
+			// Actually show the table
+			display_table(&table, screen_width, 0, 0, show_zero_data, show_zero_data);
+		}
+	}			// END OF FOR_EACH-PID loop
+	free_table(&table);
+}				// show_process_info()
+
+int node_and_digits(const struct dirent *dptr) {
+	char *p = (char *)(dptr->d_name);
+	if (*p++ != 'n') return 0;
+	if (*p++ != 'o') return 0;
+	if (*p++ != 'd') return 0;
+	if (*p++ != 'e') return 0;
+	do {
+		if (!isdigit(*p++)) return 0;
+	} while (*p != '\0');
+	return 1;
+}
+
+void init_node_ix_map_and_header(int compatibility_mode) {
+	// Count directory names of the form: /sys/devices/system/node/node<N>
+	struct dirent **namelist;
+	num_nodes = scandir("/sys/devices/system/node", &namelist, node_and_digits, NULL);
+	if (num_nodes < 1) {
+		if (compatibility_mode) {
+			perror("sysfs not mounted or system not NUMA aware");
+		} else {
+			perror("Couldn't open /sys/devices/system/node");
+		}
+		exit(EXIT_FAILURE);
+	} else {
+		node_ix_map = malloc(num_nodes * sizeof(int));
+		if (node_ix_map == NULL) {
+			perror("malloc failed line: " STRINGIFY(__LINE__));
+			exit(EXIT_FAILURE);
+		}
+		// For each "node<N>" filename present, save <N> in node_ix_map
+		for (int ix = 0; (ix < num_nodes); ix++) {
+			node_ix_map[ix] = atoi(&namelist[ix]->d_name[4]);
+			free(namelist[ix]);
+		}
+		free(namelist);
+		// Now, sort the node map in increasing order. Use a simplistic sort
+		// since we expect a relatively short (and maybe pre-ordered) list.
+		for (int ix = 0; (ix < num_nodes); ix++) {
+			int smallest_ix = ix;
+			for (int iy = ix + 1; (iy < num_nodes); iy++) {
+				if (node_ix_map[smallest_ix] > node_ix_map[iy]) {
+					smallest_ix = iy;
+				}
+			}
+			if (smallest_ix != ix) {
+				int tmp = node_ix_map[ix];
+				node_ix_map[ix] = node_ix_map[smallest_ix];
+				node_ix_map[smallest_ix] = tmp;
+			}
+		}
+		// Construct vector of "Node <N>" and "Total" column headers. Allocate
+		// one for each NUMA node, plus one on the end for the "Total" column
+		node_header = malloc((num_nodes + 1) * sizeof(char *));
+		if (node_header == NULL) {
+			perror("malloc failed line: " STRINGIFY(__LINE__));
+			exit(EXIT_FAILURE);
+		}
+		for (int node_ix = 0; (node_ix <= num_nodes); node_ix++) {
+			char node_label[64];
+			if (node_ix == num_nodes) {
+				strcpy(node_label, "Total");
+			} else if (compatibility_mode) {
+				snprintf(node_label, sizeof(node_label), "node%d", node_ix_map[node_ix]);
+			} else {
+				snprintf(node_label, sizeof(node_label), "Node %d", node_ix_map[node_ix]);
+			}
+			char *s = strdup(node_label);
+			if (s == NULL) {
+				perror("malloc failed line: " STRINGIFY(__LINE__));
+				exit(EXIT_FAILURE);
+			}
+			node_header[node_ix] = s;
+		}
+	}
+}
+
+void free_node_ix_map_and_header() {
+	if (node_ix_map != NULL) {
+		free(node_ix_map);
+		node_ix_map = NULL;
+	}
+	if (node_header != NULL) {
+		for (int ix = 0; (ix <= num_nodes); ix++) {
+			free(node_header[ix]);
+		}
+		free(node_header);
+		node_header = NULL;
+	}
+}
+
+double get_huge_page_size_in_bytes() {
+	double huge_page_size = 0;;
+	FILE *fs = fopen("/proc/meminfo", "r");
+	if (!fs) {
+		perror("Can't open /proc/meminfo");
+		exit(EXIT_FAILURE);
+	}
+	char buf[SMALL_BUF_SIZE];
+	while (fgets(buf, SMALL_BUF_SIZE, fs)) {
+		if (!strncmp("Hugepagesize", buf, 12)) {
+			char *p = &buf[12];
+			while ((!isdigit(*p)) && (p < buf + SMALL_BUF_SIZE)) {
+				p++;
+			}
+			huge_page_size = strtod(p, NULL);
+			break;
+		}
+	}
+	fclose(fs);
+	return huge_page_size * KILOBYTE;
+}
+
+int all_digits(char *p) {
+	if (p == NULL) {
+		return 0;
+	}
+	while (*p != '\0') {
+		if (!isdigit(*p++)) return 0;
+	}
+	return 1;
+}
+
+int starts_with_digit(const struct dirent *dptr) {
+	return (isdigit(dptr->d_name[0]));
+}
+
+void add_pid_to_list(int pid) {
+	if (num_pids < pid_array_max_pids) {
+		pid_array[num_pids++] = pid;
+	} else {
+		if (pid_array_max_pids == 0) {
+			pid_array_max_pids = 32;
+		}
+		int *tmp_int_ptr = realloc(pid_array, 2 * pid_array_max_pids * sizeof(int));
+		if (tmp_int_ptr == NULL) {
+			char buf[SMALL_BUF_SIZE];
+			sprintf(buf, "Too many PIDs, skipping %d", pid);
+			perror(buf);
+		} else {
+			pid_array = tmp_int_ptr;
+			pid_array_max_pids *= 2;
+			pid_array[num_pids++] = pid;
+		}
+	}
+}
+
+int ascending(const void *p1, const void *p2) {
+	return *(int *)p1 - *(int *) p2;
+}
+
+void sort_pids_and_remove_duplicates() {
+	if (num_pids > 1) {
+		qsort(pid_array, num_pids, sizeof(int), ascending);
+		int ix1 = 0;
+		for (int ix2 = 1; (ix2 < num_pids); ix2++) {
+			if (pid_array[ix2] == pid_array[ix1]) {
+				continue;
+			}
+			ix1 += 1;
+			if (ix2 > ix1) {
+				pid_array[ix1] = pid_array[ix2];
+			}
+		}
+		num_pids = ix1 + 1;
+	}
+}
+
+void add_pids_from_pattern_search(char *pattern) {
+	// Search all /proc/<PID>/cmdline files and /proc/<PID>/status:Name fields
+	// for matching patterns.  Show the memory details for matching PIDs.
+	int num_matches_found = 0;
+	struct dirent **namelist;
+	int files = scandir("/proc", &namelist, starts_with_digit, NULL);
+	if (files < 0) {
+		perror("Couldn't open /proc");
+	}
+	for (int ix = 0; (ix < files); ix++) {
+		char buf[BUF_SIZE];
+		// First get Name field from status file
+		int pid = atoi(namelist[ix]->d_name);
+		char *p = command_name_for_pid(pid);
+		if (p) {
+			strcpy(buf, p);
+		} else {
+			buf[0] = '\0';
+		}
+		// Next copy cmdline file contents onto end of buffer.  Do it a
+		// character at a time to convert nulls to spaces.
+		char fname[272];
+		snprintf(fname, sizeof(fname), "/proc/%s/cmdline", namelist[ix]->d_name);
+		FILE *fs = fopen(fname, "r");
+		if (fs) {
+			p = buf;
+			while (*p != '\0') {
+				p++;
+			}
+			*p++ = ' ';
+			int c;
+			while (((c = fgetc(fs)) != EOF) && (p < buf + BUF_SIZE - 1)) {
+				if (c == '\0') {
+					c = ' ';
+				}
+				*p++ = c;
+			}
+			*p++ = '\0';
+			fclose(fs);
+		}
+		if (strstr(buf, pattern)) {
+			if (pid != getpid()) {
+				add_pid_to_list(pid);
+				num_matches_found += 1;
+			}
+		}
+		free(namelist[ix]);
+	}
+	free(namelist);
+	if (num_matches_found == 0) {
+		printf("Found no processes containing pattern: \"%s\"\n", pattern);
+	}
+}
+
+int main(int argc, char **argv) {
+	prog_name = argv[0];
+	int show_the_system_info = 0;
+	int show_the_numastat_info = 0;
+	static struct option long_options[] = {
+		{"help", 0, 0, '?'},
+		{0, 0, 0, 0}
+	};
+	int long_option_index = 0;
+	int opt;
+	while ((opt = getopt_long(argc, argv, "cmnp:s::vVz?", long_options, &long_option_index)) != -1) {
+		switch (opt) {
+		case 0:
+			printf("Unexpected long option %s", long_options[long_option_index].name);
+			if (optarg) {
+				printf(" with arg %s", optarg);
+			}
+			printf("\n");
+			display_usage_and_exit();
+			break;
+		case 'c':
+			compress_display = 1;
+			break;
+		case 'm':
+			show_the_system_info = 1;
+			break;
+		case 'n':
+			show_the_numastat_info = 1;
+			break;
+		case 'p':
+			if ((optarg) && (all_digits(optarg))) {
+				add_pid_to_list(atoi(optarg));
+			} else {
+				add_pids_from_pattern_search(optarg);
+			}
+			break;
+		case 's':
+			sort_table = 1;
+			if ((optarg) && (all_digits(optarg))) {
+				sort_table_node = atoi(optarg);
+			}
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		case 'V':
+			display_version_and_exit();
+			break;
+		case 'z':
+			show_zero_data = 0;
+			break;
+		default:
+		case '?':
+			display_usage_and_exit();
+			break;
+		}
+	}
+	// Figure out the display width, which is used to format the tables
+	// and limit the output columns per row
+	screen_width = get_screen_width();
+	// Any remaining arguments are assumed to be additional process specifiers
+	while (optind < argc) {
+		if (all_digits(argv[optind])) {
+			add_pid_to_list(atoi(argv[optind]));
+		} else {
+			add_pids_from_pattern_search(argv[optind]);
+		}
+		optind += 1;
+	}
+	// If there are no program options or arguments, be extremely compatible
+	// with the old numastat perl script (which is included at the end of this
+	// file for reference)
+	compatibility_mode = (argc == 1);
+	init_node_ix_map_and_header(compatibility_mode);	// enumarate the NUMA nodes
+	if (compatibility_mode) {
+		show_numastat_info();
+		free_node_ix_map_and_header();
+		exit(EXIT_SUCCESS);
+	}
+	// Figure out page sizes
+	page_size_in_bytes = (double)sysconf(_SC_PAGESIZE);
+	huge_page_size_in_bytes = get_huge_page_size_in_bytes();
+	// Display the info for the process specifiers
+	if (num_pids > 0) {
+		sort_pids_and_remove_duplicates();
+		show_process_info();
+	}
+	if (pid_array != NULL) {
+		free(pid_array);
+	}
+	// Display the system-wide memory usage info
+	if (show_the_system_info) {
+		show_system_info();
+	}
+	// Display the numastat statistics info
+	if ((show_the_numastat_info) || ((num_pids == 0) && (!show_the_system_info))) {
+		show_numastat_info();
+	}
+	free_node_ix_map_and_header();
+	exit(EXIT_SUCCESS);
+}
+
+#if 0
+/*
+
+#!/usr/bin/perl
+# Print numa statistics for all nodes
+# Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+#
+# numastat 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
+# 2.
+#
+# numastat 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.
+
+# You should find a copy of v2 of the GNU General Public License somewhere
+# on your Linux system; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# Example: NUMASTAT_WIDTH=80 watch -n1 numastat
+#
+
+# output width
+$WIDTH=80;
+if (defined($ENV{'NUMASTAT_WIDTH'})) {
+	$WIDTH=$ENV{'NUMASTAT_WIDTH'};
+} else {
+	use POSIX;
+	if (POSIX::isatty(fileno(STDOUT))) {
+		if (open(R, "resize |")) {
+			while (<R>) {
+				$WIDTH=$1 if /COLUMNS=(\d+)/;
+			}
+			close R;
+		}
+	} else {
+		# don't split it up for easier parsing
+		$WIDTH=10000000;
+	}
+}
+$WIDTH = 32 if $WIDTH < 32;
+
+if (! -d "/sys/devices/system/node" ) {
+	print STDERR "sysfs not mounted or system not NUMA aware\n";
+	exit 1;
+}
+
+%stat = ();
+$title = "";
+$mode = 0;
+opendir(NODES, "/sys/devices/system/node") || exit 1;
+foreach $nd (readdir(NODES)) {
+	next unless $nd =~ /node(\d+)/;
+	# On newer kernels, readdir may enumerate the 'node(\d+) subdirs
+	# in opposite order from older kernels--e.g., node{0,1,2,...}
+	# as opposed to node{N,N-1,N-2,...}.  Accomodate this by
+	# switching to new mode so that the stats get emitted in
+	# the same order.
+        #print "readdir(NODES) returns $nd\n";
+	if (!$title && $nd =~ /node0/) {
+		$mode = 1;
+	}
+	open(STAT, "/sys/devices/system/node/$nd/numastat") ||
+			die "cannot open $nd: $!\n";
+	if (! $mode) {
+		$title = sprintf("%16s",$nd) . $title;
+	} else {
+		$title = $title . sprintf("%16s",$nd);
+	}
+	@fields = ();
+	while (<STAT>) {
+		($name, $val) = split;
+		if (! $mode) {
+			$stat{$name} = sprintf("%16u", $val) . $stat{$name};
+		} else {
+			$stat{$name} = $stat{$name} . sprintf("%16u", $val);
+		}
+		push(@fields, $name);
+	}
+	close STAT;
+}
+closedir NODES;
+
+$numfields = int(($WIDTH - 16) / 16);
+$l = 16 * $numfields;
+for ($i = 0; $i < length($title); $i += $l) {
+	print "\n" if $i > 0;
+	printf "%16s%s\n","",substr($title,$i,$l);
+	foreach (@fields) {
+		printf "%-16s%s\n",$_,substr($stat{$_},$i,$l);
+	}
+}
+
+*/
+#endif
diff --git a/rtnetlink.c b/rtnetlink.c
new file mode 100644
index 0000000..985f74a
--- /dev/null
+++ b/rtnetlink.c
@@ -0,0 +1,89 @@
+/* Simple LPGLed rtnetlink library */
+#include <sys/socket.h>
+#include <linux/rtnetlink.h>
+#include <linux/netlink.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include <unistd.h>
+#define hidden __attribute__((visibility("hidden")))
+#include "rtnetlink.h"
+
+hidden void *rta_put(struct nlmsghdr *m, int type, int len)
+{
+	struct rtattr *rta = (void *)m + NLMSG_ALIGN(m->nlmsg_len);
+	int rtalen = RTA_LENGTH(len);
+
+	rta->rta_type = type;
+	rta->rta_len = rtalen;
+	m->nlmsg_len = NLMSG_ALIGN(m->nlmsg_len) + RTA_ALIGN(rtalen);
+	return RTA_DATA(rta);
+}
+
+hidden struct rtattr *rta_get(struct nlmsghdr *m, struct rtattr *p, int offset)
+{
+	struct rtattr *rta;
+
+	if (p) {
+		rta = RTA_NEXT(p, m->nlmsg_len);
+		if (!RTA_OK(rta, m->nlmsg_len))
+			return NULL;
+	} else {
+		rta = (void *)m + NLMSG_ALIGN(offset);
+	}
+	return rta;
+}
+
+hidden int
+rta_put_address(struct nlmsghdr *msg, int type, struct sockaddr *adr)
+{
+	switch (adr->sa_family) {
+	case AF_INET: {
+		struct in_addr *i = rta_put(msg, type, 4);
+		*i = ((struct sockaddr_in *)adr)->sin_addr;
+		break;
+	}
+	case AF_INET6: {
+		struct in6_addr *i6 = rta_put(msg, type, 16);
+		*i6 = ((struct sockaddr_in6 *)adr)->sin6_addr;
+		break;
+	}
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+/* Assumes no truncation. Make the buffer large enough. */
+hidden int
+rtnetlink_request(struct nlmsghdr *msg, int buflen, struct sockaddr_nl *adr)
+{
+	int rsk;
+	int n;
+	int e;
+
+	/* Use a private socket to avoid having to keep state
+	   for a sequence number. */
+	rsk = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+	if (rsk < 0)
+		return -1;
+	n = sendto(rsk, msg, msg->nlmsg_len, 0, (struct sockaddr *)adr,
+		   sizeof(struct sockaddr_nl));
+	if (n >= 0) {
+		socklen_t adrlen = sizeof(struct sockaddr_nl);
+		n = recvfrom(rsk, msg, buflen, 0, (struct sockaddr *)adr,
+			     &adrlen);
+	}
+	e = errno;
+	close(rsk);
+	errno = e;
+	if (n < 0)
+		return -1;
+	/* Assume we only get a single reply back. This is (hopefully?)
+	   safe because it's a single use socket. */
+	if (msg->nlmsg_type == NLMSG_ERROR) {
+		struct nlmsgerr *err = NLMSG_DATA(msg);
+		errno = -err->error;
+		return -1;
+	}
+	return 0;
+}
diff --git a/rtnetlink.h b/rtnetlink.h
new file mode 100644
index 0000000..f73d909
--- /dev/null
+++ b/rtnetlink.h
@@ -0,0 +1,5 @@
+hidden int
+rta_put_address(struct nlmsghdr *msg, int type, struct sockaddr *adr);
+hidden struct rtattr *rta_get(struct nlmsghdr *m, struct rtattr *p, int offset);
+hidden void *rta_put(struct nlmsghdr *m, int type, int len);
+hidden int rtnetlink_request(struct nlmsghdr *msg, int buflen, struct sockaddr_nl *adr);
diff --git a/shm.c b/shm.c
new file mode 100644
index 0000000..260eeff
--- /dev/null
+++ b/shm.c
@@ -0,0 +1,325 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+   Manage shared memory policy for numactl.
+   The actual policy is set in numactl itself, this just sets up and maps
+   the shared memory segments and dumps them.
+
+   numactl 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
+   2.
+
+   numactl 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.
+
+   You should find a copy of v2 of the GNU General Public License somewhere
+   on your Linux system; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#define _GNU_SOURCE 1
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <unistd.h>
+#include "numa.h"
+#include "numaif.h"
+#include "numaint.h"
+#include "util.h"
+#include "shm.h"
+
+int shmfd = -1;
+long shmid = 0;
+char *shmptr;
+unsigned long long shmlen;
+mode_t shmmode = 0600;
+unsigned long long shmoffset;
+int shmflags;
+static int shm_pagesize;
+
+long huge_page_size(void)
+{
+	size_t len = 0;
+	char *line = NULL;
+	FILE *f = fopen("/proc/meminfo", "r");
+	if (f != NULL) {
+		while (getdelim(&line, &len, '\n', f) > 0) {
+			int ps;
+			if (sscanf(line, "Hugepagesize: %d kB", &ps) == 1)
+				return ps * 1024;
+		}
+		free(line);
+		fclose(f);
+	}
+	return getpagesize();
+}
+
+static void check_region(char *opt)
+{
+	if (((unsigned long)shmptr % shm_pagesize) || (shmlen % shm_pagesize)) {
+		fprintf(stderr, "numactl: policy region not page aligned\n");
+		exit(1);
+	}
+	if (!shmlen) {
+		fprintf(stderr,
+		"numactl: policy region length not specified before %s\n",
+			opt);
+		exit(1);
+	}
+}
+
+static key_t sysvkey(char *name)
+{
+	int fd;
+	key_t key = ftok(name, shmid);
+	if (key >= 0)
+		return key;
+
+	fprintf(stderr, "numactl: Creating shm key file %s mode %04o\n",
+		name, shmmode);
+	fd = creat(name, shmmode);
+	if (fd < 0)
+		nerror("cannot create key for shm %s\n", name);
+	key = ftok(name, shmid);
+	if (key < 0)
+		nerror("cannot get key for newly created shm key file %s",
+		       name);
+	return key;
+}
+
+/* Attach a sysv style shared memory segment. */
+void attach_sysvshm(char *name, char *opt)
+{
+	struct shmid_ds s;
+	key_t key = sysvkey(name);
+
+	shmfd = shmget(key, shmlen, shmflags);
+	if (shmfd < 0 && errno == ENOENT) {
+		if (shmlen == 0)
+			complain(
+                     "need a --length to create a sysv shared memory segment");
+		fprintf(stderr,
+         "numactl: Creating shared memory segment %s id %ld mode %04o length %.fMB\n",
+			name, shmid, shmmode, ((double)shmlen) / (1024*1024) );
+		shmfd = shmget(key, shmlen, IPC_CREAT|shmmode|shmflags);
+		if (shmfd < 0)
+			nerror("cannot create shared memory segment");
+	}
+
+	if (shmlen == 0) {
+		if (shmctl(shmfd, IPC_STAT, &s) < 0)
+			err("shmctl IPC_STAT");
+		shmlen = s.shm_segsz;
+	}
+
+	shmptr = shmat(shmfd, NULL, SHM_RDONLY);
+	if (shmptr == (void*)-1)
+		err("shmat");
+	shmptr += shmoffset;
+
+	shm_pagesize = (shmflags & SHM_HUGETLB) ? huge_page_size() : getpagesize();
+
+	check_region(opt);
+}
+
+/* Attach a shared memory file. */
+void attach_shared(char *name, char *opt)
+{
+	struct stat64 st;
+
+	shmfd = open(name, O_RDONLY);
+	if (shmfd < 0) {
+		errno = 0;
+		if (shmlen == 0)
+		        complain("need a --length to create a shared file");
+		shmfd = open(name, O_RDWR|O_CREAT, shmmode);
+		if (shmfd < 0)
+			nerror("cannot create file %s", name);
+	}
+	if (fstat64(shmfd, &st) < 0)
+		err("shm stat");
+	if (shmlen > st.st_size) {
+		if (ftruncate64(shmfd, shmlen) < 0) {
+			/* XXX: we could do it by hand, but it would it
+			   would be impossible to apply policy then.
+			   need to fix that in the kernel. */
+			perror("ftruncate");
+		}
+	}
+
+	shm_pagesize = st.st_blksize;
+
+	check_region(opt);
+
+	/* RED-PEN For shmlen > address space may need to map in pieces.
+	   Left for some poor 32bit soul. */
+	shmptr = mmap64(NULL, shmlen, PROT_READ, MAP_SHARED, shmfd, shmoffset);
+	if (shmptr == (char*)-1)
+		err("shm mmap");
+
+}
+
+static void
+dumppol(unsigned long long start, unsigned long long end, int pol, struct bitmask *mask)
+{
+	if (pol == MPOL_DEFAULT)
+		return;
+	printf("%016llx-%016llx: %s ",
+	       shmoffset+start,
+	       shmoffset+end,
+	       policy_name(pol));
+	printmask("", mask);
+}
+
+/* Dump policies in a shared memory segment. */
+void dump_shm(void)
+{
+	struct bitmask *nodes, *prevnodes;
+	int prevpol = -1, pol;
+	unsigned long long c, start;
+
+	start = 0;
+	if (shmlen == 0) {
+		printf("nothing to dump\n");
+		return;
+	}
+
+	nodes = numa_allocate_nodemask();
+	prevnodes = numa_allocate_nodemask();
+
+	for (c = 0; c < shmlen; c += shm_pagesize) {
+		if (get_mempolicy(&pol, nodes->maskp, nodes->size, c+shmptr,
+						MPOL_F_ADDR) < 0)
+			err("get_mempolicy on shm");
+		if (pol == prevpol)
+			continue;
+		if (prevpol != -1)
+			dumppol(start, c, prevpol, prevnodes);
+		prevnodes = nodes;
+		prevpol = pol;
+		start = c;
+	}
+	dumppol(start, c, prevpol, prevnodes);
+}
+
+static void dumpnode(unsigned long long start, unsigned long long end, int node)
+{
+	printf("%016llx-%016llx: %d\n", shmoffset+start, shmoffset+end, node);
+}
+
+/* Dump nodes in a shared memory segment. */
+void dump_shm_nodes(void)
+{
+	int prevnode = -1, node;
+	unsigned long long c, start;
+
+	start = 0;
+	if (shmlen == 0) {
+		printf("nothing to dump\n");
+		return;
+	}
+
+	for (c = 0; c < shmlen; c += shm_pagesize) {
+		if (get_mempolicy(&node, NULL, 0, c+shmptr,
+						MPOL_F_ADDR|MPOL_F_NODE) < 0)
+			err("get_mempolicy on shm");
+		if (node == prevnode)
+			continue;
+		if (prevnode != -1)
+			dumpnode(start, c, prevnode);
+		prevnode = node;
+		start = c;
+	}
+	dumpnode(start, c, prevnode);
+}
+
+static void vwarn(char *ptr, char *fmt, ...)
+{
+	va_list ap;
+	unsigned long off = (unsigned long)ptr - (unsigned long)shmptr;
+	va_start(ap,fmt);
+	printf("numactl verify %lx(%lx): ",  (unsigned long)ptr, off);
+	vprintf(fmt, ap);
+	va_end(ap);
+	exitcode = 1;
+}
+
+static unsigned interleave_next(unsigned cur, struct bitmask *mask)
+{
+	int numa_num_nodes = numa_num_possible_nodes();
+
+	++cur;
+	while (!numa_bitmask_isbitset(mask, cur)) {
+		cur = (cur+1) % numa_num_nodes;
+	}
+	return cur;
+}
+
+/* Verify policy in a shared memory segment */
+void verify_shm(int policy, struct bitmask *nodes)
+{
+	char *p;
+	int ilnode, node;
+	int pol2;
+	struct bitmask *nodes2;
+
+	nodes2 = numa_allocate_nodemask();
+
+	if (policy == MPOL_INTERLEAVE) {
+		if (get_mempolicy(&ilnode, NULL, 0, shmptr,
+					MPOL_F_ADDR|MPOL_F_NODE)
+		    < 0)
+			err("get_mempolicy");
+	}
+
+	for (p = shmptr; p - (char *)shmptr < shmlen; p += shm_pagesize) {
+		if (get_mempolicy(&pol2, nodes2->maskp, nodes2->size, p,
+							MPOL_F_ADDR) < 0)
+			err("get_mempolicy");
+		if (pol2 != policy) {
+			vwarn(p, "wrong policy %s, expected %s\n",
+			      policy_name(pol2), policy_name(policy));
+			return;
+		}
+		if (memcmp(nodes2, nodes, numa_bitmask_nbytes(nodes))) {
+			vwarn(p, "mismatched node mask\n");
+			printmask("expected", nodes);
+			printmask("real", nodes2);
+		}
+
+		if (get_mempolicy(&node, NULL, 0, p, MPOL_F_ADDR|MPOL_F_NODE) < 0)
+			err("get_mempolicy");
+
+		switch (policy) {
+		case MPOL_INTERLEAVE:
+			if (node < 0 || !numa_bitmask_isbitset(nodes2, node))
+				vwarn(p, "interleave node out of range %d\n", node);
+			if (node != ilnode) {
+				vwarn(p, "expected interleave node %d, got %d\n",
+				     ilnode,node);
+				return;
+			}
+			ilnode = interleave_next(ilnode, nodes2);
+			break;
+		case MPOL_PREFERRED:
+		case MPOL_BIND:
+			if (!numa_bitmask_isbitset(nodes2, node)) {
+				vwarn(p, "unexpected node %d\n", node);
+				printmask("expected", nodes2);
+			}
+			break;
+
+		case MPOL_DEFAULT:
+			break;
+
+		}
+	}
+
+}
diff --git a/shm.h b/shm.h
new file mode 100644
index 0000000..68166a7
--- /dev/null
+++ b/shm.h
@@ -0,0 +1,17 @@
+
+extern int shmfd;
+extern long shmid;
+extern char *shmptr;
+extern unsigned long long shmlen;
+extern mode_t shmmode;
+extern unsigned long long shmoffset;
+extern int shmflags;
+
+extern void dump_shm(void);
+extern void dump_shm_nodes(void);
+extern void attach_shared(char *, char *);
+extern void attach_sysvshm(char *, char *);
+extern void verify_shm(int policy, struct bitmask *);
+
+/* in numactl.c */
+extern int exitcode;
diff --git a/stream_lib.c b/stream_lib.c
new file mode 100644
index 0000000..a392bdd
--- /dev/null
+++ b/stream_lib.c
@@ -0,0 +1,266 @@
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include "stream_lib.h"
+
+static inline double mysecond()
+{
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	return tv.tv_sec + tv.tv_usec * 1.e-6;
+}
+
+/*
+ * Program: Stream
+ * Programmer: Joe R. Zagar
+ * Revision: 4.0-BETA, October 24, 1995
+ * Original code developed by John D. McCalpin
+ *
+ * This program measures memory transfer rates in MB/s for simple
+ * computational kernels coded in C.  These numbers reveal the quality
+ * of code generation for simple uncacheable kernels as well as showing
+ * the cost of floating-point operations relative to memory accesses.
+ *
+ * INSTRUCTIONS:
+ *
+ *	1) Stream requires a good bit of memory to run.  Adjust the
+ *          value of 'N' (below) to give a 'timing calibration' of
+ *          at least 20 clock-ticks.  This will provide rate estimates
+ *          that should be good to about 5% precision.
+ *
+ * Hacked by AK to be a library
+ */
+
+long N = 8000000;
+#define NTIMES	10
+#define OFFSET	0
+
+/*
+ *	3) Compile the code with full optimization.  Many compilers
+ *	   generate unreasonably bad code before the optimizer tightens
+ *	   things up.  If the results are unreasonably good, on the
+ *	   other hand, the optimizer might be too smart for me!
+ *
+ *         Try compiling with:
+ *               cc -O stream_d.c second_wall.c -o stream_d -lm
+ *
+ *         This is known to work on Cray, SGI, IBM, and Sun machines.
+ *
+ *
+ *	4) Mail the results to mccalpin@cs.virginia.edu
+ *	   Be sure to include:
+ *		a) computer hardware model number and software revision
+ *		b) the compiler flags
+ *		c) all of the output from the test case.
+ * Thanks!
+ *
+ */
+
+int checktick();
+
+# define HLINE "-------------------------------------------------------------\n"
+
+# ifndef MIN
+# define MIN(x,y) ((x)<(y)?(x):(y))
+# endif
+# ifndef MAX
+# define MAX(x,y) ((x)>(y)?(x):(y))
+# endif
+
+static double *a, *b, *c;
+
+static double rmstime[4] = { 0 }, maxtime[4] = {
+0}, mintime[4] = {
+FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX};
+
+static char *label[4] = { "Copy:      ", "Scale:     ",
+	"Add:       ", "Triad:     "
+};
+char *stream_names[] = { "Copy","Scale","Add","Triad" };
+
+static double bytes[4];
+
+int stream_verbose = 1;
+
+#define Vprintf(x...) do { if (stream_verbose) printf(x); } while(0)
+
+void stream_check(void)
+{
+	int quantum;
+	int BytesPerWord;
+	register int j;
+	double t;
+
+	/* --- SETUP --- determine precision and check timing --- */
+
+	Vprintf(HLINE);
+	BytesPerWord = sizeof(double);
+	Vprintf("This system uses %d bytes per DOUBLE PRECISION word.\n",
+	       BytesPerWord);
+
+	Vprintf(HLINE);
+	Vprintf("Array size = %lu, Offset = %d\n", N, OFFSET);
+	Vprintf("Total memory required = %.1f MB.\n",
+	       (3 * N * BytesPerWord) / 1048576.0);
+	Vprintf("Each test is run %d times, but only\n", NTIMES);
+	Vprintf("the *best* time for each is used.\n");
+
+	/* Get initial value for system clock. */
+
+	for (j = 0; j < N; j++) {
+		a[j] = 1.0;
+		b[j] = 2.0;
+		c[j] = 0.0;
+	}
+
+	Vprintf(HLINE);
+
+	if ((quantum = checktick()) >= 1)
+		Vprintf("Your clock granularity/precision appears to be "
+		       "%d microseconds.\n", quantum);
+	else
+		Vprintf("Your clock granularity appears to be "
+		       "less than one microsecond.\n");
+
+	t = mysecond();
+	for (j = 0; j < N; j++)
+		a[j] = 2.0E0 * a[j];
+	t = 1.0E6 * (mysecond() - t);
+
+	Vprintf("Each test below will take on the order"
+	       " of %d microseconds.\n", (int) t);
+	Vprintf("   (= %d clock ticks)\n", (int) (t / quantum));
+	Vprintf("Increase the size of the arrays if this shows that\n");
+	Vprintf("you are not getting at least 20 clock ticks per test.\n");
+
+	Vprintf(HLINE);
+
+	Vprintf("WARNING -- The above is only a rough guideline.\n");
+	Vprintf("For best results, please be sure you know the\n");
+	Vprintf("precision of your system timer.\n");
+	Vprintf(HLINE);
+}
+
+void stream_test(double *res)
+{
+	register int j, k;
+	double scalar, times[4][NTIMES];
+
+	/*  --- MAIN LOOP --- repeat test cases NTIMES times --- */
+
+	scalar = 3.0;
+	for (k = 0; k < NTIMES; k++) {
+		times[0][k] = mysecond();
+		for (j = 0; j < N; j++)
+			c[j] = a[j];
+		times[0][k] = mysecond() - times[0][k];
+
+		times[1][k] = mysecond();
+		for (j = 0; j < N; j++)
+			b[j] = scalar * c[j];
+		times[1][k] = mysecond() - times[1][k];
+
+		times[2][k] = mysecond();
+		for (j = 0; j < N; j++)
+			c[j] = a[j] + b[j];
+		times[2][k] = mysecond() - times[2][k];
+
+		times[3][k] = mysecond();
+		for (j = 0; j < N; j++)
+			a[j] = b[j] + scalar * c[j];
+		times[3][k] = mysecond() - times[3][k];
+	}
+
+	/*  --- SUMMARY --- */
+
+	for (k = 0; k < NTIMES; k++) {
+		for (j = 0; j < 4; j++) {
+			rmstime[j] =
+			    rmstime[j] + (times[j][k] * times[j][k]);
+			mintime[j] = MIN(mintime[j], times[j][k]);
+			maxtime[j] = MAX(maxtime[j], times[j][k]);
+		}
+	}
+
+	Vprintf
+	    ("Function      Rate (MB/s)   RMS time     Min time     Max time\n");
+	for (j = 0; j < 4; j++) {
+		double speed = 1.0E-06 * bytes[j] / mintime[j];
+
+		rmstime[j] = sqrt(rmstime[j] / (double) NTIMES);
+
+		Vprintf("%s%11.4f  %11.4f  %11.4f  %11.4f\n", label[j],
+			speed,
+		       rmstime[j], mintime[j], maxtime[j]);
+
+		if (res)
+			res[j] = speed;
+
+	}
+}
+
+# define	M	20
+
+int checktick()
+{
+	int i, minDelta, Delta;
+	double t1, t2, timesfound[M];
+
+/*  Collect a sequence of M unique time values from the system. */
+
+	for (i = 0; i < M; i++) {
+		t1 = mysecond();
+		while (((t2 = mysecond()) - t1) < 1.0E-6);
+		timesfound[i] = t1 = t2;
+	}
+
+/*
+ * Determine the minimum difference between these M values.
+ * This result will be our estimate (in microseconds) for the
+ * clock granularity.
+ */
+
+	minDelta = 1000000;
+	for (i = 1; i < M; i++) {
+		Delta =
+		    (int) (1.0E6 * (timesfound[i] - timesfound[i - 1]));
+		minDelta = MIN(minDelta, MAX(Delta, 0));
+	}
+
+	return (minDelta);
+}
+
+void stream_setmem(unsigned long size)
+{
+	N = (size - OFFSET) / (3*sizeof(double));
+}
+
+long stream_memsize(void)
+{
+	return 3*(sizeof(double) * (N+OFFSET)) ;
+}
+
+long stream_init(void *mem)
+{
+	int i;
+
+	for (i = 0; i < 4; i++) {
+		rmstime[i] = 0;
+		maxtime[i] = 0;
+		mintime[i] = FLT_MAX;
+	}
+
+	bytes[0] = 2 * sizeof(double) * N;
+	bytes[1] = 2 * sizeof(double) * N;
+	bytes[2] = 3 * sizeof(double) * N;
+	bytes[3] = 3 * sizeof(double) * N;
+
+	a = mem;
+	b = (double *)mem +   (N+OFFSET);
+	c = (double *)mem + 2*(N+OFFSET);
+	stream_check();
+	return 0;
+}
diff --git a/stream_lib.h b/stream_lib.h
new file mode 100644
index 0000000..4d749bd
--- /dev/null
+++ b/stream_lib.h
@@ -0,0 +1,8 @@
+long stream_memsize(void);
+long stream_init(void *mem);
+#define STREAM_NRESULTS 4
+void stream_test(double *res);
+void stream_check(void);
+void stream_setmem(unsigned long size);
+extern int stream_verbose;
+extern char *stream_names[];
diff --git a/stream_main.c b/stream_main.c
new file mode 100644
index 0000000..c46cae0
--- /dev/null
+++ b/stream_main.c
@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include "numa.h"
+#include "numaif.h"
+#include "util.h"
+#include "stream_lib.h"
+
+void usage(void)
+{
+	exit(1);
+}
+
+char *policy = "default";
+
+/* Run STREAM with a numa policy */
+int main(int ac, char **av)
+{
+	struct bitmask *nodes;
+	char *map;
+	long size;
+	int policy;
+
+	policy = parse_policy(av[1], av[2]);
+
+        nodes = numa_allocate_nodemask();
+
+	if (av[1] && av[2])
+		nodes = numa_parse_nodestring(av[2]);
+	if (!nodes) {
+		printf ("<%s> is invalid\n", av[2]);
+		exit(1);
+	}
+	size = stream_memsize();
+	map = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,
+		   0, 0);
+	if (map == (char*)-1) exit(1);
+	if (mbind(map, size, policy, nodes->maskp, nodes->size, 0) < 0)
+		perror("mbind"), exit(1);
+	stream_init(map);
+	stream_test(NULL);
+	return 0;
+}
diff --git a/syscall.c b/syscall.c
new file mode 100644
index 0000000..31cf005
--- /dev/null
+++ b/syscall.c
@@ -0,0 +1,266 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+
+   libnuma 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; version
+   2.1.
+
+   libnuma 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 find a copy of v2.1 of the GNU Lesser General Public License
+   somewhere on your Linux system; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#include <unistd.h>
+#include <sys/types.h>
+#include <asm/unistd.h>
+#include <errno.h>
+#include "numa.h"
+#include "numaif.h"
+#include "numaint.h"
+
+#define WEAK __attribute__((weak))
+
+#if !defined(__NR_mbind) || !defined(__NR_set_mempolicy) || \
+    !defined(__NR_get_mempolicy) || !defined(__NR_migrate_pages) || \
+    !defined(__NR_move_pages)
+
+#if defined(__x86_64__)
+
+#define __NR_sched_setaffinity    203
+#define __NR_sched_getaffinity     204
+
+/* Official allocation */
+
+#define __NR_mbind 237
+#define __NR_set_mempolicy 238
+#define __NR_get_mempolicy 239
+#define __NR_migrate_pages 256
+#define __NR_move_pages 279
+
+#elif defined(__ia64__)
+#define __NR_sched_setaffinity    1231
+#define __NR_sched_getaffinity    1232
+#define __NR_migrate_pages	1280
+#define __NR_move_pages 1276
+
+/* Official allocation */
+
+#define __NR_mbind 1259
+#define __NR_get_mempolicy 1260
+#define __NR_set_mempolicy 1261
+
+#elif defined(__i386__)
+
+#define __NR_mbind 274
+#define __NR_get_mempolicy 275
+#define __NR_set_mempolicy 276
+#define __NR_migrate_pages 294
+#define __NR_move_pages 317
+
+#elif defined(__powerpc__)
+
+#define __NR_mbind 259
+#define __NR_get_mempolicy 260
+#define __NR_set_mempolicy 261
+#define __NR_migrate_pages 258
+/* FIXME: powerpc is missing move pages!!!
+#define __NR_move_pages xxx
+*/
+
+#elif defined(__mips__)
+
+#if _MIPS_SIM == _ABIO32
+/*
+ * Linux o32 style syscalls are in the range from 4000 to 4999.
+ */
+#define __NR_Linux 4000
+#define __NR_mbind (__NR_Linux + 268)
+#define __NR_get_mempolicy (__NR_Linux + 269)
+#define __NR_set_mempolicy (__NR_Linux + 270)
+#define __NR_migrate_pages (__NR_Linux + 287)
+#endif
+
+#if _MIPS_SIM == _ABI64
+/*
+ * Linux 64-bit syscalls are in the range from 5000 to 5999.
+ */
+#define __NR_Linux 5000
+#define __NR_mbind (__NR_Linux + 227)
+#define __NR_get_mempolicy (__NR_Linux + 228)
+#define __NR_set_mempolicy (__NR_Linux + 229)
+#define __NR_migrate_pages (__NR_Linux + 246)
+#endif
+
+#if _MIPS_SIM == _ABIN32
+/*
+ * Linux N32 syscalls are in the range from 6000 to 6999.
+ */
+#define __NR_Linux 6000
+#define __NR_mbind (__NR_Linux + 231)
+#define __NR_get_mempolicy (__NR_Linux + 232)
+#define __NR_set_mempolicy (__NR_Linux + 233)
+#define __NR_migrate_pages (__NR_Linux + 250)
+#endif
+
+#elif defined(__hppa__)
+
+#define __NR_migrate_pages	272
+
+#elif defined(__arm__)
+/* https://bugs.debian.org/796802 */
+#warning "ARM does not implement the migrate_pages() syscall"
+
+#elif !defined(DEPS_RUN)
+#error "Add syscalls for your architecture or update kernel headers"
+#endif
+
+#endif
+
+#ifndef __GLIBC_PREREQ
+# define __GLIBC_PREREQ(x,y) 0
+#endif
+
+#if defined(__GLIBC__) && __GLIBC_PREREQ(2, 11)
+
+/* glibc 2.11 seems to have working 6 argument sycall. Use the
+   glibc supplied syscall in this case.
+   The version cut-off is rather arbitary and could be probably
+   earlier. */
+
+#define syscall6 syscall
+#elif defined(__x86_64__)
+/* 6 argument calls on x86-64 are often buggy in both glibc and
+   asm/unistd.h. Add a working version here. */
+long syscall6(long call, long a, long b, long c, long d, long e, long f)
+{
+       long res;
+       asm volatile ("movq %[d],%%r10 ; movq %[e],%%r8 ; movq %[f],%%r9 ; syscall"
+		     : "=a" (res)
+		     : "0" (call),"D" (a),"S" (b), "d" (c),
+		       [d] "g" (d), [e] "g" (e), [f] "g" (f) :
+		     "r11","rcx","r8","r10","r9","memory" );
+       if (res < 0) {
+	       errno = -res;
+	       res = -1;
+       }
+       return res;
+}
+#elif defined(__i386__)
+
+/* i386 has buggy syscall6 in glibc too. This is tricky to do
+   in inline assembly because it clobbers so many registers. Do it
+   out of line. */
+asm(
+"__syscall6:\n"
+"	pushl %ebp\n"
+"	pushl %edi\n"
+"	pushl %esi\n"
+"	pushl %ebx\n"
+"	movl  (0+5)*4(%esp),%eax\n"
+"	movl  (1+5)*4(%esp),%ebx\n"
+"	movl  (2+5)*4(%esp),%ecx\n"
+"	movl  (3+5)*4(%esp),%edx\n"
+"	movl  (4+5)*4(%esp),%esi\n"
+"	movl  (5+5)*4(%esp),%edi\n"
+"	movl  (6+5)*4(%esp),%ebp\n"
+"	int $0x80\n"
+"	popl %ebx\n"
+"	popl %esi\n"
+"	popl %edi\n"
+"	popl %ebp\n"
+"	ret"
+);
+extern long __syscall6(long n, long a, long b, long c, long d, long e, long f);
+
+long syscall6(long call, long a, long b, long c, long d, long e, long f)
+{
+       long res = __syscall6(call,a,b,c,d,e,f);
+       if (res < 0) {
+	       errno = -res;
+	       res = -1;
+       }
+       return res;
+}
+
+#else
+#define syscall6 syscall
+#endif
+
+long WEAK get_mempolicy(int *policy, unsigned long *nmask,
+				unsigned long maxnode, void *addr,
+				unsigned flags)
+{
+	return syscall(__NR_get_mempolicy, policy, nmask,
+					maxnode, addr, flags);
+}
+
+long WEAK mbind(void *start, unsigned long len, int mode,
+	const unsigned long *nmask, unsigned long maxnode, unsigned flags)
+{
+	return syscall6(__NR_mbind, (long)start, len, mode, (long)nmask,
+				maxnode, flags);
+}
+
+long WEAK set_mempolicy(int mode, const unsigned long *nmask,
+                                   unsigned long maxnode)
+{
+	long i;
+	i = syscall(__NR_set_mempolicy,mode,nmask,maxnode);
+	return i;
+}
+
+long WEAK migrate_pages(int pid, unsigned long maxnode,
+	const unsigned long *frommask, const unsigned long *tomask)
+{
+#if defined(__NR_migrate_pages)
+	return syscall(__NR_migrate_pages, pid, maxnode, frommask, tomask);
+#else
+    errno = ENOSYS;
+    return -1;
+#endif
+}
+
+long WEAK move_pages(int pid, unsigned long count,
+	void **pages, const int *nodes, int *status, int flags)
+{
+	return syscall(__NR_move_pages, pid, count, pages, nodes, status, flags);
+}
+
+/* SLES8 glibc doesn't define those */
+int numa_sched_setaffinity_v1(pid_t pid, unsigned len, const unsigned long *mask)
+{
+	return syscall(__NR_sched_setaffinity,pid,len,mask);
+}
+backward_symver(numa_sched_setaffinity_v1,numa_sched_setaffinity);
+
+int numa_sched_setaffinity_v2(pid_t pid, struct bitmask *mask)
+{
+	return syscall(__NR_sched_setaffinity, pid, numa_bitmask_nbytes(mask),
+								mask->maskp);
+}
+symver(numa_sched_setaffinity_v2,numa_sched_setaffinity);
+
+int numa_sched_getaffinity_v1(pid_t pid, unsigned len, const unsigned long *mask)
+{
+	return syscall(__NR_sched_getaffinity,pid,len,mask);
+
+}
+backward_symver(numa_sched_getaffinity_v1,numa_sched_getaffinity);
+
+int numa_sched_getaffinity_v2(pid_t pid, struct bitmask *mask)
+{
+	/* len is length in bytes */
+	return syscall(__NR_sched_getaffinity, pid, numa_bitmask_nbytes(mask),
+								mask->maskp);
+	/* sched_getaffinity returns sizeof(cpumask_t) */
+
+}
+symver(numa_sched_getaffinity_v2,numa_sched_getaffinity);
+
+make_internal_alias(numa_sched_getaffinity_v1);
+make_internal_alias(numa_sched_getaffinity_v2);
+make_internal_alias(numa_sched_setaffinity_v1);
+make_internal_alias(numa_sched_setaffinity_v2);
diff --git a/sysfs.c b/sysfs.c
new file mode 100644
index 0000000..f1cdcdc
--- /dev/null
+++ b/sysfs.c
@@ -0,0 +1,69 @@
+/* Utility functions for reading sysfs values */
+#define _GNU_SOURCE 1
+#include <stdio.h>
+#include <sys/fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include "numa.h"
+#include "numaint.h"
+
+#define SYSFS_BLOCK 4096
+
+hidden char *sysfs_read(char *name)
+{
+	char *buf;
+	int n;
+	int fd;
+
+	fd = open(name, O_RDONLY);
+	buf = malloc(SYSFS_BLOCK);
+	if (!buf)
+		return NULL;
+	n = read(fd, buf, SYSFS_BLOCK - 1);
+	close(fd);
+	if (n <= 0) {
+		free(buf);
+		return NULL;
+	}
+	buf[n] = 0;
+	return buf;
+}
+
+hidden int sysfs_node_read(struct bitmask *mask, char *fmt, ...)
+{
+	int n;
+	va_list ap;
+	char *p, *fn, *m, *end;
+	int num;
+
+	va_start(ap, fmt);
+	n = vasprintf(&fn, fmt, ap);
+	va_end(ap);
+	if (n < 0)
+		return -1;
+	p = sysfs_read(fn);
+	free(fn);
+	if (!p)
+		return -1;
+
+	m = p;
+	do {
+		num = strtol(m, &end, 0);
+		if (m == end)
+			return -1;
+		if (num < 0)
+			return -2;
+		if (num >= numa_num_task_nodes())
+			return -1;
+		numa_bitmask_setbit(mask, num);
+
+		/* Continuation not supported by kernel yet. */
+		m = end;
+		while (isspace(*m) || *m == ',')
+			m++;
+	} while (isdigit(*m));
+	free(p);
+	return 0;
+}
diff --git a/sysfs.h b/sysfs.h
new file mode 100644
index 0000000..0574ab1
--- /dev/null
+++ b/sysfs.h
@@ -0,0 +1,3 @@
+struct bitmask;
+hidden char *sysfs_read(char *name);
+hidden int sysfs_node_read(struct bitmask *mask, char *fmt, ...);
diff --git a/test-libnuma.c b/test-libnuma.c
new file mode 100644
index 0000000..0234350
--- /dev/null
+++ b/test-libnuma.c
@@ -0,0 +1,21 @@
+#include <sched.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "third_party/libnuma/numa.h"
+
+void numa_init(void);
+
+int main(int argc, char *argv[])
+{
+  numa_init();
+  if (numa_available() == 0) {
+    printf("numa max node: %d\n", numa_max_node());
+  } else {
+    printf("numa not available\n");
+  }
+
+  return (0);
+}
diff --git a/test/README b/test/README
new file mode 100644
index 0000000..c584c6f
--- /dev/null
+++ b/test/README
@@ -0,0 +1,21 @@
+
+Various simple test scripts to verify some parts of the NUMA API.
+
+To do a full regression test run make test
+
+You should have at least two nodes on a NUMA system for the test suite.
+
+The tests in regress assume that there is enough memory free on nodes 0/1.
+They consider PREFERRED/INTERLEAVE not hitting the first choice node an 
+error. 
+
+They also require a relatively idle machine to avoid too much
+noise from memory allocation from other processes. Without
+that regress1 might fail.
+
+You can run the tests under valgrind with VALGRIND=valgrind make test
+Older valgrind versions incorrectly report a uninitialized byte error
+on set_mempolicy. That is a false positive.
+
+TBD: more detailed unit tests for mbind / shm / {get,set}_mempolicy
+Currently everything is tested using numactl only.
diff --git a/test/bind_range b/test/bind_range
new file mode 100644
index 0000000..70c0df6
--- /dev/null
+++ b/test/bind_range
@@ -0,0 +1,109 @@
+#!/bin/bash
+
+# This simple script checks --all/-a option which is used for
+# supressing of default cpuset awareness of options --cpunodebind,
+# --physcpubind, --interleave, --preferred and --membind.
+
+# NOTE: Test needs two nodes and two cpus at least
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+export old_mask
+
+eval_test() {
+       # echo "Running $1.."
+       $1
+       if [ $? == 1 ] ;  then
+          echo -e "$1 FAILED!"
+	  reset_mask
+          exit 1
+       fi
+       echo -e "$1 PASSED"
+}
+
+function check_arg_order
+{
+	numactl --all --physcpubind=$HIGHESTCPU ls > /dev/null 2>&1
+	if [ $? == 1 ] ; then
+		return 1;
+	fi
+	numactl --physcpubind=$HIGHESTCPU --all ls > /dev/null 2>&1
+	if [ $? == 0 ] ; then
+		return 1;
+	fi
+
+	return 0
+}
+
+function check_physcpubind
+{
+	reset_mask
+	set_cpu_affinity 0
+	numactl --physcpubind=$HIGHESTCPU ls > /dev/null 2>&1
+	if [ $? == 0 ] ; then # shouldn't pass so easy
+		return 1;
+	fi
+	numactl --all --physcpubind=$HIGHESTCPU ls > /dev/null 2>&1
+	if [ $? == 1 ] ; then # shouldn't fail
+		return 1;
+	fi
+
+	return 0
+}
+
+function check_cpunodebind
+{
+	local low_cpu_range
+	local high_cpu
+
+	reset_mask
+	low_cpu_range=$(cat /sys/devices/system/node/node$LOWESTNODE/cpulist)
+	set_cpu_affinity $low_cpu_range
+	numactl --cpunodebind=$HIGHESTNODE ls > /dev/null 2>&1
+	if [ $? == 1 ] ; then # should pass
+		return 1;
+	fi
+	numactl --all --cpunodebind=$HIGHESTNODE ls > /dev/null 2>&1
+	if [ $? == 1 ] ; then # should pass for sure
+		return 1;
+	fi
+
+	return 0
+}
+
+function set_cpu_affinity
+{
+	taskset -p -c $1 $$ > /dev/null
+	#echo -e "\taffinity of shell was set to" $1
+}
+
+function get_mask
+{
+	old_mask=$(taskset -p $$ | cut -f2 -d: | sed -e 's/^[ \t]*//')
+}
+
+function reset_mask
+{
+	taskset -p $old_mask $$ > /dev/null
+	#echo -e "\taffinity of shell was reset to" $old_mask
+}
+
+HIGHESTCPU=$(grep 'processor' /proc/cpuinfo | tail -n1 | cut -f2 -d':')
+HIGHESTCPU=$(echo $HIGHESTCPU | cut -f2 -d' ')
+HIGHESTNODE=$(numactl -H | grep -e 'node [0-9]* cpus' | tail -n1 | cut -f2 -d' ')
+LOWESTNODE=$(numactl -H | grep -e 'node [0-9]* cpus' | head -n1 | cut -f2 -d' ')
+
+get_mask
+
+eval_test check_arg_order
+eval_test check_physcpubind
+eval_test check_cpunodebind
+
+reset_mask
+
+exit 0
+
+
diff --git a/test/checkaffinity b/test/checkaffinity
new file mode 100755
index 0000000..8b96ed9
--- /dev/null
+++ b/test/checkaffinity
@@ -0,0 +1,31 @@
+#!/bin/bash
+# check if affinity works
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+S=`numactl --show | grep nodebind:`
+NODES=`echo $S | sed -e "s/nodebind://"`
+
+S=`numactl --show | grep physcpubind:`
+CPUS=`echo $S | sed -e "s/physcpubind://"`
+
+for i in $CPUS ; do
+    if [ "$(numactl --physcpubind=$i "${testdir}"/printcpu)" != "$i" ] ; then
+       echo "--physcpubind for $i doesn't work"
+       exit 1
+    fi
+    if [ "$(numactl --physcpubind=$i numactl --show | awk '/^physcpubind/ { print $2 }' )" != "$i" ] ; then
+	echo "--show doesn't agree with physcpubind for cpu $i"
+	exit 1
+    fi
+done
+
+for i in $NODES ; do
+    if [ $(numactl --cpunodebind=$i numactl --show | awk '/nodebind/ { print $2 }' ) != $i ] ; then
+	echo "--show doesn't agree with cpunodebind for node $i"
+	exit 1
+    fi
+done
diff --git a/test/checktopology b/test/checktopology
new file mode 100755
index 0000000..63403b5
--- /dev/null
+++ b/test/checktopology
@@ -0,0 +1,42 @@
+#!/bin/bash
+# check numactl --hardware output
+# this checks most of the topology discovery in libnuma
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+numcpus=$(grep -c processor /proc/cpuinfo)
+numnodes=$(ls -1d /sys/devices/system/node/node[0-9]* | wc -l)
+
+nccpus=$(numactl --hardware | grep cpus | sed 's/node.*cpus://' | wc -w ) 
+ncnodes=$(numactl --hardware | grep -c 'node.*size' ) 
+
+if [ $numnodes != $ncnodes ] ; then
+    echo "numactl --hardware doesnt report all nodes"
+    exit 1
+fi
+
+if [ $numcpus != $nccpus -a \( $[$nccpus / $numnodes] != $numcpus \) ] ; then
+    echo "numactl --hardware cpus look bogus"
+    exit 1
+fi
+
+numactl --hardware | grep cpus | while read n ; do 
+    node=${n/ cpus*/} 
+    node=${node/ /}
+    cpus=${n/*: /}
+    k=0
+    for i in $cpus ; do 
+	if [ ! -h "/sys/devices/system/node/$node/cpu$i" ] ; then
+	    echo "$node doesn't have cpu $i"
+	    exit 1
+	fi
+	k=$[$k+1]
+    done
+    if [ $k != $(echo $cpus | wc -w) ] ; then
+	echo "$node missing cpu"
+	exit 1	
+    fi
+done
diff --git a/test/distance.c b/test/distance.c
new file mode 100644
index 0000000..fca109f
--- /dev/null
+++ b/test/distance.c
@@ -0,0 +1,42 @@
+/* Test numa_distance */
+#include <numa.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+	int numnodes, maxnode, a, b, got_nodes = 0;
+	int *node_to_use;
+	long size, free_node_sizes;
+	if (numa_available() < 0) {
+		printf("no numa support in kernel\n");
+		exit(1);
+	}
+	numnodes = numa_num_configured_nodes();
+	maxnode = numa_max_node();
+	node_to_use = (int *)malloc(numnodes * sizeof(int));
+	for (a = 0; a <= maxnode; a++) {
+		size = numa_node_size(a, &free_node_sizes);
+		if(size != -1)
+			node_to_use[got_nodes++] = a;
+	}
+	for (a = 0; a < got_nodes; a++){
+		printf("%03d: ", node_to_use[a]);
+		if (numa_distance(node_to_use[a], node_to_use[a]) != 10) {
+			printf("%d: self distance is not 10 (%d)\n",
+			       node_to_use[a], numa_distance(node_to_use[a],node_to_use[a]));
+			exit(1);
+		}
+		for (b = 0; b < got_nodes; b++) {
+			int d1 = numa_distance(node_to_use[a], node_to_use[b]);
+			int d2 = numa_distance(node_to_use[b], node_to_use[a]);
+			printf("%03d ", d1);
+			if (d1 != d2) {
+				printf("\n(%d,%d)->(%d,%d) wrong!\n",node_to_use[a],node_to_use[b],d1,d2);
+				exit(1);
+			}
+		}
+		printf("\n");
+	}
+	return 0;
+}
diff --git a/test/ftok.c b/test/ftok.c
new file mode 100644
index 0000000..736a42e
--- /dev/null
+++ b/test/ftok.c
@@ -0,0 +1,8 @@
+#include <sys/ipc.h>
+#include <stdio.h>
+int main(int ac, char **av)
+{
+	while (*++av)
+		printf("0x%x\n", ftok(*av, 0));
+	return 0;
+}
diff --git a/test/getnodemask.c b/test/getnodemask.c
new file mode 100644
index 0000000..7f39be9
--- /dev/null
+++ b/test/getnodemask.c
@@ -0,0 +1,28 @@
+#include <sched.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <numa.h>
+
+int main(int argc, char *argv[])
+{
+	nodemask_t nodemask;
+	int rc, i;
+
+	rc = numa_available();
+	printf("numa_available returns %d\n", rc);
+	if (rc < 0) exit(1);
+
+	nodemask_zero(&nodemask);
+
+	nodemask = numa_get_run_node_mask();
+	for (i = 0; i < 4; i++) {
+		printf("numa_get_run_node_mask nodemask_isset returns=0x%lx\n", nodemask_isset(&nodemask, i));
+	}
+
+	rc = numa_run_on_node_mask(&nodemask);
+	printf("rc=%d from numa_run_on_node_mask\n", rc);
+
+	return (0);
+}
diff --git a/test/mbind_mig_pages.c b/test/mbind_mig_pages.c
new file mode 100644
index 0000000..31c73e4
--- /dev/null
+++ b/test/mbind_mig_pages.c
@@ -0,0 +1,129 @@
+/*
+ * Test program to test the moving of pages using mbind.
+ *
+ * (C) 2006 Silicon Graphics, Inc.
+ *		Christoph Lameter <clameter@sgi.com>
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <numa.h>
+#include <numaif.h>
+#include <unistd.h>
+#include <asm/unistd.h>
+
+unsigned int pagesize;
+unsigned int page_count = 32;
+
+char *page_base;
+char *pages;
+
+void **addr;
+int *status;
+int *nodes;
+int errors;
+int nr_nodes;
+
+struct bitmask *old_nodes;
+struct bitmask *new_nodes;
+
+int main(int argc, char **argv)
+{
+	int i, rc;
+
+	pagesize = getpagesize();
+
+	nr_nodes = numa_max_node()+1;
+
+	old_nodes = numa_bitmask_alloc(nr_nodes);
+	new_nodes = numa_bitmask_alloc(nr_nodes);
+	numa_bitmask_setbit(old_nodes, 0);
+	numa_bitmask_setbit(new_nodes, 1);
+
+	if (nr_nodes < 2) {
+		printf("A minimum of 2 nodes is required for this test.\n");
+		exit(1);
+	}
+
+	setbuf(stdout, NULL);
+	printf("mbind migration test ......\n");
+	if (argc > 1)
+		sscanf(argv[1], "%d", &page_count);
+
+	page_base = malloc((pagesize + 1) * page_count);
+	addr = malloc(sizeof(char *) * page_count);
+	status = malloc(sizeof(int *) * page_count);
+	nodes = malloc(sizeof(int *) * page_count);
+	if (!page_base || !addr || !status || !nodes) {
+		printf("Unable to allocate memory\n");
+		exit(1);
+	}
+
+	pages = (void *) ((((long)page_base) & ~((long)(pagesize - 1))) + pagesize);
+
+	for (i = 0; i < page_count; i++) {
+		if (i != 2)
+			/* We leave page 2 unallocated */
+			pages[ i * pagesize ] = (char) i;
+		addr[i] = pages + i * pagesize;
+		nodes[i] = 0;
+		status[i] = -123;
+	}
+
+	/* Move pages toi node zero */
+	numa_move_pages(0, page_count, addr, nodes, status, 0);
+
+	printf("\nPage status before page migration\n");
+	printf("---------------------------------\n");
+	rc = numa_move_pages(0, page_count, addr, NULL, status, 0);
+	if (rc < 0) {
+		perror("move_pages");
+		exit(1);
+	}
+
+	for (i = 0; i < page_count; i++) {
+		printf("Page %d vaddr=%p node=%d\n", i, pages + i * pagesize, status[i]);
+		if (i != 2 && status[i]) {
+			printf("Bad page state. Page %d status %d\n",i, status[i]);
+			exit(1);
+		}
+	}
+
+	/* Move to node zero */
+	printf("\nMoving pages via mbind to node 0 ...\n");
+	rc = mbind(pages, page_count * pagesize, MPOL_BIND, old_nodes->maskp,
+		old_nodes->size + 1, MPOL_MF_MOVE | MPOL_MF_STRICT);
+	if (rc < 0) {
+		perror("mbind");
+		errors++;
+	}
+
+	printf("\nMoving pages via mbind from node 0 to 1 ...\n");
+	rc = mbind(pages, page_count * pagesize, MPOL_BIND, new_nodes->maskp,
+		new_nodes->size + 1, MPOL_MF_MOVE | MPOL_MF_STRICT);
+	if (rc < 0) {
+		perror("mbind");
+		errors++;
+	}
+
+	numa_move_pages(0, page_count, addr, NULL, status, 0);
+	for (i = 0; i < page_count; i++) {
+		printf("Page %d vaddr=%lx node=%d\n", i,
+			(unsigned long)(pages + i * pagesize), status[i]);
+		if (i != 2) {
+			if (pages[ i* pagesize ] != (char) i) {
+				printf("*** Page content corrupted.\n");
+				errors++;
+			} else if (status[i] != 1) {
+				printf("*** Page on wrong node.\n");
+				errors++;
+			}
+		}
+	}
+
+	if (!errors)
+		printf("Test successful.\n");
+	else
+		printf("%d errors.\n", errors);
+
+	return errors > 0 ? 1 : 0;
+}
diff --git a/test/migrate_pages.c b/test/migrate_pages.c
new file mode 100644
index 0000000..37c4e97
--- /dev/null
+++ b/test/migrate_pages.c
@@ -0,0 +1,124 @@
+/*
+ * Test program to test the moving of a processes pages.
+ *
+ * (C) 2006 Silicon Graphics, Inc.
+ *		Christoph Lameter <clameter@sgi.com>
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <numa.h>
+#include <unistd.h>
+#include <errno.h>
+
+unsigned int pagesize;
+unsigned int page_count = 32;
+
+char *page_base;
+char *pages;
+
+void **addr;
+int *status;
+int *nodes;
+int errors;
+int nr_nodes;
+
+struct bitmask *old_nodes;
+struct bitmask *new_nodes;
+
+int main(int argc, char **argv)
+{
+	int i, rc;
+
+	pagesize = getpagesize();
+
+	nr_nodes = numa_max_node()+1;
+
+	old_nodes = numa_bitmask_alloc(nr_nodes);
+        new_nodes = numa_bitmask_alloc(nr_nodes);
+        numa_bitmask_setbit(old_nodes, 1);
+        numa_bitmask_setbit(new_nodes, 0);
+
+	if (nr_nodes < 2) {
+		printf("A minimum of 2 nodes is required for this test.\n");
+		exit(1);
+	}
+
+	setbuf(stdout, NULL);
+	printf("migrate_pages() test ......\n");
+	if (argc > 1)
+		sscanf(argv[1], "%d", &page_count);
+
+	page_base = malloc((pagesize + 1) * page_count);
+	addr = malloc(sizeof(char *) * page_count);
+	status = malloc(sizeof(int *) * page_count);
+	nodes = malloc(sizeof(int *) * page_count);
+	if (!page_base || !addr || !status || !nodes) {
+		printf("Unable to allocate memory\n");
+		exit(1);
+	}
+
+	pages = (void *) ((((long)page_base) & ~((long)(pagesize - 1))) + pagesize);
+
+	for (i = 0; i < page_count; i++) {
+		if (i != 2)
+			/* We leave page 2 unallocated */
+			pages[ i * pagesize ] = (char) i;
+		addr[i] = pages + i * pagesize;
+		nodes[i] = 1;
+		status[i] = -123;
+	}
+
+	/* Move to starting node */
+	rc = numa_move_pages(0, page_count, addr, nodes, status, 0);
+	if (rc < 0 && errno != ENOENT) {
+		perror("move_pages");
+		exit(1);
+	}
+
+	/* Verify correct startup locations */
+	printf("Page location at the beginning of the test\n");
+	printf("------------------------------------------\n");
+
+	numa_move_pages(0, page_count, addr, NULL, status, 0);
+	for (i = 0; i < page_count; i++) {
+		printf("Page %d vaddr=%p node=%d\n", i, pages + i * pagesize, status[i]);
+		if (i != 2 && status[i] != 1) {
+			printf("Bad page state before migrate_pages. Page %d status %d\n",i, status[i]);
+			exit(1);
+		}
+	}
+
+	/* Move to node zero */
+	numa_move_pages(0, page_count, addr, nodes, status, 0);
+
+	printf("\nMigrating the current processes pages ...\n");
+	rc = numa_migrate_pages(0, old_nodes, new_nodes);
+
+	if (rc < 0) {
+		perror("numa_migrate_pages failed");
+		errors++;
+	}
+
+	/* Get page state after migration */
+	numa_move_pages(0, page_count, addr, NULL, status, 0);
+	for (i = 0; i < page_count; i++) {
+		printf("Page %d vaddr=%lx node=%d\n", i,
+			(unsigned long)(pages + i * pagesize), status[i]);
+		if (i != 2) {
+			if (pages[ i* pagesize ] != (char) i) {
+				printf("*** Page contents corrupted.\n");
+				errors++;
+			} else if (status[i]) {
+				printf("*** Page on the wrong node\n");
+				errors++;
+			}
+		}
+	}
+
+	if (!errors)
+		printf("Test successful.\n");
+	else
+		printf("%d errors.\n", errors);
+
+	return errors > 0 ? 1 : 0;
+}
diff --git a/test/move_pages.c b/test/move_pages.c
new file mode 100644
index 0000000..87d9b3e
--- /dev/null
+++ b/test/move_pages.c
@@ -0,0 +1,101 @@
+/*
+ * Test program to test the moving of individual pages in a process.
+ *
+ * (C) 2006 Silicon Graphics, Inc.
+ *		Christoph Lameter <clameter@sgi.com>
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "numa.h"
+#include <unistd.h>
+#include <asm/unistd.h>
+
+unsigned int pagesize;
+unsigned int page_count = 32;
+
+char *page_base;
+char *pages;
+
+void **addr;
+int *status;
+int *nodes;
+int errors;
+int nr_nodes;
+
+int main(int argc, char **argv)
+{
+	int i, rc;
+
+	pagesize = getpagesize();
+
+	nr_nodes = numa_max_node();
+
+	if (nr_nodes < 2) {
+		printf("A minimum of 2 nodes is required for this test.\n");
+		exit(1);
+	}
+
+	setbuf(stdout, NULL);
+	printf("move_pages() test ......\n");
+	if (argc > 1)
+		sscanf(argv[1], "%d", &page_count);
+
+	printf("pages=%d (%s)\n", page_count, argv[1]);
+
+	page_base = malloc((pagesize + 1) * page_count);
+	addr = malloc(sizeof(char *) * page_count);
+	status = malloc(sizeof(int *) * page_count);
+	nodes = malloc(sizeof(int *) * page_count);
+	if (!page_base || !addr || !status || !nodes) {
+		printf("Unable to allocate memory\n");
+		exit(1);
+	}
+
+	pages = (void *) ((((long)page_base) & ~((long)(pagesize - 1))) + pagesize);
+
+	for (i = 0; i < page_count; i++) {
+		if (i != 2)
+			/* We leave page 2 unallocated */
+			pages[ i * pagesize ] = (char) i;
+		addr[i] = pages + i * pagesize;
+		nodes[i] = (i % nr_nodes);
+		status[i] = -123;
+	}
+
+	printf("\nMoving pages to start node ...\n");
+	rc = numa_move_pages(0, page_count, addr, NULL, status, 0);
+	if (rc < 0)
+		perror("move_pages");
+
+	for (i = 0; i < page_count; i++)
+		printf("Page %d vaddr=%p node=%d\n", i, pages + i * pagesize, status[i]);
+
+	printf("\nMoving pages to target nodes ...\n");
+	rc = numa_move_pages(0, page_count, addr, nodes, status, 0);
+
+	if (rc < 0) {
+		perror("move_pages");
+		errors++;
+	}
+
+	for (i = 0; i < page_count; i++) {
+		if (i != 2) {
+			if (pages[ i* pagesize ] != (char) i)
+				errors++;
+			else if (nodes[i] != (i % nr_nodes))
+				errors++;
+		}
+	}
+
+	for (i = 0; i < page_count; i++) {
+		printf("Page %d vaddr=%lx node=%d\n", i,
+			(unsigned long)(pages + i * pagesize), status[i]);
+	}
+
+	if (!errors)
+		printf("Test successful.\n");
+	else
+		printf("%d errors.\n", errors);
+
+	return errors > 0 ? 1 : 0;
+}
diff --git a/test/mynode.c b/test/mynode.c
new file mode 100644
index 0000000..f728a70
--- /dev/null
+++ b/test/mynode.c
@@ -0,0 +1,15 @@
+#include <numa.h>
+#include <numaif.h>
+#include <stdio.h>
+
+int main(void)
+{
+	int nd;
+	char *man = numa_alloc(1000);
+	*man = 1;
+	if (get_mempolicy(&nd, NULL, 0, man, MPOL_F_NODE|MPOL_F_ADDR) < 0)
+		perror("get_mempolicy");
+	else
+		printf("my node %d\n", nd);
+	return 0;
+}
diff --git a/test/node-parse.c b/test/node-parse.c
new file mode 100644
index 0000000..85858d7
--- /dev/null
+++ b/test/node-parse.c
@@ -0,0 +1,26 @@
+/* Test wrapper for the nodemask parser */
+#include <stdio.h>
+#include "numa.h"
+#include "util.h"
+
+/* For util.c. Fixme. */
+void usage(void)
+{
+	exit(1);
+}
+
+int main(int ac, char **av)
+{
+	int err = 0;
+	while (*++av) {
+		struct bitmask *mask = numa_parse_nodestring(*av);
+		if (!mask) {
+			printf("Failed to convert `%s'\n", *av);
+			err |= 1;
+			continue;
+		}
+		printmask("result", mask);
+		numa_bitmask_free(mask);
+	}
+	return err;
+}
diff --git a/test/nodemap.c b/test/nodemap.c
new file mode 100644
index 0000000..cd2cffa
--- /dev/null
+++ b/test/nodemap.c
@@ -0,0 +1,30 @@
+#include "numa.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+	int i, k, w, ncpus;
+	struct bitmask *cpus;
+	int maxnode = numa_num_configured_nodes()-1;
+
+	if (numa_available() < 0)  {
+		printf("no numa\n");
+		exit(1);
+	}
+	cpus = numa_allocate_cpumask();
+	ncpus = cpus->size;
+
+	for (i = 0; i <= maxnode ; i++) {
+		if (numa_node_to_cpus(i, cpus) < 0) {
+			printf("node %d failed to convert\n",i);
+		}
+		printf("%d: ", i);
+		w = 0;
+		for (k = 0; k < ncpus; k++)
+			if (numa_bitmask_isbitset(cpus, k))
+				printf(" %s%d", w>0?",":"", k);
+		putchar('\n');
+	}
+	return 0;
+}
diff --git a/test/numademo b/test/numademo
new file mode 100755
index 0000000..5cdd3a0
--- /dev/null
+++ b/test/numademo
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+exec "${builddir}"/numademo -t -e 10M
diff --git a/test/pagesize.c b/test/pagesize.c
new file mode 100644
index 0000000..9f5dec7
--- /dev/null
+++ b/test/pagesize.c
@@ -0,0 +1,8 @@
+#include <unistd.h>
+#include <stdio.h>
+
+int main(void)
+{
+	printf("%d\n", getpagesize());
+	return 0;
+}
diff --git a/test/prefered.c b/test/prefered.c
new file mode 100644
index 0000000..d273bec
--- /dev/null
+++ b/test/prefered.c
@@ -0,0 +1,63 @@
+/* Test prefer policy */
+#include "numa.h"
+#include "numaif.h"
+#include <sys/mman.h>
+#include <stdio.h>
+#include <assert.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#define err(x) perror(x),exit(1)
+
+int main(void)
+{
+	int max = numa_max_node();
+	int maxmask = numa_num_possible_nodes();
+	struct bitmask *nodes, *mask;
+	int pagesize = getpagesize();
+	int i;
+	int pol;
+	int node;
+	int err = 0;
+	nodes = numa_bitmask_alloc(maxmask);
+	mask = numa_bitmask_alloc(maxmask);
+
+	for (i = max; i >= 0; --i) {
+		char *mem = mmap(NULL, pagesize*(max+1), PROT_READ|PROT_WRITE,
+					MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
+		char *adr = mem;
+
+		if (mem == (char *)-1)
+			err("mmap");
+
+		printf("%d offset %lx\n", i, (long)(adr - mem));
+
+		numa_bitmask_clearall(nodes);
+		numa_bitmask_clearall(mask);
+		numa_bitmask_setbit(nodes, i);
+
+		if (mbind(adr,  pagesize, MPOL_PREFERRED, nodes->maskp,
+							nodes->size, 0) < 0)
+			err("mbind");
+
+		++*adr;
+
+		if (get_mempolicy(&pol, mask->maskp, mask->size, adr, MPOL_F_ADDR) < 0)
+			err("get_mempolicy");
+
+		assert(pol == MPOL_PREFERRED);
+		assert(numa_bitmask_isbitset(mask, i));
+
+		node = 0x123;
+
+		if (get_mempolicy(&node, NULL, 0, adr, MPOL_F_ADDR|MPOL_F_NODE) < 0)
+			err("get_mempolicy2");
+
+		printf("got node %d expected %d\n", node, i);
+
+		if (node != i)
+			err = 1;
+	}
+	return err;
+}
diff --git a/test/printcpu b/test/printcpu
new file mode 100755
index 0000000..661fa5a
--- /dev/null
+++ b/test/printcpu
@@ -0,0 +1,5 @@
+#!/bin/bash
+#print cpu it is running on
+declare -a arr
+arr=( $(< /proc/self/stat) )
+echo ${arr[38]}
diff --git a/test/randmap.c b/test/randmap.c
new file mode 100644
index 0000000..df8a666
--- /dev/null
+++ b/test/randmap.c
@@ -0,0 +1,175 @@
+/* Randomly change policy */
+#include <stdio.h>
+#include "numa.h"
+#include "numaif.h"
+#include <sys/mman.h>
+#include <sys/shm.h>
+#include <sys/ipc.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define SIZE (100*1024*1024)
+#define PAGES (SIZE/pagesize)
+
+#define perror(x) printf("%s: %s\n", x, strerror(errno))
+#define err(x) perror(x),exit(1)
+
+struct page {
+	unsigned long mask;
+	int policy;
+};
+
+struct page *pages;
+char *map;
+int pagesize;
+
+void setpol(unsigned long offset, unsigned long length, int policy, unsigned long nodes)
+{
+	long i, end;
+
+	printf("off:%lx length:%lx policy:%d nodes:%lx\n",
+	       offset, length, policy, nodes);
+
+	if (mbind(map + offset*pagesize, length*pagesize, policy,
+		  &nodes, 8, 0) < 0) {
+		printf("mbind: %s offset %lx length %lx policy %d nodes %lx\n",
+		       strerror(errno),
+		       offset*pagesize, length*pagesize,
+		       policy, nodes);
+		return;
+	}
+
+	for (i = offset; i < offset+length; i++) {
+		pages[i].mask = nodes;
+		pages[i].policy = policy;
+	}
+
+	i = offset - 20;
+	if (i < 0)
+		i = 0;
+	end = offset+length+20;
+	if (end > PAGES)
+		end = PAGES;
+	for (; i < end; i++) {
+		int pol2;
+		unsigned long nodes2;
+		if (get_mempolicy(&pol2, &nodes2, sizeof(long)*8, map+i*pagesize,
+				  MPOL_F_ADDR) < 0)
+			err("get_mempolicy");
+		if (pol2 != pages[i].policy) {
+			printf("%lx: got policy %d expected %d, nodes got %lx expected %lx\n",
+			       i, pol2, pages[i].policy, nodes2, pages[i].mask);
+		}
+		if (policy != MPOL_DEFAULT && nodes2 != pages[i].mask) {
+			printf("%lx: nodes %lx, expected %lx, policy %d\n",
+			       i, nodes2, pages[i].mask, policy);
+		}
+	}
+}
+
+static unsigned char pop4[16] = {
+  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
+};
+
+int popcnt(unsigned long val)
+{
+	int count = 0;
+	while (val) {
+		count += pop4[val & 0xf];
+		val >>= 4;
+	}
+	return count;
+}
+
+void testmap(void)
+{
+	pages = calloc(1, PAGES * sizeof(struct page));
+	if (!pages)
+		exit(100);
+
+	printf("simple tests\n");
+#define MB ((1024*1024)/pagesize)
+	setpol(0, PAGES, MPOL_INTERLEAVE, 3);
+	setpol(0, MB, MPOL_BIND, 1);
+	setpol(MB, MB, MPOL_BIND, 1);
+	setpol(MB, MB, MPOL_DEFAULT, 0);
+	setpol(MB, MB, MPOL_PREFERRED, 2);
+	setpol(MB/2, MB, MPOL_DEFAULT, 0);
+	setpol(MB+MB/2, MB, MPOL_BIND, 2);
+	setpol(MB/2+100, 100, MPOL_PREFERRED, 1);
+	setpol(100, 200, MPOL_PREFERRED, 1);
+	printf("done\n");
+
+	for (;;) {
+		unsigned long offset = random() % PAGES;
+		int policy = random() % (MPOL_MAX+1);
+		unsigned long nodes = random() % 4;
+		long length = random() % (PAGES - offset);
+
+		/* validate */
+		switch (policy) {
+		case MPOL_DEFAULT:
+			nodes = 0;
+			break;
+		case MPOL_INTERLEAVE:
+		case MPOL_BIND:
+			if (nodes == 0)
+				continue;
+			break;
+		case MPOL_PREFERRED:
+			if (popcnt(nodes) != 1)
+				continue;
+			break;
+		}
+
+		setpol(offset, length, policy, nodes);
+
+	}
+}
+
+int main(int ac, char **av)
+{
+	unsigned long seed;
+
+	pagesize = getpagesize();
+
+#if 0
+	map = mmap(NULL, SIZE, PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, 0, 0);
+	if (map == (char*)-1)
+		err("mmap");
+#else
+	int shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT|0666);
+	if (shmid < 0) err("shmget");
+	map = shmat(shmid, NULL, SHM_RDONLY);
+	shmctl(shmid, IPC_RMID, NULL);
+	if (map == (char *)-1) err("shmat");
+	printf("map %p\n", map);
+#endif
+
+	if (av[1]) {
+		char *end;
+		unsigned long timeout = strtoul(av[1], &end, 0);
+		switch (*end) {
+		case 'h': timeout *= 3600; break;
+		case 'm': timeout *= 60; break;
+		}
+		printf("running for %lu seconds\n", timeout);
+		alarm(timeout);
+	} else
+		printf("running forever\n");
+
+	if (av[1] && av[2])
+		seed = strtoul(av[2], 0, 0);
+	else
+		seed = time(0);
+
+	printf("random seed %lu\n", seed);
+	srandom(seed);
+
+	testmap();
+	/* test shm etc. */
+	return 0;
+}
diff --git a/test/realloc_test.c b/test/realloc_test.c
new file mode 100644
index 0000000..db80820
--- /dev/null
+++ b/test/realloc_test.c
@@ -0,0 +1,108 @@
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include "numa.h"
+#include "numaif.h"
+
+#define DEFAULT_NR_PAGES	1024
+
+static int parse_int(const char *str)
+{
+	char	*endptr;
+	long	ret = strtol(str, &endptr, 0);
+	if (*endptr != '\0') {
+		fprintf(stderr, "[error] strtol() failed: parse error: %s\n", endptr);
+		exit(1);
+	}
+
+	if (errno == ERANGE)
+		fprintf(stderr, "[warning] strtol() out of range\n");
+
+	if (ret > INT_MAX || ret < INT_MIN) {
+		fprintf(stderr, "[warning] parse_int() out of range\n");
+		ret = (ret > 0) ? INT_MAX : INT_MIN;
+	}
+
+	return (int) ret;
+}
+
+int main(int argc, char **argv)
+{
+	char	*mem;
+	int		page_size = numa_pagesize();
+	int		node = 0;
+	int		nr_pages = DEFAULT_NR_PAGES;
+
+	if (numa_available() < 0) {
+		fprintf(stderr, "numa is not available");
+		exit(1);
+	}
+
+	if (argc > 1)
+		node = parse_int(argv[1]);
+	if (argc > 2)
+		nr_pages = parse_int(argv[2]);
+
+	mem = numa_alloc_onnode(page_size, node);
+
+	/* Store the policy of the newly allocated area */
+	unsigned long	nodemask;
+	int				mode;
+	int				nr_nodes = numa_num_possible_nodes();
+	if (get_mempolicy(&mode, &nodemask, nr_nodes, mem,
+					  MPOL_F_NODE | MPOL_F_ADDR) < 0) {
+		perror("get_mempolicy() failed");
+		exit(1);
+	}
+
+	/* Print some info */
+	printf("Page size: %d\n", page_size);
+	printf("Pages realloc'ed: %d\n", nr_pages);
+	printf("Allocate data in node: %d\n", node);
+
+	int i;
+	int nr_inplace = 0;
+	int nr_moved   = 0;
+	for (i = 0; i < nr_pages; i++) {
+		/* Enlarge mem with one more page */
+		char	*new_mem = numa_realloc(mem, (i+1)*page_size, (i+2)*page_size);
+		if (!new_mem) {
+			perror("numa_realloc() failed");
+			exit(1);
+		}
+
+		if (new_mem == mem)
+			++nr_inplace;
+		else
+			++nr_moved;
+		mem = new_mem;
+
+		/* Check the policy of the realloc'ed area */
+		unsigned long	realloc_nodemask;
+		int				realloc_mode;
+		if (get_mempolicy(&realloc_mode, &realloc_nodemask,
+						  nr_nodes, mem, MPOL_F_NODE | MPOL_F_ADDR) < 0) {
+			perror("get_mempolicy() failed");
+			exit(1);
+		}
+
+		assert(realloc_nodemask == nodemask &&
+			   realloc_mode == mode && "policy changed");
+	}
+
+	/* Shrink to the original size */
+	mem = numa_realloc(mem, (nr_pages + 1)*page_size, page_size);
+	if (!mem) {
+		perror("numa_realloc() failed");
+		exit(1);
+	}
+
+	numa_free(mem, page_size);
+	printf("In-place reallocs: %d\n", nr_inplace);
+	printf("Moved reallocs: %d\n", nr_moved);
+	return 0;
+}
diff --git a/test/regress b/test/regress
new file mode 100755
index 0000000..c0cf6d7
--- /dev/null
+++ b/test/regress
@@ -0,0 +1,220 @@
+#!/bin/bash
+# simple regression test for numactl/numaapi
+# must be run from 'test' directory of numactl source package,
+# after build [just use 'make test']
+# note the statistics checks may fail when the system is under
+# memory pressure
+# Copyright 2003,2004 Andi Kleen, SuSE Labs.
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+: ${NUMACTL:=${builddir}/numactl}
+VALGRIND=${VALGRIND:-}
+
+MB=$[1024*1024]
+SIZE=$[15 * $MB]
+DEMOSIZE=$[10 * $MB]
+STAT_INTERVAL=5
+
+PAGESIZE=$("${builddir}/test/pagesize")
+PAGES=$[ $SIZE / $PAGESIZE ]
+HALFPAGES=$[ $PAGES / 2 ]
+HALFPAGES=$[ $HALFPAGES - 100 ]
+DOUBLEPAGES=$[ $PAGES * 2 ]
+DOUBLEPAGES=$[ $DOUBLEPAGES - 200 ]
+NEEDPAGES=$[ $DOUBLEPAGES + $DOUBLEPAGES / 5 ] # 20% spare
+
+EXIT=0
+
+declare -i maxnode
+declare -a node
+declare -a nlist
+
+# =====================================================================
+numactl() {
+	$VALGRIND $NUMACTL "$@"
+}
+
+failed() {
+    echo '=======FAILED'
+    echo "Check if machine doesn't have background jobs and try again"
+    EXIT=1
+}
+
+# nstat statname node
+nstat() {
+    sleep $STAT_INTERVAL
+    declare -a fields
+    numastat | grep $1 | while read -a fields ; do
+	echo ${fields[$[1 + $2]]}
+    done
+}
+
+probe_hardware()
+{
+	declare -i n=0
+
+	numnodes=$(numactl --hardware | awk '/^available/ { print $2 }')
+	maxnode=$(expr $numnodes - 1)
+	nlist=( $(numactl --hardware | grep "^node" |  tail -1 |awk '{$1=""; print }') )
+
+	# find nodes with at least NEEDPAGES of free memory
+	for i in $(seq 0 $maxnode) ; do
+		free=$(numactl --hardware | fgrep " ${nlist[$i]} free" | awk '{print $4}')
+		free=$(( free * MB ))
+		if [[ $((free / PAGESIZE)) -ge $NEEDPAGES ]]; then
+			node[$n]=${nlist[$i]}
+			n=$((n + 1 ))
+		fi
+	done
+	numnodes=$n
+	maxnode=$(expr $numnodes - 1)
+
+	if [ $numnodes -lt 2 ] ; then
+	    echo "need at least two nodes with at least $NEEDPAGES each of"
+	    echo "free memory for mempolicy regression tests"
+	    exit 77  # Skip test
+	fi
+}
+
+# =========================================================================
+_test_process_state() {
+    echo '=>testing numactl' "$@" "memhog -H $SIZE"
+    numactl "$@" memhog -H $SIZE  || failed
+}
+
+test_process_state()
+{
+	declare -i n0=${node[0]} n1=${node[1]}
+
+	_test_process_state --interleave=$n1
+
+	a0=`nstat interleave_hit 0`
+	a1=`nstat interleave_hit 1`
+	_test_process_state --interleave=$n0,$n1
+	b0=`nstat interleave_hit 0`
+	b1=`nstat interleave_hit 1`
+	if [ $(expr $b1 - $a1) -lt $HALFPAGES ]; then
+	    echo "interleaving test failed $n1 $b1 $a1"
+	    failed
+	fi
+	if [ $(expr $b0 - $a0) -lt $HALFPAGES ]; then
+	    echo "interleaving test failed $n0 $b0 $a0"
+	    failed
+	fi
+
+	_test_process_state --interleave=all
+	_test_process_state --membind=all
+
+	a=$(expr $(nstat numa_hit 0) + $(nstat numa_hit 1))
+	_test_process_state --membind=$n0,$n1
+	b=$(expr $(nstat numa_hit 0) + $(nstat numa_hit 1))
+	if [ $(expr $b - $a) -lt $PAGES ]; then
+	    echo "membind test failed $n1 $b $a ($PAGES)"
+	    failed
+	fi
+
+	for i in $(seq 0 $maxnode) ; do
+		declare -i ni=${node[$i]}
+		a=`nstat numa_hit $i`
+		_test_process_state --membind=$ni
+		_test_process_state --preferred=$ni
+		b=`nstat numa_hit $i`
+		if [ $(expr $b - $a) -lt $DOUBLEPAGES ]; then
+		    echo "membind/preferred on node $ni failed $b $a"
+		    failed
+		fi
+	done
+	_test_process_state --localalloc
+}
+
+# =========================================================================
+# test mbind
+
+_test_mbind() {
+	echo '=>testing memhog -H' "$@"
+	memhog -H $SIZE "$@" || failed
+}
+
+test_mbind()
+{
+	declare -i n0=${node[0]} n1=${node[1]}
+
+	a0=`nstat interleave_hit 0`
+	a1=`nstat interleave_hit 1`
+	_test_mbind interleave $n0,$n1
+	b0=`nstat interleave_hit 0`
+	b1=`nstat interleave_hit 1`
+	if [ $(expr $b1 - $a1) -lt $HALFPAGES ]; then
+	    echo "interleaving test 2 failed $n1 $b1 $a1 expected $HALFPAGES"
+	    failed
+	fi
+	if [ $(expr $b0 - $a0) -lt $HALFPAGES ]; then
+	    echo "interleaving test 2 failed $n0 $b0 $a0"
+	    failed
+	fi
+
+	_test_mbind interleave all
+
+	a=$(expr $(nstat numa_hit 0) + $(nstat numa_hit 1))
+	_test_mbind membind $n0,$n1
+	b=$(expr $(nstat numa_hit 0) + $(nstat numa_hit 1))
+	if [ $(expr $b - $a) -lt $PAGES ]; then
+	    echo "membind test 2 failed $b $a ($PAGES)"
+	    failed
+	fi
+
+	for i in $(seq 0 $maxnode) ; do
+		declare -i ni=${node[$i]}
+		a=`nstat numa_hit $i`
+		_test_mbind membind $ni
+		_test_mbind preferred $ni
+		b=`nstat numa_hit $i`
+		if [ $(expr $b - $a) -lt $DOUBLEPAGES ]; then
+		    echo "membind/preferred test 2 on node $ni failed $b $a"
+		    failed
+		fi
+	done
+}
+
+# =========================================================================
+main()
+{
+
+	# Get the interval vm statistics refresh at
+	if [ -e /proc/sys/vm/stat_interval ]; then
+		STAT_INTERVAL=`cat /proc/sys/vm/stat_interval`
+		STAT_INTERVAL=`expr $STAT_INTERVAL \* 2`
+	fi
+
+	probe_hardware
+
+	numactl --cpubind=${node[0]} /bin/true
+	numactl --cpubind=${node[1]} /bin/true
+
+	numactl -s
+	numactl --hardware
+
+	numastat > A
+
+	test_process_state
+
+	test_mbind
+
+	numastat > B
+	diff -u A B
+	rm A B
+
+	if [ "$EXIT" = 0 ] ; then
+		echo '========SUCCESS'
+	else
+		echo '========FAILURE'
+		exit 1
+	fi
+}
+
+# =========================================================================
+main
diff --git a/test/regress-io b/test/regress-io
new file mode 100644
index 0000000..3e6e789
--- /dev/null
+++ b/test/regress-io
@@ -0,0 +1,47 @@
+#!/bin/bash
+# test IO affinity parsing
+# tests may fail depending on machine setup
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+E=0
+
+check() {
+	echo testing $@
+	if "$@" ; then
+		true
+	else
+		echo failed
+		E=1
+	fi
+
+}
+
+fail() {
+	echo testing failure of $@
+	if "$@" ; then
+		echo failed
+		E=1
+	else
+		true
+	fi
+}
+
+check "${builddir}/test/node-parse" file:.
+check "${builddir}/test/node-parse" ip:8.8.8.8
+fail "${builddir}/test/node-parse" ip:127.0.0.1
+
+IF=$(ip link ls | grep eth | cut -d: -f2 | head -1)
+check "${builddir}/test/node-parse" "netdev:$IF"
+fail "${builddir}/test/node-parse" netdev:lo
+DEV=$(df | awk '/\/$/ { print $1 }')
+check "${builddir}/test/node-parse" file:$DEV
+check "${builddir}/test/node-parse" block:$(basename $DEV)
+check "${builddir}/test/node-parse" pci:0:0.0
+
+if [ "$E" = 0 ] ; then echo SUCCESS ; else echo FAILURE ; fi
+
+exit $E
diff --git a/test/regress2 b/test/regress2
new file mode 100755
index 0000000..aa6ea41
--- /dev/null
+++ b/test/regress2
@@ -0,0 +1,28 @@
+#!/bin/sh
+# More regression tests for libnuma/numa api
+
+VALGRIND=${VALGRIND:-}
+
+testdir=`dirname "$0"`
+: ${srcdir:=${testdir}/..}
+: ${builddir:=${srcdir}}
+export PATH=${builddir}:$PATH
+
+T() {
+       echo "$@" 
+       if ! $VALGRIND "$@" ;  then
+	  echo	$1 FAILED!!!!
+	  exit 1
+       fi
+       echo
+}
+
+# still broken
+#T "${builddir}/test/prefered"
+T "${builddir}/test/distance"
+T "${builddir}/test/nodemap"
+T "${srcdir}/test/checkaffinity"
+T "${srcdir}/test/checktopology"
+T "${builddir}/test/tbitmap"
+T "${srcdir}/test/bind_range"
+#T "${builddir}/test/randmap"
diff --git a/test/runltp b/test/runltp
new file mode 100755
index 0000000..4e7d979
--- /dev/null
+++ b/test/runltp
@@ -0,0 +1,21 @@
+#!/bin/sh
+# run the Linux Test Project with various numactl settings. will run for a few hours.
+# must run as root
+# You can download LTP from http://ltp.sourceforge.net 
+# Change LTP below to the source directory of a compiled LTP distribution
+
+LTP=/src/ltp
+LEN=2h
+
+LTPOPT="-q -p -t $LEN"
+export PATH=`pwd`/..:$PATH
+
+cd $LTP
+for i in 1 2 3 ; do 
+	numactl --interleave=all ./runltp $LTPOPT -l n.interleave.all.$i
+	numactl --interleave=0,1 ./runltp $LTPOPT -l n.interleave.01.$i
+	numactl --preferred=0 --cpubind=1 ./runltp $LTPOPT -l n.preferred.$i
+# the VM test that allocates all memory may fail	
+	numactl --membind=1 --cpubind=0 ./runltp $LTPOPT -l n.membind1.$i
+	numactl --membind=0,1 ./runltp $LTPOPT -l n.membind01.$i
+done 
diff --git a/test/shmtest b/test/shmtest
new file mode 100755
index 0000000..18c66ee
--- /dev/null
+++ b/test/shmtest
@@ -0,0 +1,104 @@
+#!/bin/sh
+# basic shared memory policy test
+
+
+# hugetlbfs and tmpfs must be mounted on these mount points
+TMPFS=/dev/shm
+HUGE=/huge
+
+#valgrind 3.0.1 doesn't implement mbind() yet on x86-64
+#VALGRIND="valgrind --tool=memcheck"
+VALGRIND=
+
+set -e 
+
+export PATH=`pwd`/..:$PATH
+
+numactl() { 
+	$VALGRIND ../numactl "$@"
+}
+
+failure() { 
+	numastat > after
+	set +e
+	diff -u before after
+	echo
+	echo TEST FAILED
+	exit 1
+}
+
+success() {
+	echo test succeeded
+}	
+
+checkpoint() {
+	numastat > before 
+}	
+
+trap failure EXIT
+
+basictest() { 
+echo initial
+checkpoint
+numactl --length=20m $1 --dump
+echo interleave
+checkpoint
+numactl --offset=2m --length=2m $1 --strict --interleave=0,1 --verify --dump
+echo interleave verify
+checkpoint
+numactl $1 --dump
+echo membind setup
+checkpoint
+numactl --offset 4m --length=2m $1 --strict --membind=1 --verify --dump
+echo membind verify
+checkpoint
+numactl $1 --dump
+echo preferred setup
+checkpoint
+numactl --offset 6m --length 2m $1 --strict --preferred=1 --verify --dump
+echo preferred verify
+checkpoint
+numactl $1 --dump
+
+# check overlaps here
+} 
+
+cleanupshm() { 
+    if [ -f $1 ] ; then
+	ipcrm -M `./ftok $1` || true
+	rm $1
+    fi
+}
+
+
+banner() { 
+echo 
+echo ++++++++++++ $1 +++++++++++++++
+echo
+}
+ 
+banner shm
+cleanupshm A
+basictest --shm=A
+cleanupshm A
+
+banner hugeshm
+cleanupshm B
+basictest "--huge --shm=B"
+cleanupshm B
+
+banner tmpfs 
+basictest "--file $TMPFS/B"
+rm $TMPFS/B
+
+# first need a way to create holey hugetlbfs files.
+
+#banner hugetlbfs
+#basictest "--file $HUGE/B"
+#rm /hugetlbfs/B
+
+rm before
+
+trap success EXIT
+
+
diff --git a/test/tbitmap.c b/test/tbitmap.c
new file mode 100644
index 0000000..4ab48c0
--- /dev/null
+++ b/test/tbitmap.c
@@ -0,0 +1,103 @@
+/* Unit test bitmap parser */
+#define _GNU_SOURCE 1
+//#include <asm/bitops.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "numa.h"
+#include "util.h"
+
+/* For util.c. Fixme. */
+void usage(void)
+{
+	exit(1);
+}
+
+#define ALIGN(x,a) (((x)+(a)-1)&~((a)-1))
+
+#define test_bit(i,p)  ((p)[(i) / BITS_PER_LONG] &   (1UL << ((i)%BITS_PER_LONG)))
+#define set_bit(i,p)   ((p)[(i) / BITS_PER_LONG] |=  (1UL << ((i)%BITS_PER_LONG)))
+#define clear_bit(i,p) ((p)[(i) / BITS_PER_LONG] &= ~(1UL << ((i)%BITS_PER_LONG)))
+
+typedef unsigned u32;
+#define BITS_PER_LONG (sizeof(long)*8)
+
+#define round_up(x,y) (((x) + (y) - 1) & ~((y)-1))
+
+#define CPU_BYTES(x) (round_up(x, BITS_PER_LONG)/8)
+#define CPU_LONGS(x) (CPU_BYTES(x) / sizeof(long))
+
+/* Following routine extracted from Linux 2.6.16 */
+
+#define CHUNKSZ                         32
+#define nbits_to_hold_value(val)        fls(val)
+#define unhex(c)                        (isdigit(c) ? (c - '0') : (toupper(c) - 'A' + 10))
+#define BASEDEC 10              /* fancier cpuset lists input in decimal */
+
+/**
+ * bitmap_scnprintf - convert bitmap to an ASCII hex string.
+ * @buf: byte buffer into which string is placed
+ * @buflen: reserved size of @buf, in bytes
+ * @mask: pointer to struct bitmask to convert
+ *
+ * Hex digits are grouped into comma-separated sets of eight digits per set.
+ */
+int bitmap_scnprintf(char *buf, unsigned int buflen, struct bitmask *mask)
+{
+        int i, word, bit, len = 0;
+        unsigned long val;
+        const char *sep = "";
+        int chunksz;
+        u32 chunkmask;
+
+        chunksz = mask->size & (CHUNKSZ - 1);
+        if (chunksz == 0)
+                chunksz = CHUNKSZ;
+
+        i = ALIGN(mask->size, CHUNKSZ) - CHUNKSZ;
+        for (; i >= 0; i -= CHUNKSZ) {
+                chunkmask = ((1ULL << chunksz) - 1);
+                word = i / BITS_PER_LONG;
+                bit = i % BITS_PER_LONG;
+                val = (mask->maskp[word] >> bit) & chunkmask;
+                len += snprintf(buf+len, buflen-len, "%s%0*lx", sep,
+                        (chunksz+3)/4, val);
+                chunksz = CHUNKSZ;
+                sep = ",";
+        }
+        return len;
+}
+
+extern int numa_parse_bitmap(char  *buf, struct bitmask *mask);
+#define MASKSIZE 300
+
+int main(void)
+{
+	char buf[1024];
+	struct bitmask *mask, *mask2;
+	int i;
+
+	mask  = numa_bitmask_alloc(MASKSIZE);
+	mask2 = numa_bitmask_alloc(MASKSIZE);
+
+	printf("Testing bitmap functions\n");
+	for (i = 0; i < MASKSIZE; i++) {
+		numa_bitmask_clearall(mask);
+		numa_bitmask_clearall(mask2);
+		numa_bitmask_setbit(mask, i);
+		assert(find_first(mask) == i);
+		bitmap_scnprintf(buf, sizeof(buf), mask);
+		strcat(buf,"\n");
+		if (numa_parse_bitmap(buf, mask2) < 0)
+			assert(0);
+		if (memcmp(mask->maskp, mask2->maskp, numa_bitmask_nbytes(mask))) {
+			bitmap_scnprintf(buf, sizeof(buf), mask2);
+			printf("mask2 differs: %s\n", buf);
+			assert(0);
+		}
+	}
+	printf("Passed\n");
+	return 0;
+}
diff --git a/test/tshared.c b/test/tshared.c
new file mode 100644
index 0000000..7ff80e8
--- /dev/null
+++ b/test/tshared.c
@@ -0,0 +1,50 @@
+#include <numa.h>
+#include <numaif.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define err(x) perror(x),exit(1)
+
+enum SZ {
+	MEMSZ = 100<<20,
+	NTHR = 10,
+};
+
+/* test if shared interleaving state works. */
+int main(void)
+{
+	int i, k;
+	char *mem;
+	int pagesz = getpagesize();
+	int max_node;
+
+	if (numa_available() < 0) {
+		printf("no NUMA API available\n");
+		exit(1);
+	}
+	max_node = numa_max_node();
+	mem = numa_alloc_interleaved(MEMSZ);
+	for (i = 0; i < NTHR; i++) {
+		if (fork() == 0) {
+			for (k = i*pagesz; k < MEMSZ; k += pagesz * NTHR) {
+				mem[k] = 1;
+			}
+			_exit(0);
+		}
+	}
+	for (i = 0; i < NTHR; i++)
+		wait(NULL);
+	k = 0;
+	for (i = 0; i < MEMSZ; i += pagesz) {
+		int nd;
+		if (get_mempolicy(&nd, NULL, 0, mem + i, MPOL_F_NODE|MPOL_F_ADDR) < 0)
+			err("get_mempolicy");
+		if (nd != k)
+			printf("offset %d node %d expected %d\n", i, nd, k);
+		k = (k+1)%(max_node+1);
+	}
+
+	return 0;
+}
diff --git a/test/tshm.c b/test/tshm.c
new file mode 100644
index 0000000..79ca02c
--- /dev/null
+++ b/test/tshm.c
@@ -0,0 +1,117 @@
+#include <sys/shm.h>
+#include <sys/ipc.h>
+#include <sys/fcntl.h>
+#include <stdio.h>
+#include <numaif.h>
+
+#define err(x) perror(x),exit(1)
+
+enum {
+	MEMSZ = 10*1024*1024,
+};
+
+struct req {
+	enum cmd {
+		SET = 1,
+		CHECK,
+		REPLY,
+		EXIT,
+	} cmd;
+	long offset;
+	long len;
+	int policy;
+	nodemask_t nodes;
+};
+
+void worker(void)
+{
+	struct req req;
+	while (read(0, &req, sizeof(struct req) > 0)) {
+		switch (req.cmd) {
+		case SET:
+			if (mbind(map + req.offset, req.len, req.policy, &req.nodes,
+				  NUMA_MAX_NODES+1, 0) < 0)
+				err("mbind");
+			break;
+		case TEST:
+			req.cmd = REPLY;
+			if (get_mempolicy(&req.policy, &req.nodes, NUMA_MAX_NODES+1,
+					  map + req.offset, MPOL_F_ADDR) < 0)
+				err("get_mempolicy");
+			write(1, &req, sizeof(struct req));
+			break;
+		case EXIT:
+			return;
+		default:
+			abort();
+		}
+	}
+}
+
+void sendreq(int fd, enum cmd cmd, int policy, long offset, long len, nodemask_t nodes)
+{
+	struct req req = {
+		.cmd = cmd,
+		.offset = offset,
+		.len = len,
+		.policy = policy,
+		.nodes = nodes
+	};
+	if (write(fd, &req, sizeof(struct req)) != sizeof(struct req))
+		panic("bad req write");
+}
+
+void readreq(int fd, int *policy, nodemask_t *nodes, long offset, long len)
+{
+	struct req req;
+	if (read(fd, &req, sizeof(struct req)) != sizeof(struct req))
+		panic("bad req read");
+	if (req.cmd != REPLY)
+		abort();
+	*policy = req.policy;
+	*nodes = req.nodes;
+}
+
+int main(void)
+{
+	int fd = open("tshm", O_CREAT, 0600);
+	close(fd);
+	key_t key = ftok("tshm", 1);
+	int shm = shmget(key, MEMSZ,  IPC_CREAT|0600);
+	if (shm < 0) err("shmget");
+	char *map = shmat(shm, NULL, 0);
+	printf("map = %p\n", map);
+
+	unsigned long nmask = 0x3;
+	if (mbind(map, MEMSZ, MPOL_INTERLEAVE, &nmask, 4, 0) < 0) err("mbind1");
+
+	int fd[2];
+	if (pipe(fd) < 0) err("pipe");
+	if (fork() == 0) {
+		close(0);
+		close(1);
+		dup2(fd[0], 0);
+		dup2(fd[1], 1);
+		worker();
+		_exit(0);
+	}
+
+	int pagesz = getpagesize();
+	int i;
+
+	srand(1);
+	for (;;) {
+
+		/* chose random offset */
+
+		/* either in child or here */
+
+		/* change policy */
+
+		/* ask other guy to check */
+
+	}
+
+	shmdt(map);
+	shmctl(shm, IPC_RMID, 0);
+}
diff --git a/threadtest.c b/threadtest.c
new file mode 100644
index 0000000..33fa7bd
--- /dev/null
+++ b/threadtest.c
@@ -0,0 +1,3 @@
+/* Test if gcc supports thread */
+int __thread x;
+int main(void) { return x; }
diff --git a/util.c b/util.c
new file mode 100644
index 0000000..96fa1aa
--- /dev/null
+++ b/util.c
@@ -0,0 +1,131 @@
+/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
+
+   numactl 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
+   2.
+
+   numactl 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.
+
+   You should find a copy of v2 of the GNU General Public License somewhere
+   on your Linux system; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#include "numa.h"
+#include "numaif.h"
+#include "util.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+
+void printmask(char *name, struct bitmask *mask)
+{
+	int i;
+	printf("%s: ", name);
+	for (i = 0; i < mask->size; i++)
+		if (numa_bitmask_isbitset(mask, i))
+			printf("%d ", i);
+	putchar('\n');
+}
+
+int find_first(struct bitmask *mask)
+{
+	int i;
+	for (i = 0; i < mask->size; i++)
+		if (numa_bitmask_isbitset(mask, i))
+			return i;
+	return -1;
+}
+
+void complain(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	fprintf(stderr, "numactl: ");
+	vfprintf(stderr,fmt,ap);
+	putchar('\n');
+	va_end(ap);
+	exit(1);
+}
+
+void nerror(const char *fmt, ...)
+{
+	int err = errno;
+	va_list ap;
+	va_start(ap,fmt);
+	fprintf(stderr, "numactl: ");
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+	if (err)
+		fprintf(stderr,": %s\n", strerror(err));
+	else
+		fputc('\n', stderr);
+	exit(1);
+}
+
+long memsize(char *s)
+{
+	char *end;
+	long length = strtoul(s,&end,0);
+	switch (toupper(*end)) {
+	case 'G': length *= 1024;  /*FALL THROUGH*/
+	case 'M': length *= 1024;  /*FALL THROUGH*/
+	case 'K': length *= 1024; break;
+	}
+	return length;
+}
+
+static struct policy {
+	char *name;
+	int policy;
+	int noarg;
+} policies[] = {
+	{ "interleave", MPOL_INTERLEAVE, },
+	{ "membind",    MPOL_BIND, },
+	{ "preferred",   MPOL_PREFERRED, },
+	{ "default",    MPOL_DEFAULT, 1 },
+	{ NULL },
+};
+
+static char *policy_names[] = { "default", "preferred", "bind", "interleave" };
+
+char *policy_name(int policy)
+{
+	static char buf[32];
+	if (policy >= array_len(policy_names)) {
+		sprintf(buf, "[%d]", policy);
+		return buf;
+	}
+	return policy_names[policy];
+}
+
+int parse_policy(char *name, char *arg)
+{
+	int k;
+	struct policy *p = NULL;
+	if (!name)
+		return MPOL_DEFAULT;
+	for (k = 0; policies[k].name; k++) {
+		p = &policies[k];
+		if (!strcmp(p->name, name))
+			break;
+	}
+	if (!p || !p->name || (!arg && !p->noarg))
+		usage();
+    return p->policy;
+}
+
+void print_policies(void)
+{
+	int i;
+	printf("Policies:");
+	for (i = 0; policies[i].name; i++)
+		printf(" %s", policies[i].name);
+	printf("\n");
+}
diff --git a/util.h b/util.h
new file mode 100644
index 0000000..8443086
--- /dev/null
+++ b/util.h
@@ -0,0 +1,20 @@
+extern void printmask(char *name, struct bitmask *mask);
+extern int find_first(struct bitmask *mask);
+extern struct bitmask *nodemask(char *s);
+extern struct bitmask *cpumask(char *s, int *ncpus);
+extern int read_sysctl(char *name);
+extern void complain(const char *fmt, ...);
+extern void nerror(const char *fmt, ...);
+
+/* defined in main module, but called by util.c */
+extern void usage(void);
+
+extern long memsize(char *s);
+extern int parse_policy(char *name, char *arg);
+extern void print_policies(void);
+extern char *policy_name(int policy);
+
+#define err(x) perror("numactl: " x),exit(1)
+#define array_len(x) (sizeof(x)/sizeof(*(x)))
+
+#define round_up(x,y) (((x) + (y) - 1) & ~((y)-1))
diff --git a/versions.ldscript b/versions.ldscript
new file mode 100644
index 0000000..eaddc7e
--- /dev/null
+++ b/versions.ldscript
@@ -0,0 +1,175 @@
+# Symbols defined in the library which aren't specifically bound to a
+# version node are effectively bound to an unspecified base version of
+# the library. It is possible to bind all otherwise unspecified symbols
+# to a given version node using `global: *' somewhere in the version script.
+#
+# The interfaces at the "v1" level.
+# At this level we present these functions to the linker (and thus to an
+# application).
+# Any functions not defined in the global list (i.e. "local") will be internal
+# to the library (i.e. not exported but used within the library).
+# Thus the real function names, "numa_bind_v1" etc, are local and won't
+# be known to the linker.
+
+# the first 16 have v1 aliases
+# 3 of the 5 system calls that libnuma provides are common to all versions:
+libnuma_1.1 {
+  global:
+    set_mempolicy;
+    get_mempolicy;
+    mbind;
+    numa_all_nodes;
+    numa_alloc;
+    numa_alloc_interleaved;
+    numa_alloc_interleaved_subset;
+    numa_alloc_local;
+    numa_alloc_onnode;
+    numa_available;
+    numa_bind;
+    numa_distance;
+    numa_error;
+    numa_exit_on_error;
+    numa_free;
+    numa_get_interleave_mask;
+    numa_get_interleave_node;
+    numa_get_membind;
+    numa_get_run_node_mask;
+    numa_interleave_memory;
+    numa_max_node;
+    numa_migrate_pages;
+    numa_no_nodes;
+    numa_node_size64;
+    numa_node_size;
+    numa_node_to_cpus;
+    numa_pagesize;
+    numa_parse_bitmap;
+    numa_police_memory;
+    numa_preferred;
+    numa_run_on_node;
+    numa_run_on_node_mask;
+    numa_sched_getaffinity;
+    numa_sched_setaffinity;
+    numa_set_bind_policy;
+    numa_set_interleave_mask;
+    numa_set_localalloc;
+    numa_set_membind;
+    numa_set_preferred;
+    numa_set_strict;
+    numa_setlocal_memory;
+    numa_tonode_memory;
+    numa_tonodemask_memory;
+    numa_warn;
+    numa_exit_on_warn;
+  local:
+    *;
+};
+
+# The interfaces at the "v2" level.
+# The first 17 have v2 aliases
+# We add the bitmask_ functions
+# and the move_pages and migrate_pages system calls
+# 1.2 depends on 1.1
+
+libnuma_1.2 {
+  global:
+    copy_bitmask_to_nodemask;
+    copy_nodemask_to_bitmask;
+    copy_bitmask_to_bitmask;
+    set_mempolicy;
+    get_mempolicy;
+    mbind;
+    move_pages;
+    migrate_pages;
+    numa_all_cpus_ptr;
+    numa_all_nodes_ptr;
+    numa_alloc;
+    numa_alloc_interleaved;
+    numa_alloc_interleaved_subset;
+    numa_alloc_local;
+    numa_alloc_onnode;
+    numa_realloc;
+    numa_allocate_cpumask;
+    numa_allocate_nodemask;
+    numa_available;
+    numa_bind;
+    numa_bitmask_alloc;
+    numa_bitmask_clearall;
+    numa_bitmask_clearbit;
+    numa_bitmask_equal;
+    numa_bitmask_free;
+    numa_bitmask_isbitset;
+    numa_bitmask_nbytes;
+    numa_bitmask_setall;
+    numa_bitmask_setbit;
+    numa_bitmask_weight;
+    numa_distance;
+    numa_error;
+    numa_exit_on_error;
+    numa_free;
+    numa_get_interleave_mask;
+    numa_get_interleave_node;
+    numa_get_membind;
+    numa_get_mems_allowed;
+    numa_get_run_node_mask;
+    numa_interleave_memory;
+    numa_max_node;
+    numa_max_possible_node;
+    numa_migrate_pages;
+    numa_move_pages;
+    numa_no_nodes_ptr;
+    numa_node_size64;
+    numa_node_size;
+    numa_node_to_cpus;
+    numa_node_of_cpu;
+    numa_nodes_ptr;
+    numa_num_configured_cpus;
+    numa_num_configured_nodes;
+    numa_num_possible_nodes;
+    numa_num_task_cpus;
+    numa_num_task_nodes;
+    numa_num_thread_cpus;
+    numa_num_thread_nodes;
+    numa_pagesize;
+    numa_parse_bitmap;
+    numa_parse_cpustring;
+    numa_parse_nodestring;
+    numa_police_memory;
+    numa_preferred;
+    numa_run_on_node;
+    numa_run_on_node_mask;
+    numa_sched_getaffinity;
+    numa_sched_setaffinity;
+    numa_set_bind_policy;
+    numa_set_interleave_mask;
+    numa_set_localalloc;
+    numa_set_membind;
+    numa_set_preferred;
+    numa_set_strict;
+    numa_setlocal_memory;
+    numa_tonode_memory;
+    numa_tonodemask_memory;
+    numa_warn;
+  local:
+    *;
+} libnuma_1.1;
+
+# New parsing interface for cpu/numastrings
+# was added into version 1.3
+
+libnuma_1.3 {
+  global:
+    numa_parse_cpustring_all;
+    numa_parse_nodestring_all;
+    numa_num_possible_cpus;
+  local:
+    *;
+} libnuma_1.2;
+
+# New interface with customizable cpuset awareness
+# was added into version 1.4
+libnuma_1.4 {
+  global:
+    numa_run_on_node_mask_all;
+  local:
+    *;
+} libnuma_1.3;