auto import from //depot/cupcake/@135843android-sdk-tools_r2android-sdk-1.6_r2android-sdk-1.6_r1android-sdk-1.6-docs_r1android-sdk-1.5_r3android-sdk-1.5_r1android-sdk-1.5-preandroid-1.6_r2android-1.6_r1.5android-1.6_r1.4android-1.6_r1.3android-1.6_r1.2android-1.6_r1.1android-1.6_r1android-1.5r4android-1.5r3android-1.5r2android-1.5donut-release2donut-releasedonutcupcake-releasecupcake

103 files changed, 15275 insertions, 0 deletions

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..582ddc9
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,3 @@
+ifeq ($(TARGET_ARCH),arm)
+include $(call all-subdir-makefiles)
+endif
diff --git a/MODULE_LICENSE_GPL b/MODULE_LICENSE_GPL
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_GPL
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..d60c31a
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  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 Library 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 Library General
+Public License instead of this License.
diff --git a/config.h b/config.h
new file mode 100644
index 0000000..c220da5
--- /dev/null
+++ b/config.h
@@ -0,0 +1,101 @@
+/* config.h.  Generated by configure.  */
+/* config.h.in.  Generated from configure.in by autoheader.  */
+
+/* whether popt prototype takes a const char ** */
+#define CONST_POPT 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `bfd' library (-lbfd). */
+#define HAVE_LIBBFD 1
+
+/* Define to 1 if you have the `iberty' library (-liberty). */
+#define HAVE_LIBIBERTY 1
+
+/* Define to 1 if you have the <libiberty.h> header file. */
+/* #undef HAVE_LIBIBERTY_H */
+
+/* Define to 1 if you have the `popt' library (-lpopt). */
+#define HAVE_LIBPOPT 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `perfmonctl' function. */
+/* #undef HAVE_PERFMONCTL */
+
+/* Define to 1 if you have the `sched_setaffinity' function. */
+/* #undef HAVE_SCHED_SETAFFINITY */
+
+/* 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 1 if you have the `xcalloc' function. */
+#undef HAVE_XCALLOC
+
+/* Define to 1 if you have the `xmemdup' function. */
+#undef HAVE_XMEMDUP
+
+/* whether malloc attribute is understood */
+#define MALLOC_ATTRIBUTE_OK 1
+
+/* whether to build ABI tools */
+#define OPROF_ABI 1
+
+/* package binary directory */
+#define OP_BINDIR "/usr/local/bin/"
+
+/* package data directory */
+#define OP_DATADIR "/usr/local/share/oprofile/"
+
+/* Name of package */
+#define PACKAGE "oprofile"
+
+/* 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 ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Synthesize special symbols when needed */
+/* #undef SYNTHESIZE_SYMBOLS */
+
+/* whether bfd.h defines bool values */
+/* #undef TRUE_FALSE_ALREADY_DEFINED */
+
+/* Version number of package */
+#define VERSION "0.9.1"
+
+/* Define to 1 if the X Window System is missing or not being used. */
+/* #undef X_DISPLAY_MISSING */
diff --git a/daemon/Android.mk b/daemon/Android.mk
new file mode 100644
index 0000000..abee74c
--- /dev/null
+++ b/daemon/Android.mk
@@ -0,0 +1,33 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	init.c \
+	opd_anon.c \
+	opd_cookie.c \
+	opd_events.c \
+	opd_kernel.c \
+	opd_mangling.c \
+	opd_perfmon.c \
+	opd_pipe.c \
+	opd_sfile.c \
+	opd_spu.c \
+	opd_stats.c \
+	opd_trans.c \
+	oprofiled.c
+
+LOCAL_STATIC_LIBRARIES := \
+	libpopt libutil libdb libabi libop
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/.. \
+	$(LOCAL_PATH)/../libdb \
+	$(LOCAL_PATH)/../libutil \
+	$(LOCAL_PATH)/../libop \
+	$(LOCAL_PATH)/../libabi
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE:= oprofiled
+
+include $(BUILD_EXECUTABLE)
diff --git a/daemon/init.c b/daemon/init.c
new file mode 100644
index 0000000..be0b9da
--- /dev/null
+++ b/daemon/init.c
@@ -0,0 +1,373 @@
+/**
+ * @file daemon/init.c
+ * Daemon set up and main loop for 2.6
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * @Modifications Daniel Hansel
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ */
+
+#include "config.h"
+ 
+#include "oprofiled.h"
+#include "opd_stats.h"
+#include "opd_sfile.h"
+#include "opd_pipe.h"
+#include "opd_kernel.h"
+#include "opd_trans.h"
+#include "opd_anon.h"
+#include "opd_perfmon.h"
+#include "opd_printf.h"
+
+#include "op_version.h"
+#include "op_config.h"
+#include "op_deviceio.h"
+#include "op_get_time.h"
+#include "op_libiberty.h"
+#include "op_fileio.h"
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#if ANDROID
+#include <sys/wait.h>
+#else
+#include <wait.h>
+#endif
+#include <string.h>
+
+size_t kernel_pointer_size;
+
+static fd_t devfd;
+static char * sbuf;
+static size_t s_buf_bytesize;
+extern char * session_dir;
+static char start_time_str[32];
+static int jit_conversion_running;
+
+static void opd_sighup(void);
+static void opd_alarm(void);
+static void opd_sigterm(void);
+static void opd_sigchild(void);
+static void opd_do_jitdumps(void);
+
+/**
+ * opd_open_files - open necessary files
+ *
+ * Open the device files and the log file,
+ * and mmap() the hash map.
+ */
+static void opd_open_files(void)
+{
+	devfd = op_open_device("/dev/oprofile/buffer");
+	if (devfd == -1) {
+		if (errno == EINVAL)
+			fprintf(stderr, "Failed to open device. Possibly you have passed incorrect\n"
+				"parameters. Check /var/log/messages.");
+		else
+			perror("Failed to open profile device");
+		exit(EXIT_FAILURE);
+	}
+
+	/* give output before re-opening stdout as the logfile */
+	printf("Using log file %s\n", op_log_file);
+
+	/* set up logfile */
+	close(0);
+	close(1);
+
+	if (open("/dev/null", O_RDONLY) == -1) {
+		perror("oprofiled: couldn't re-open stdin as /dev/null: ");
+		exit(EXIT_FAILURE);
+	}
+
+	opd_open_logfile();
+	opd_create_pipe();
+
+	printf("oprofiled started %s", op_get_time());
+	printf("kernel pointer size: %lu\n",
+		(unsigned long)kernel_pointer_size);
+	fflush(stdout);
+}
+ 
+
+/** Done writing out the samples, indicate with complete_dump file */
+static void complete_dump(void)
+{
+	FILE * status_file;
+
+retry:
+	status_file = fopen(op_dump_status, "w");
+
+	if (!status_file && errno == EMFILE) {
+		if (sfile_lru_clear()) {
+			printf("LRU cleared but file open fails for %s.\n",
+			       op_dump_status);
+			abort();
+		}
+		goto retry;
+	}
+
+	if (!status_file) {
+		perror("warning: couldn't set complete_dump: ");
+		return;
+	}
+
+	fprintf(status_file, "1\n");
+	fclose(status_file);
+}
+
+ 
+/**
+ * opd_do_samples - process a sample buffer
+ * @param opd_buf  buffer to process
+ *
+ * Process a buffer of samples.
+ *
+ * If the sample could be processed correctly, it is written
+ * to the relevant sample file.
+ */
+static void opd_do_samples(char const * opd_buf, ssize_t count)
+{
+	size_t num = count / kernel_pointer_size;
+ 
+	opd_stats[OPD_DUMP_COUNT]++;
+
+	verbprintf(vmisc, "Read buffer of %d entries.\n", (unsigned int)num);
+ 
+	opd_process_samples(opd_buf, num);
+
+	complete_dump();
+}
+ 
+static void opd_do_jitdumps(void)
+{ 
+	pid_t childpid;
+	int arg_num;
+	unsigned long long end_time = 0ULL;
+	struct timeval tv;
+	char end_time_str[32];
+	char opjitconv_path[PATH_MAX + 1];
+	char * exec_args[6];
+
+	if (jit_conversion_running)
+		return;
+	jit_conversion_running = 1;
+
+	childpid = fork();
+	switch (childpid) {
+		case -1:
+			perror("Error forking JIT dump process!");
+			break;
+		case 0:
+			gettimeofday(&tv, NULL);
+			end_time = tv.tv_sec;
+			sprintf(end_time_str, "%llu", end_time);
+			sprintf(opjitconv_path, "%s/%s", OP_BINDIR, "opjitconv");
+			arg_num = 0;
+			exec_args[arg_num++] = opjitconv_path;
+			if (vmisc)
+				exec_args[arg_num++] = "-d";
+			exec_args[arg_num++] = session_dir;
+			exec_args[arg_num++] = start_time_str;
+			exec_args[arg_num++] = end_time_str;
+			exec_args[arg_num] = (char *) NULL;
+			execvp("opjitconv", exec_args);
+			fprintf(stderr, "Failed to exec %s: %s\n",
+			        exec_args[0], strerror(errno));
+			/* We don't want any cleanup in the child */
+			_exit(EXIT_FAILURE);
+		default:
+			break;
+	} 
+
+} 
+
+/**
+ * opd_do_read - enter processing loop
+ * @param buf  buffer to read into
+ * @param size  size of buffer
+ *
+ * Read some of a buffer from the device and process
+ * the contents.
+ */
+static void opd_do_read(char * buf, size_t size)
+{
+	opd_open_pipe();
+
+	while (1) {
+		ssize_t count = -1;
+
+		/* loop to handle EINTR */
+		while (count < 0) {
+			count = op_read_device(devfd, buf, size);
+
+			/* we can lose an alarm or a hup but
+			 * we don't care.
+			 */
+			if (signal_alarm) {
+				signal_alarm = 0;
+				opd_alarm();
+			}
+
+			if (signal_hup) {
+				signal_hup = 0;
+				opd_sighup();
+			}
+
+			if (signal_term)
+				opd_sigterm();
+
+			if (signal_child)
+				opd_sigchild();
+
+			if (signal_usr1) {
+				signal_usr1 = 0;
+				perfmon_start();
+			}
+
+			if (signal_usr2) {
+				signal_usr2 = 0;
+				perfmon_stop();
+			}
+
+			if (is_jitconv_requested()) {
+				verbprintf(vmisc, "Start opjitconv was triggered\n");
+				opd_do_jitdumps();
+			}
+		}
+
+		opd_do_samples(buf, count);
+	}
+	
+	opd_close_pipe();
+}
+
+
+/** opd_alarm - sync files and report stats */
+static void opd_alarm(void)
+{
+	sfile_sync_files();
+	opd_print_stats();
+	alarm(60 * 10);
+}
+ 
+
+/** re-open files for logrotate/opcontrol --reset */
+static void opd_sighup(void)
+{
+	printf("Received SIGHUP.\n");
+	/* We just close them, and re-open them lazily as usual. */
+	sfile_close_files();
+	close(1);
+	close(2);
+	opd_open_logfile();
+}
+
+
+static void clean_exit(void)
+{
+	perfmon_exit();
+	unlink(op_lock_file);
+}
+
+
+static void opd_sigterm(void)
+{
+	opd_do_jitdumps();
+	opd_print_stats();
+	printf("oprofiled stopped %s", op_get_time());
+	exit(EXIT_FAILURE);
+}
+
+/* SIGCHLD received from JIT dump child process. */
+static void opd_sigchild(void)
+{
+	int child_status;
+	wait(&child_status);
+	jit_conversion_running = 0;
+	if (WIFEXITED(child_status) && (!WEXITSTATUS(child_status))) {
+		verbprintf(vmisc, "JIT dump processing complete.\n");
+	} else {
+		printf("JIT dump processing exited abnormally: %d\n",
+		       WEXITSTATUS(child_status));
+	}
+
+}
+ 
+static void opd_26_init(void)
+{
+	size_t i;
+	size_t opd_buf_size;
+	unsigned long long start_time = 0ULL;
+	struct timeval tv;
+
+	opd_create_vmlinux(vmlinux, kernel_range);
+	opd_create_xen(xenimage, xen_range);
+
+	opd_buf_size = opd_read_fs_int("/dev/oprofile/", "buffer_size", 1);
+	kernel_pointer_size = opd_read_fs_int("/dev/oprofile/", "pointer_size", 1);
+
+	s_buf_bytesize = opd_buf_size * kernel_pointer_size;
+
+	sbuf = xmalloc(s_buf_bytesize);
+
+	opd_reread_module_info();
+
+	for (i = 0; i < OPD_MAX_STATS; i++)
+		opd_stats[i] = 0;
+
+	perfmon_init();
+
+	cookie_init();
+	sfile_init();
+	anon_init();
+
+	/* must be /after/ perfmon_init() at least */
+	if (atexit(clean_exit)) {
+		perfmon_exit();
+		perror("oprofiled: couldn't set exit cleanup: ");
+		exit(EXIT_FAILURE);
+	}
+
+	/* trigger kernel module setup before returning control to opcontrol */
+	opd_open_files();
+	gettimeofday(&tv, NULL);
+	start_time = 0ULL;
+	start_time = tv.tv_sec;
+	sprintf(start_time_str, "%llu", start_time);
+		  
+}
+
+
+static void opd_26_start(void)
+{
+	/* simple sleep-then-process loop */
+	opd_do_read(sbuf, s_buf_bytesize);
+}
+
+
+static void opd_26_exit(void)
+{
+	opd_print_stats();
+	printf("oprofiled stopped %s", op_get_time());
+
+	free(sbuf);
+	free(vmlinux);
+	/* FIXME: free kernel images, sfiles etc. */
+}
+
+struct oprofiled_ops opd_26_ops = {
+	.init = opd_26_init,
+	.start = opd_26_start,
+	.exit = opd_26_exit,
+};
diff --git a/daemon/opd_anon.c b/daemon/opd_anon.c
new file mode 100644
index 0000000..9caea3d
--- /dev/null
+++ b/daemon/opd_anon.c
@@ -0,0 +1,228 @@
+/**
+ * @file opd_anon.c
+ * Anonymous region handling.
+ *
+ * Our caching of maps has some problems: if we get tgid reuse,
+ * and it's the same application, we might end up with wrong
+ * maps. The same happens in an unmap-remap case. There's not much
+ * we can do about this, we just hope it's not too common...
+ *
+ * What is relatively common is expanding anon maps, which leaves us
+ * with lots of separate sample files.
+ *
+ * @remark Copyright 2005 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @Modifications Gisle Dankel
+ */
+
+#include "opd_anon.h"
+#include "opd_trans.h"
+#include "opd_sfile.h"
+#include "opd_printf.h"
+#include "op_libiberty.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define HASH_SIZE 1024
+#define HASH_BITS (HASH_SIZE - 1)
+
+/*
+ * Note that this value is tempered by the fact that when we miss in the
+ * anon cache, we'll tear down all the mappings for that tgid. Thus, LRU
+ * of a mapping can potentially clear out a much larger number of
+ * mappings.
+ */
+#define LRU_SIZE 8192
+#define LRU_AMOUNT (LRU_SIZE/8)
+
+static struct list_head hashes[HASH_SIZE];
+static struct list_head lru;
+static size_t nr_lru;
+
+static void do_lru(struct transient * trans)
+{
+	size_t nr_to_kill = LRU_AMOUNT;
+	struct list_head * pos;
+	struct list_head * pos2;
+	struct anon_mapping * entry;
+
+	list_for_each_safe(pos, pos2, &lru) {
+		entry = list_entry(pos, struct anon_mapping, lru_list);
+		if (trans->anon == entry)
+			clear_trans_current(trans);
+		if (trans->last_anon == entry)
+			clear_trans_last(trans);
+		sfile_clear_anon(entry);
+		list_del(&entry->list);
+		list_del(&entry->lru_list);
+		--nr_lru;
+		free(entry);
+		if (nr_to_kill-- == 0)
+			break;
+	}
+}
+
+
+static unsigned long hash_anon(pid_t tgid, cookie_t app)
+{
+	return ((app >> DCOOKIE_SHIFT) ^ (tgid >> 2)) & (HASH_SIZE - 1);
+}
+ 
+
+static void clear_anon_maps(struct transient * trans)
+{
+	unsigned long hash = hash_anon(trans->tgid, trans->app_cookie);
+	pid_t tgid = trans->tgid;
+	cookie_t app = trans->app_cookie;
+	struct list_head * pos;
+	struct list_head * pos2;
+	struct anon_mapping * entry;
+
+	clear_trans_current(trans);
+
+	list_for_each_safe(pos, pos2, &hashes[hash]) {
+		entry = list_entry(pos, struct anon_mapping, list);
+		if (entry->tgid == tgid && entry->app_cookie == app) {
+			if (trans->last_anon == entry)
+				clear_trans_last(trans);
+			sfile_clear_anon(entry);
+			list_del(&entry->list);
+			list_del(&entry->lru_list);
+			--nr_lru;
+			free(entry);
+		}
+	}
+
+	if (vmisc) {
+		char const * name = verbose_cookie(app);
+		printf("Cleared anon maps for tgid %u (%s).\n", tgid, name);
+	}
+}
+
+
+static void
+add_anon_mapping(struct transient * trans, vma_t start, vma_t end, char * name)
+{
+	unsigned long hash = hash_anon(trans->tgid, trans->app_cookie);
+	struct anon_mapping * m = xmalloc(sizeof(struct anon_mapping));
+	m->tgid = trans->tgid;
+	m->app_cookie = trans->app_cookie;
+	m->start = start;
+	m->end = end;
+	strncpy(m->name, name, MAX_IMAGE_NAME_SIZE + 1);
+	list_add_tail(&m->list, &hashes[hash]);
+	list_add_tail(&m->lru_list, &lru);
+	if (++nr_lru == LRU_SIZE)
+		do_lru(trans);
+	if (vmisc) {
+		char const * name = verbose_cookie(m->app_cookie);
+		printf("Added anon map 0x%llx-0x%llx for tgid %u (%s).\n",
+		       start, end, m->tgid, name);
+	}
+}
+
+
+/* 42000000-4212f000 r-xp 00000000 16:03 424334 /lib/tls/libc-2.3.2.so */
+static void get_anon_maps(struct transient * trans)
+{
+	FILE * fp = NULL;
+	char buf[PATH_MAX];
+	vma_t start, end;
+	int ret;
+
+	snprintf(buf, PATH_MAX, "/proc/%d/maps", trans->tgid);
+	fp = fopen(buf, "r");
+	if (!fp)
+		return;
+
+	while (fgets(buf, PATH_MAX, fp) != NULL) {
+		char tmp[MAX_IMAGE_NAME_SIZE + 1];
+		char name[MAX_IMAGE_NAME_SIZE + 1];
+		/* Some anon maps have labels like
+		 * [heap], [stack], [vdso], [vsyscall] ...
+		 * Keep track of these labels. If a map has no name, call it "anon".
+		 * Ignore all mappings starting with "/" (file or shared memory object)
+		 */
+		strcpy(name, "anon");
+		ret = sscanf(buf, "%llx-%llx %20s %20s %20s %20s %20s",
+		             &start, &end, tmp, tmp, tmp, tmp, name);
+		if (ret < 6 || name[0] == '/')
+			continue;
+
+		add_anon_mapping(trans, start, end, name);
+	}
+
+	fclose(fp);
+}
+
+
+static int
+anon_match(struct transient const * trans, struct anon_mapping const * anon)
+{
+	if (!anon)
+		return 0;
+	if (trans->tgid != anon->tgid)
+		return 0;
+	if (trans->app_cookie != anon->app_cookie)
+		return 0;
+	if (trans->pc < anon->start)
+		return 0;
+	return (trans->pc < anon->end);
+}
+
+
+struct anon_mapping * find_anon_mapping(struct transient * trans)
+{
+	unsigned long hash = hash_anon(trans->tgid, trans->app_cookie);
+	struct list_head * pos;
+	struct anon_mapping * entry;
+	int tried = 0;
+
+	if (anon_match(trans, trans->anon))
+		return (trans->anon);
+
+retry:
+	list_for_each(pos, &hashes[hash]) {
+		entry = list_entry(pos, struct anon_mapping, list);
+		if (anon_match(trans, entry))
+			goto success;
+	}
+
+	if (!tried) {
+		clear_anon_maps(trans);
+		get_anon_maps(trans);
+		tried = 1;
+		goto retry;
+	}
+
+	return NULL;
+
+success:
+	/*
+	 * Typically, there's one big mapping that matches. Let's go
+	 * faster.
+	 */
+	list_del(&entry->list);
+	list_add(&entry->list, &hashes[hash]);
+
+	verbprintf(vmisc, "Found range 0x%llx-0x%llx for tgid %u, pc %llx.\n",
+	           entry->start, entry->end, (unsigned int)entry->tgid,
+		   trans->pc);
+	return entry;
+}
+
+
+void anon_init(void)
+{
+	size_t i;
+
+	for (i = 0; i < HASH_SIZE; ++i)
+		list_init(&hashes[i]);
+
+	list_init(&lru);
+}
diff --git a/daemon/opd_anon.h b/daemon/opd_anon.h
new file mode 100644
index 0000000..3f66b55
--- /dev/null
+++ b/daemon/opd_anon.h
@@ -0,0 +1,54 @@
+/**
+ * @file opd_anon.h
+ * Anonymous region handling.
+ *
+ * @remark Copyright 2005 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ */
+
+#ifndef OPD_ANON_H
+#define OPD_ANON_H
+
+#include "op_types.h"
+#include "op_list.h"
+
+#include "opd_cookie.h"
+
+#include <sys/types.h>
+
+struct transient;
+
+/**
+ * Shift useful bits into play for VMA hashing.
+ */
+#define VMA_SHIFT 13 
+
+/* Maximum size of the image name considered */
+#define MAX_IMAGE_NAME_SIZE 20
+
+struct anon_mapping {
+	/** start of the mapping */
+	vma_t start;
+	/** end of the mapping */
+	vma_t end;
+	/** tgid of the app */
+	pid_t tgid;
+	/** cookie of the app */
+	cookie_t app_cookie;
+	/** hash list */
+	struct list_head list;
+	/** lru list */
+	struct list_head lru_list;
+	char name[MAX_IMAGE_NAME_SIZE+1];
+};
+
+/**
+ * Try to find an anonymous mapping for the given pc/tgid pair.
+ */
+struct anon_mapping * find_anon_mapping(struct transient *);
+
+void anon_init(void);
+
+#endif /* OPD_ANON_H */
diff --git a/daemon/opd_cookie.c b/daemon/opd_cookie.c
new file mode 100644
index 0000000..3578e48
--- /dev/null
+++ b/daemon/opd_cookie.c
@@ -0,0 +1,209 @@
+/**
+ * @file opd_cookie.c
+ * cookie -> name cache
+ *
+ * @remark Copyright 2002, 2005 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ */
+
+#include "opd_cookie.h"
+#include "oprofiled.h"
+#include "op_list.h"
+#include "op_libiberty.h"
+
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#ifndef __NR_lookup_dcookie
+#if defined(__i386__)
+#define __NR_lookup_dcookie 253
+#elif defined(__x86_64__)
+#define __NR_lookup_dcookie 212
+#elif defined(__powerpc__)
+#define __NR_lookup_dcookie 235
+#elif defined(__alpha__)
+#define __NR_lookup_dcookie 406
+#elif defined(__hppa__)
+#define __NR_lookup_dcookie 223
+#elif defined(__ia64__)
+#define __NR_lookup_dcookie 1237
+#elif defined(__sparc__)
+/* untested */
+#define __NR_lookup_dcookie 208
+#elif defined(__s390__) || defined (__s390x__)
+#define __NR_lookup_dcookie 110
+#elif defined(__arm__)
+#define __NR_lookup_dcookie (__NR_SYSCALL_BASE+249)
+#elif defined(__mips__)
+#include <sgidefs.h>
+/* O32 */
+#if _MIPS_SIM == _MIPS_SIM_ABI32
+#define __NR_lookup_dcookie 4247
+/* N64 */
+#elif _MIPS_SIM == _MIPS_SIM_ABI64
+#define __NR_lookup_dcookie 5206
+/* N32 */
+#elif _MIPS_SIM == _MIPS_SIM_NABI32
+#define __NR_lookup_dcookie 6206
+#else
+#error Unknown MIPS ABI: Dunno __NR_lookup_dcookie
+#endif
+#else
+#error Please define __NR_lookup_dcookie for your architecture
+#endif
+#endif /* __NR_lookup_dcookie */
+
+#if (defined(__powerpc__) && !defined(__powerpc64__)) || defined(__hppa__)\
+	|| (defined(__s390__) && !defined(__s390x__)) \
+	|| (defined(__mips__) && (_MIPS_SIM == _MIPS_SIM_ABI32) \
+	    && defined(__MIPSEB__)) \
+        || (defined(__arm__) && defined(__ARM_EABI__) \
+            && defined(__ARMEB__))
+static inline int lookup_dcookie(cookie_t cookie, char * buf, size_t size)
+{
+	return syscall(__NR_lookup_dcookie, (unsigned long)(cookie >> 32),
+		       (unsigned long)(cookie & 0xffffffff), buf, size);
+}
+#elif (defined(__mips__) && (_MIPS_SIM == _MIPS_SIM_ABI32)) \
+	|| (defined(__arm__) && defined(__ARM_EABI__))
+static inline int lookup_dcookie(cookie_t cookie, char * buf, size_t size)
+{
+	return syscall(__NR_lookup_dcookie,
+		       (unsigned long)(cookie & 0xffffffff),
+		       (unsigned long)(cookie >> 32), buf, size);
+}
+#else
+static inline int lookup_dcookie(cookie_t cookie, char * buf, size_t size)
+{
+	return syscall(__NR_lookup_dcookie, cookie, buf, size);
+}
+#endif
+
+
+struct cookie_entry {
+	cookie_t value;
+	char * name;
+	int ignored;
+	struct list_head list;
+};
+
+
+#define HASH_SIZE 512
+#define HASH_BITS (HASH_SIZE - 1)
+
+static struct list_head hashes[HASH_SIZE];
+
+static struct cookie_entry * create_cookie(cookie_t cookie)
+{
+	int err;
+	struct cookie_entry * entry = xmalloc(sizeof(struct cookie_entry));
+
+	entry->value = cookie;
+	entry->name = xmalloc(PATH_MAX + 1);
+
+	err = lookup_dcookie(cookie, entry->name, PATH_MAX);
+
+	if (err < 0) {
+		fprintf(stderr, "Lookup of cookie %llx failed, errno=%d\n",
+		       cookie, errno); 
+		free(entry->name);
+		entry->name = NULL;
+		entry->ignored = 0;
+	} else {
+		entry->ignored = is_image_ignored(entry->name);
+	}
+
+	return entry;
+}
+
+
+/* Cookie monster want cookie! */
+static unsigned long hash_cookie(cookie_t cookie)
+{
+	return (cookie >> DCOOKIE_SHIFT) & (HASH_SIZE - 1);
+}
+ 
+
+char const * find_cookie(cookie_t cookie)
+{
+	unsigned long hash = hash_cookie(cookie);
+	struct list_head * pos;
+	struct cookie_entry * entry;
+
+	if (cookie == INVALID_COOKIE || cookie == NO_COOKIE)
+		return NULL;
+
+	list_for_each(pos, &hashes[hash]) {
+		entry = list_entry(pos, struct cookie_entry, list);
+		if (entry->value == cookie)
+			goto out;
+	}
+
+	/* not sure this can ever happen due to is_cookie_ignored */
+	entry = create_cookie(cookie);
+	list_add(&entry->list, &hashes[hash]);
+out:
+	return entry->name;
+}
+
+
+int is_cookie_ignored(cookie_t cookie)
+{
+	unsigned long hash = hash_cookie(cookie);
+	struct list_head * pos;
+	struct cookie_entry * entry;
+
+	if (cookie == INVALID_COOKIE || cookie == NO_COOKIE)
+		return 1;
+
+	list_for_each(pos, &hashes[hash]) {
+		entry = list_entry(pos, struct cookie_entry, list);
+		if (entry->value == cookie)
+			goto out;
+	}
+
+	entry = create_cookie(cookie);
+	list_add(&entry->list, &hashes[hash]);
+out:
+	return entry->ignored;
+}
+
+
+char const * verbose_cookie(cookie_t cookie)
+{
+	unsigned long hash = hash_cookie(cookie);
+	struct list_head * pos;
+	struct cookie_entry * entry;
+
+	if (cookie == INVALID_COOKIE)
+		return "invalid";
+
+	if (cookie == NO_COOKIE)
+		return "anonymous";
+
+	list_for_each(pos, &hashes[hash]) {
+		entry = list_entry(pos, struct cookie_entry, list);
+		if (entry->value == cookie) {
+			if (!entry->name)
+				return "failed lookup";
+			return entry->name;
+		}
+	}
+
+	return "not hashed";
+}
+
+
+void cookie_init(void)
+{
+	size_t i;
+
+	for (i = 0; i < HASH_SIZE; ++i)
+		list_init(&hashes[i]);
+}
diff --git a/daemon/opd_cookie.h b/daemon/opd_cookie.h
new file mode 100644
index 0000000..a9f13b1
--- /dev/null
+++ b/daemon/opd_cookie.h
@@ -0,0 +1,39 @@
+/**
+ * @file opd_cookie.h
+ * cookie -> name cache
+ *
+ * @remark Copyright 2002, 2005 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ */
+
+#ifndef OPD_COOKIE_H
+#define OPD_COOKIE_H
+
+typedef unsigned long long cookie_t;
+
+#define INVALID_COOKIE ~0LLU
+#define NO_COOKIE 0LLU
+
+/**
+ * Shift value to remove trailing zero on a dcookie value, 7 is sufficient
+ * for most architecture
+ */
+#define DCOOKIE_SHIFT 7
+
+/**
+ * Return the name of the given dcookie. May return
+ * NULL on failure.
+ */
+char const * find_cookie(cookie_t cookie);
+
+/** return true if this cookie should be ignored */
+int is_cookie_ignored(cookie_t cookie);
+
+/** give a textual description of the cookie */
+char const * verbose_cookie(cookie_t cookie);
+
+void cookie_init(void);
+
+#endif /* OPD_COOKIE_H */
diff --git a/daemon/opd_events.c b/daemon/opd_events.c
new file mode 100644
index 0000000..81a87d2
--- /dev/null
+++ b/daemon/opd_events.c
@@ -0,0 +1,165 @@
+/**
+ * @file daemon/opd_events.c
+ * Event details for each counter
+ *
+ * @remark Copyright 2002, 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "config.h"
+ 
+#include "opd_events.h"
+#include "opd_printf.h"
+#include "oprofiled.h"
+
+#include "op_string.h"
+#include "op_config.h"
+#include "op_cpufreq.h"
+#include "op_cpu_type.h"
+#include "op_libiberty.h"
+#include "op_hw_config.h"
+#include "op_sample_file.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+extern op_cpu cpu_type;
+
+struct opd_event opd_events[OP_MAX_COUNTERS];
+
+static double cpu_speed;
+
+static void malformed_events(void)
+{
+	fprintf(stderr, "oprofiled: malformed events passed "
+	        "on the command line\n");
+	exit(EXIT_FAILURE);
+}
+
+
+static char * copy_token(char ** c, char delim)
+{
+	char * tmp = *c;
+	char * tmp2 = *c;
+	char * str;
+
+	if (!**c)
+		return NULL;
+
+	while (*tmp2 && *tmp2 != delim)
+		++tmp2;
+
+	if (tmp2 == tmp)
+		return NULL;
+
+	str = op_xstrndup(tmp, tmp2 - tmp);
+	*c = tmp2;
+	if (**c)
+		++*c;
+	return str;
+}
+
+
+static unsigned long copy_ulong(char ** c, char delim)
+{
+	unsigned long val = 0;
+	char * str = copy_token(c, delim);
+	if (!str)
+		malformed_events();
+	val = strtoul(str, NULL, 0);
+	free(str);
+	return val;
+}
+
+
+void opd_parse_events(char const * events)
+{
+	char * ev = xstrdup(events);
+	char * c;
+	size_t cur = 0;
+
+	if (cpu_type == CPU_TIMER_INT) {
+		struct opd_event * event = &opd_events[0];
+		event->name = xstrdup("TIMER");
+		event->value = event->counter
+			= event->count = event->um = 0;
+		event->kernel = 1;
+		event->user = 1;
+		return;
+	}
+
+	if (!ev || !strlen(ev)) {
+		fprintf(stderr, "oprofiled: no events passed.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	verbprintf(vmisc, "Events: %s\n", ev);
+
+	c = ev;
+
+	while (*c && cur < op_nr_counters) {
+		struct opd_event * event = &opd_events[cur];
+
+		if (!(event->name = copy_token(&c, ':')))
+			malformed_events();
+		event->value = copy_ulong(&c, ':');
+		event->counter = copy_ulong(&c, ':');
+		event->count = copy_ulong(&c, ':');
+		event->um = copy_ulong(&c, ':');
+		event->kernel = copy_ulong(&c, ':');
+		event->user = copy_ulong(&c, ',');
+		++cur;
+	}
+
+	if (*c) {
+		fprintf(stderr, "oprofiled: too many events passed.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	free(ev);
+
+	cpu_speed = op_cpu_frequency();
+}
+
+
+struct opd_event * find_counter_event(unsigned long counter)
+{
+	size_t i;
+
+	for (i = 0; i < op_nr_counters && opd_events[i].name; ++i) {
+		if (counter == opd_events[i].counter)
+			return &opd_events[i];
+	}
+
+	fprintf(stderr, "Unknown event for counter %lu\n", counter);
+	abort();
+	return NULL;
+}
+
+
+void fill_header(struct opd_header * header, unsigned long counter,
+                 vma_t anon_start, vma_t cg_to_anon_start,
+                 int is_kernel, int cg_to_is_kernel,
+                 int spu_samples, uint64_t embed_offset, time_t mtime)
+{
+	struct opd_event * event = find_counter_event(counter);
+
+	memset(header, '\0', sizeof(struct opd_header));
+	header->version = OPD_VERSION;
+	memcpy(header->magic, OPD_MAGIC, sizeof(header->magic));
+	header->cpu_type = cpu_type;
+	header->ctr_event = event->value;
+	header->ctr_count = event->count;
+	header->ctr_um = event->um;
+	header->is_kernel = is_kernel;
+	header->cg_to_is_kernel = cg_to_is_kernel;
+	header->cpu_speed = cpu_speed;
+	header->mtime = mtime;
+	header->anon_start = anon_start;
+	header->spu_profile = spu_samples;
+	header->embedded_offset = embed_offset;
+	header->cg_to_anon_start = cg_to_anon_start;
+}
diff --git a/daemon/opd_events.h b/daemon/opd_events.h
new file mode 100644
index 0000000..3bd0106
--- /dev/null
+++ b/daemon/opd_events.h
@@ -0,0 +1,47 @@
+/**
+ * @file daemon/opd_events.h
+ * Event details for each counter
+ *
+ * @remark Copyright 2002, 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OPD_EVENTS_H
+
+#include "op_types.h"
+
+#include <stdint.h>
+#include <time.h>
+
+/** event description for setup (perfmon) and mangling */
+struct opd_event {
+	char * name;
+	unsigned long value;
+	unsigned long counter;
+	unsigned long count;
+	unsigned long um;
+	unsigned long kernel;
+	unsigned long user;
+};
+
+/* needed for opd_perfmon.c */
+extern struct opd_event opd_events[];
+
+/** parse the events into the opd_events array */
+void opd_parse_events(char const * events);
+
+/** Find the event for the given counter */
+struct opd_event * find_counter_event(unsigned long counter);
+
+struct opd_header;
+
+/** fill the sample file header with event info etc. */
+void fill_header(struct opd_header * header, unsigned long counter,
+                 vma_t anon_start, vma_t anon_end,
+                 int is_kernel, int cg_to_is_kernel,
+                 int spu_samples, uint64_t embed_offset, time_t mtime);
+
+#endif /* OPD_EVENTS_H */
diff --git a/daemon/opd_interface.h b/daemon/opd_interface.h
new file mode 100644
index 0000000..c876830
--- /dev/null
+++ b/daemon/opd_interface.h
@@ -0,0 +1,45 @@
+/**
+ * @file opd_interface.h
+ *
+ * Module / user space interface for 2.6 kernels and above
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ */
+
+#ifndef OPD_INTERFACE_H
+#define OPD_INTERFACE_H
+
+#define CTX_SWITCH_CODE			1
+#define CPU_SWITCH_CODE			2
+#define COOKIE_SWITCH_CODE		3
+#define KERNEL_ENTER_SWITCH_CODE	4
+#define USER_ENTER_SWITCH_CODE		5
+#define MODULE_LOADED_CODE		6
+#define CTX_TGID_CODE			7
+#define TRACE_BEGIN_CODE		8
+/* Code 9 used to be TRACE_END_CODE which is not used anymore  */
+/* Code 9 is now considered an unknown escape code             */
+#define XEN_ENTER_SWITCH_CODE		10
+/*
+ * Ugly work-around for the unfortunate collision between Xenoprof's
+ * DOMAIN_SWITCH_CODE (in use on x86) and Cell's SPU_PROFILING_CODE
+ * (in use with Power):
+ */
+#if defined(__powerpc__)
+#define SPU_PROFILING_CODE		11
+#define SPU_CTX_SWITCH_CODE		12
+#define DOMAIN_SWITCH_CODE		13
+#define LAST_CODE			14
+#else
+#define DOMAIN_SWITCH_CODE		11
+#define LAST_CODE			12
+#endif
+ 
+#endif /* OPD_INTERFACE_H */
diff --git a/daemon/opd_kernel.c b/daemon/opd_kernel.c
new file mode 100644
index 0000000..5ebc210
--- /dev/null
+++ b/daemon/opd_kernel.c
@@ -0,0 +1,229 @@
+/**
+ * @file daemon/opd_kernel.c
+ * Dealing with the kernel and kernel module samples
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ */
+
+#include "opd_kernel.h"
+#include "opd_sfile.h"
+#include "opd_trans.h"
+#include "opd_printf.h"
+#include "opd_stats.h"
+#include "oprofiled.h"
+
+#include "op_fileio.h"
+#include "op_config.h"
+#include "op_libiberty.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <assert.h>
+
+static LIST_HEAD(modules);
+
+static struct kernel_image vmlinux_image;
+
+static struct kernel_image xen_image;
+
+void opd_create_vmlinux(char const * name, char const * arg)
+{
+	/* vmlinux is *not* on the list of modules */
+	list_init(&vmlinux_image.list);
+
+	/* for no vmlinux */
+	if (no_vmlinux) {
+		vmlinux_image.name = "no-vmlinux";
+		return;
+	}
+	
+	vmlinux_image.name = xstrdup(name);
+
+	sscanf(arg, "%llx,%llx", &vmlinux_image.start, &vmlinux_image.end);
+
+	verbprintf(vmisc, "kernel_start = %llx, kernel_end = %llx\n",
+	           vmlinux_image.start, vmlinux_image.end);
+
+	if (!vmlinux_image.start && !vmlinux_image.end) {
+		fprintf(stderr, "error: mis-parsed kernel range: %llx-%llx\n",
+		        vmlinux_image.start, vmlinux_image.end);
+		exit(EXIT_FAILURE);
+	}
+}
+
+void opd_create_xen(char const * name, char const * arg)
+{
+	/* xen is *not* on the list of modules */
+	list_init(&xen_image.list);
+
+	/* for no xen */
+	if (no_xen) {
+		xen_image.name = "no-xen";
+		return;
+	}
+
+	xen_image.name = xstrdup(name);
+
+	sscanf(arg, "%llx,%llx", &xen_image.start, &xen_image.end);
+
+	verbprintf(vmisc, "xen_start = %llx, xen_end = %llx\n",
+	           xen_image.start, xen_image.end);
+
+	if (!xen_image.start && !xen_image.end) {
+		fprintf(stderr, "error: mis-parsed xen range: %llx-%llx\n",
+		        xen_image.start, xen_image.end);
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+/**
+ * Allocate and initialise a kernel image description
+ * @param name image name
+ * @param start start address
+ * @param end end address
+ */
+static struct kernel_image *
+opd_create_module(char const * name, vma_t start, vma_t end)
+{
+	struct kernel_image * image = xmalloc(sizeof(struct kernel_image));
+
+	image->name = xstrdup(name);
+	image->start = start;
+	image->end = end;
+	list_add(&image->list, &modules);
+
+	return image;
+}
+
+
+/**
+ * Clear and free all kernel image information and reset
+ * values.
+ */
+static void opd_clear_modules(void)
+{
+	struct list_head * pos;
+	struct list_head * pos2;
+	struct kernel_image * image;
+
+	list_for_each_safe(pos, pos2, &modules) {
+		image = list_entry(pos, struct kernel_image, list);
+		if (image->name)
+			free(image->name);
+		free(image);
+	}
+
+	list_init(&modules);
+
+	/* clear out lingering references */
+	sfile_clear_kernel();
+}
+
+
+/*
+ * each line is in the format:
+ *
+ * module_name 16480 1 dependencies Live 0xe091e000
+ *
+ * without any blank space in each field
+ */
+void opd_reread_module_info(void)
+{
+	FILE * fp;
+	char * line;
+	struct kernel_image * image;
+	int module_size;
+	char ref_count[32+1];
+	int ret;
+	char module_name[256+1];
+	char live_info[32+1];
+	char dependencies[4096+1];
+	unsigned long long start_address;
+
+	if (no_vmlinux)
+		return;
+
+	opd_clear_modules();
+
+	printf("Reading module info.\n");
+
+	fp = op_try_open_file("/proc/modules", "r");
+
+	if (!fp) {
+		printf("oprofiled: /proc/modules not readable, "
+			"can't process module samples.\n");
+		return;
+	}
+
+	while (1) {
+		line = op_get_line(fp);
+
+		if (!line)
+			break;
+
+		if (line[0] == '\0') {
+			free(line);
+			continue;
+		}
+
+		ret = sscanf(line, "%256s %u %32s %4096s %32s %llx",
+			     module_name, &module_size, ref_count,
+			     dependencies, live_info, &start_address);
+		if (ret != 6) {
+			printf("bad /proc/modules entry: %s\n", line);
+			free(line);
+			continue;
+		}
+
+		image = opd_create_module(module_name, start_address,
+		                          start_address + module_size);
+
+		verbprintf(vmodule, "module %s start %llx end %llx\n",
+			   image->name, image->start, image->end);
+
+		free(line);
+	}
+
+	op_close_file(fp);
+}
+
+
+/**
+ * find a kernel image by PC value
+ * @param trans holds PC value to look up
+ *
+ * find the kernel image which contains this PC.
+ *
+ * Return %NULL if not found.
+ */
+struct kernel_image * find_kernel_image(struct transient const * trans)
+{
+	struct list_head * pos;
+	struct kernel_image * image = &vmlinux_image;
+
+	if (no_vmlinux)
+		return image;
+
+	if (image->start <= trans->pc && image->end > trans->pc)
+		return image;
+
+	list_for_each(pos, &modules) {
+		image = list_entry(pos, struct kernel_image, list);
+		if (image->start <= trans->pc && image->end > trans->pc)
+			return image;
+	}
+
+	if (xen_image.start <= trans->pc && xen_image.end > trans->pc)
+		return &xen_image;
+
+	return NULL;
+}
diff --git a/daemon/opd_kernel.h b/daemon/opd_kernel.h
new file mode 100644
index 0000000..cb71a30
--- /dev/null
+++ b/daemon/opd_kernel.h
@@ -0,0 +1,43 @@
+/**
+ * @file daemon/opd_kernel.h
+ * Dealing with the kernel and kernel module images
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ */
+
+#ifndef OPD_KERNEL_H
+#define OPD_KERNEL_H
+
+#include "op_types.h"
+#include "op_list.h"
+
+struct transient;
+
+/** create the kernel image */
+void opd_create_vmlinux(char const * name, char const * arg);
+
+void opd_create_xen(char const * name, char const * arg);
+
+/** opd_reread_module_info - parse /proc/modules for kernel modules */
+void opd_reread_module_info(void);
+
+/** Describes a kernel module or vmlinux itself */
+struct kernel_image {
+	char * name;
+	vma_t start;
+	vma_t end;
+	struct list_head list;
+};
+
+/** Find a kernel_image based upon the given parameters in trans. */
+struct kernel_image *
+find_kernel_image(struct transient const * trans);
+
+#endif /* OPD_KERNEL_H */
diff --git a/daemon/opd_mangling.c b/daemon/opd_mangling.c
new file mode 100644
index 0000000..08a6079
--- /dev/null
+++ b/daemon/opd_mangling.c
@@ -0,0 +1,205 @@
+/**
+ * @file daemon/opd_mangling.c
+ * Mangling and opening of sample files
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <sys/types.h>
+ 
+#include "opd_mangling.h"
+#include "opd_kernel.h"
+#include "opd_cookie.h"
+#include "opd_sfile.h"
+#include "opd_anon.h"
+#include "opd_printf.h"
+#include "opd_events.h"
+#include "oprofiled.h"
+
+#include "op_file.h"
+#include "op_sample_file.h"
+#include "op_config.h"
+#include "op_mangle.h"
+#include "op_events.h"
+#include "op_libiberty.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+
+static char const * get_dep_name(struct sfile const * sf)
+{
+	if (sf->anon)
+		return find_cookie(sf->app_cookie);
+
+	/* avoid to call find_cookie(), caller can recover using image_name */
+	if (sf->cookie == sf->app_cookie)
+		return NULL;
+
+	if (!separate_kernel && !(separate_lib && !sf->kernel))
+		return NULL;
+
+	/* this will fail if e.g. kernel thread */
+	if (sf->app_cookie == 0)
+		return NULL;
+
+	return find_cookie(sf->app_cookie);
+}
+
+
+static char * mangle_anon(struct anon_mapping const * anon)
+{
+	char * name = xmalloc(PATH_MAX);
+
+	snprintf(name, 1024, "%u.0x%llx.0x%llx", (unsigned int)anon->tgid,
+	       anon->start, anon->end);
+
+	return name;
+}
+
+
+static char *
+mangle_filename(struct sfile * last, struct sfile const * sf, int counter, int cg)
+{
+	char * mangled;
+	struct mangle_values values;
+	struct opd_event * event = find_counter_event(counter);
+
+	values.flags = 0;
+
+	if (sf->kernel) {
+		values.image_name = sf->kernel->name;
+		values.flags |= MANGLE_KERNEL;
+	} else if (sf->anon) {
+		values.flags |= MANGLE_ANON;
+		values.image_name = mangle_anon(sf->anon);
+		values.anon_name = sf->anon->name;
+	} else {
+		values.image_name = find_cookie(sf->cookie);
+	}
+
+	values.dep_name = get_dep_name(sf);
+	if (!values.dep_name)
+		values.dep_name = values.image_name;
+ 
+	/* FIXME: log */
+	if (!values.image_name || !values.dep_name)
+		return NULL;
+
+	if (separate_thread) {
+		values.flags |= MANGLE_TGID | MANGLE_TID;
+		values.tid = sf->tid;
+		values.tgid = sf->tgid;
+	}
+ 
+	if (separate_cpu) {
+		values.flags |= MANGLE_CPU;
+		values.cpu = sf->cpu;
+	}
+
+	if (cg) {
+		values.flags |= MANGLE_CALLGRAPH;
+		if (last->kernel) {
+			values.cg_image_name = last->kernel->name;
+		} else if (last->anon) {
+			values.flags |= MANGLE_CG_ANON;
+			values.cg_image_name = mangle_anon(last->anon);
+			values.anon_name = last->anon->name;
+		} else {
+			values.cg_image_name = find_cookie(last->cookie);
+		}
+
+		/* FIXME: log */
+		if (!values.cg_image_name) {
+			if (values.flags & MANGLE_ANON)
+				free((char *)values.image_name);
+			return NULL;
+		}
+	}
+
+	values.event_name = event->name;
+	values.count = event->count;
+	values.unit_mask = event->um;
+
+	mangled = op_mangle_filename(&values);
+
+	if (values.flags & MANGLE_ANON)
+		free((char *)values.image_name);
+	if (values.flags & MANGLE_CG_ANON)
+		free((char *)values.cg_image_name);
+	return mangled;
+}
+
+
+int opd_open_sample_file(odb_t * file, struct sfile * last,
+                         struct sfile * sf, int counter, int cg)
+{
+	char * mangled;
+	char const * binary;
+	int spu_profile = 0;
+	vma_t last_start = 0;
+	int err;
+
+	mangled = mangle_filename(last, sf, counter, cg);
+
+	if (!mangled)
+		return EINVAL;
+
+	verbprintf(vsfile, "Opening \"%s\"\n", mangled);
+
+	create_path(mangled);
+
+	/* locking sf will lock associated cg files too */
+	sfile_get(sf);
+	if (sf != last)
+		sfile_get(last);
+
+retry:
+	err = odb_open(file, mangled, ODB_RDWR, sizeof(struct opd_header));
+
+	/* This can naturally happen when racing against opcontrol --reset. */
+	if (err) {
+		if (err == EMFILE) {
+			if (sfile_lru_clear()) {
+				printf("LRU cleared but odb_open() fails for %s.\n", mangled);
+				abort();
+			}
+			goto retry;
+		}
+
+		fprintf(stderr, "oprofiled: open of %s failed: %s\n",
+		        mangled, strerror(err));
+		goto out;
+	}
+
+	if (!sf->kernel)
+		binary = find_cookie(sf->cookie);
+	else
+		binary = sf->kernel->name;
+
+	if (last && last->anon)
+		last_start = last->anon->start;
+
+	if (sf->embedded_offset != UNUSED_EMBEDDED_OFFSET)
+		spu_profile = 1;
+
+	fill_header(odb_get_data(file), counter,
+		    sf->anon ? sf->anon->start : 0, last_start,
+		    !!sf->kernel, last ? !!last->kernel : 0,
+		    spu_profile, sf->embedded_offset,
+		    binary ? op_get_mtime(binary) : 0);
+
+out:
+	sfile_put(sf);
+	if (sf != last)
+		sfile_put(last);
+	free(mangled);
+	return err;
+}
diff --git a/daemon/opd_mangling.h b/daemon/opd_mangling.h
new file mode 100644
index 0000000..0e46ec4
--- /dev/null
+++ b/daemon/opd_mangling.h
@@ -0,0 +1,33 @@
+/**
+ * @file daemon/opd_mangling.h
+ * Mangling and opening of sample files
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OPD_MANGLING_H
+#define OPD_MANGLING_H
+
+#include "odb.h"
+
+struct sfile;
+
+/*
+ * opd_open_sample_file - open a sample file
+ * @param sf  sfile to open sample file for
+ * @param counter  counter number
+ * @param cg if this is a callgraph file
+ *
+ * Open image sample file for the sfile, counter
+ * counter and set up memory mappings for it.
+ *
+ * Returns 0 on success.
+ */
+int opd_open_sample_file(odb_t * file, struct sfile * last,
+                         struct sfile * sf, int counter, int cg);
+
+#endif /* OPD_MANGLING_H */
diff --git a/daemon/opd_perfmon.c b/daemon/opd_perfmon.c
new file mode 100644
index 0000000..a1b158a
--- /dev/null
+++ b/daemon/opd_perfmon.c
@@ -0,0 +1,496 @@
+/**
+ * @file opd_perfmon.c
+ * perfmonctl() handling
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ */
+
+#ifdef __ia64__
+
+/* need this for sched_setaffinity() in <sched.h> */
+#define _GNU_SOURCE
+
+#include "oprofiled.h"
+#include "opd_perfmon.h"
+#include "opd_events.h"
+
+#include "op_cpu_type.h"
+#include "op_libiberty.h"
+#include "op_hw_config.h"
+
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#ifdef HAVE_SCHED_SETAFFINITY
+#include <sched.h>
+#endif
+
+extern op_cpu cpu_type;
+
+#ifndef HAVE_SCHED_SETAFFINITY
+
+/* many glibc's are not yet up to date */
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 1231
+#endif
+
+/* Copied from glibc's <sched.h> and <bits/sched.h> and munged */
+#define CPU_SETSIZE	1024
+#define __NCPUBITS	(8 * sizeof (unsigned long))
+typedef struct
+{
+	unsigned long __bits[CPU_SETSIZE / __NCPUBITS];
+} cpu_set_t;
+
+#define CPU_SET(cpu, cpusetp) \
+	((cpusetp)->__bits[(cpu)/__NCPUBITS] |= (1UL << ((cpu) % __NCPUBITS)))
+#define CPU_ZERO(cpusetp) \
+	memset((cpusetp), 0, sizeof(cpu_set_t))
+
+static int
+sched_setaffinity(pid_t pid, size_t len, cpu_set_t const * cpusetp)
+{
+	return syscall(__NR_sched_setaffinity, pid, len, cpusetp);
+}
+#endif
+
+
+#ifndef HAVE_PERFMONCTL
+#ifndef __NR_perfmonctl
+#define __NR_perfmonctl 1175
+#endif
+
+static int perfmonctl(int fd, int cmd, void * arg, int narg)
+{
+	return syscall(__NR_perfmonctl, fd, cmd, arg, narg);
+}
+#endif
+
+
+static unsigned char uuid[16] = {
+	0x77, 0x7a, 0x6e, 0x61, 0x20, 0x65, 0x73, 0x69,
+	0x74, 0x6e, 0x72, 0x20, 0x61, 0x65, 0x0a, 0x6c
+};
+
+
+static size_t nr_cpus;
+
+struct child {
+	pid_t pid;
+	int up_pipe[2];
+	int ctx_fd;
+	sig_atomic_t sigusr1;
+	sig_atomic_t sigusr2;
+	sig_atomic_t sigterm;
+};
+
+static struct child * children;
+
+static void perfmon_start_child(int ctx_fd)
+{
+	if (perfmonctl(ctx_fd, PFM_START, 0, 0) == -1) {
+		perror("Couldn't start perfmon: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+static void perfmon_stop_child(int ctx_fd)
+{
+	if (perfmonctl(ctx_fd, PFM_STOP, 0, 0) == -1) {
+		perror("Couldn't stop perfmon: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+static void child_sigusr1(int val __attribute__((unused)))
+{
+	size_t i;
+
+	for (i = 0; i < nr_cpus; ++i) {
+		if (children[i].pid == getpid()) {
+			children[i].sigusr1 = 1;
+			return;
+		}
+	}
+}
+
+
+static void child_sigusr2(int val __attribute__((unused)))
+{
+	size_t i;
+
+	for (i = 0; i < nr_cpus; ++i) {
+		if (children[i].pid == getpid()) {
+			children[i].sigusr2 = 1;
+			return;
+		}
+	}
+}
+
+
+static void child_sigterm(int val __attribute__((unused)))
+{
+	printf("Child received SIGTERM, killing parent.\n");
+	kill(getppid(), SIGTERM);
+}
+
+
+static void set_affinity(size_t cpu)
+{
+	cpu_set_t set;
+
+	CPU_ZERO(&set);
+	CPU_SET(cpu, &set);
+
+	int err = sched_setaffinity(getpid(), sizeof(set), &set);
+
+	if (err == -1) {
+		fprintf(stderr, "Failed to set affinity: %s\n",
+			    strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+static void setup_signals(void)
+{
+	struct sigaction act;
+	sigset_t mask;
+
+	sigemptyset(&mask);
+	sigaddset(&mask, SIGUSR1);
+	sigaddset(&mask, SIGUSR2);
+	sigprocmask(SIG_BLOCK, &mask, NULL);
+
+	act.sa_handler = child_sigusr1;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+
+	if (sigaction(SIGUSR1, &act, NULL)) {
+		perror("oprofiled: install of SIGUSR1 handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = child_sigusr2;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+
+	if (sigaction(SIGUSR2, &act, NULL)) {
+		perror("oprofiled: install of SIGUSR2 handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = child_sigterm;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+
+	if (sigaction(SIGTERM, &act, NULL)) {
+		perror("oprofiled: install of SIGTERM handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+/** create the per-cpu context */
+static void create_context(struct child * self)
+{
+	pfarg_context_t ctx;
+	int err;
+
+	memset(&ctx, 0, sizeof(pfarg_context_t));
+	memcpy(&ctx.ctx_smpl_buf_id, &uuid, 16);
+	ctx.ctx_flags = PFM_FL_SYSTEM_WIDE;
+
+	err = perfmonctl(0, PFM_CREATE_CONTEXT, &ctx, 1);
+	if (err == -1) {
+		fprintf(stderr, "CREATE_CONTEXT failed: %s\n",
+		        strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	self->ctx_fd = ctx.ctx_fd;
+}
+
+
+/** program the perfmon counters */
+static void write_pmu(struct child * self)
+{
+	pfarg_reg_t pc[OP_MAX_COUNTERS];
+	pfarg_reg_t pd[OP_MAX_COUNTERS];
+	int err;
+	size_t i;
+
+	memset(pc, 0, sizeof(pc));
+	memset(pd, 0, sizeof(pd));
+
+#define PMC_GEN_INTERRUPT (1UL << 5)
+#define PMC_PRIV_MONITOR (1UL << 6)
+/* McKinley requires pmc4 to have bit 23 set (enable PMU).
+ * It is supposedly ignored in other pmc registers.
+ */
+#define PMC_MANDATORY (1UL << 23)
+#define PMC_USER (1UL << 3)
+#define PMC_KERNEL (1UL << 0)
+	for (i = 0; i < op_nr_counters && opd_events[i].name; ++i) {
+		struct opd_event * event = &opd_events[i];
+		pc[i].reg_num = event->counter + 4;
+		pc[i].reg_value = PMC_GEN_INTERRUPT;
+		pc[i].reg_value |= PMC_PRIV_MONITOR;
+		pc[i].reg_value |= PMC_MANDATORY;
+		(event->user) ? (pc[i].reg_value |= PMC_USER)
+		              : (pc[i].reg_value &= ~PMC_USER);
+		(event->kernel) ? (pc[i].reg_value |= PMC_KERNEL)
+		                : (pc[i].reg_value &= ~PMC_KERNEL);
+		pc[i].reg_value &= ~(0xff << 8);
+		pc[i].reg_value |= ((event->value & 0xff) << 8);
+		pc[i].reg_value &= ~(0xf << 16);
+		pc[i].reg_value |= ((event->um & 0xf) << 16);
+		pc[i].reg_smpl_eventid = event->counter;
+	}
+
+	for (i = 0; i < op_nr_counters && opd_events[i].name; ++i) {
+		struct opd_event * event = &opd_events[i];
+		pd[i].reg_value = ~0UL - event->count + 1;
+		pd[i].reg_short_reset = ~0UL - event->count + 1;
+		pd[i].reg_num = event->counter + 4;
+	}
+
+	err = perfmonctl(self->ctx_fd, PFM_WRITE_PMCS, pc, i);
+	if (err == -1) {
+		perror("Couldn't write PMCs: ");
+		exit(EXIT_FAILURE);
+	}
+
+	err = perfmonctl(self->ctx_fd, PFM_WRITE_PMDS, pd, i);
+	if (err == -1) {
+		perror("Couldn't write PMDs: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+static void load_context(struct child * self)
+{
+	pfarg_load_t load_args;
+	int err;
+
+	memset(&load_args, 0, sizeof(load_args));
+	load_args.load_pid = self->pid;
+
+	err = perfmonctl(self->ctx_fd, PFM_LOAD_CONTEXT, &load_args, 1);
+	if (err == -1) {
+		perror("Couldn't load context: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+static void notify_parent(struct child * self, size_t cpu)
+{
+	for (;;) {
+		ssize_t ret;
+		ret = write(self->up_pipe[1], &cpu, sizeof(size_t));
+		if (ret == sizeof(size_t))
+			break;
+		if (ret < 0 && errno != EINTR) {
+			fprintf(stderr, "Failed to write child pipe with %s\n",
+			        strerror(errno));
+			exit(EXIT_FAILURE);
+		}
+	}
+}
+
+
+static void run_child(size_t cpu)
+{
+	struct child * self = &children[cpu];
+
+	self->pid = getpid();
+	self->sigusr1 = 0;
+	self->sigusr2 = 0;
+	self->sigterm = 0;
+
+	setup_signals();
+
+	set_affinity(cpu);
+
+	create_context(self);
+
+	write_pmu(self);
+
+	load_context(self);
+
+	notify_parent(self, cpu);
+
+	for (;;) {
+		sigset_t sigmask;
+		sigfillset(&sigmask);
+		sigdelset(&sigmask, SIGUSR1);
+		sigdelset(&sigmask, SIGUSR2);
+		sigdelset(&sigmask, SIGTERM);
+
+		if (self->sigusr1) {
+			printf("PFM_START on CPU%d\n", (int)cpu);
+			fflush(stdout);
+			perfmon_start_child(self->ctx_fd);
+			self->sigusr1 = 0;
+		}
+
+		if (self->sigusr2) {
+			printf("PFM_STOP on CPU%d\n", (int)cpu);
+			fflush(stdout);
+			perfmon_stop_child(self->ctx_fd);
+			self->sigusr2 = 0;
+		}
+
+		sigsuspend(&sigmask);
+	}
+}
+
+
+static void wait_for_child(struct child * child)
+{
+	size_t tmp;
+	for (;;) {
+		ssize_t ret;
+		ret = read(child->up_pipe[0], &tmp, sizeof(size_t));
+		if (ret == sizeof(size_t))
+			break;
+		if (ret < 0 && errno != EINTR) {
+			fprintf(stderr, "Failed to read child pipe with %s\n",
+			        strerror(errno));
+			exit(EXIT_FAILURE);
+		}
+	}
+	printf("Perfmon child up on CPU%d\n", (int)tmp);
+	fflush(stdout);
+
+	close(child->up_pipe[0]);
+	close(child->up_pipe[1]);
+}
+
+static struct child* xen_ctx;
+
+void perfmon_init(void)
+{
+	size_t i;
+	long nr;
+
+	if (cpu_type == CPU_TIMER_INT)
+		return;
+
+	if (!no_xen) {
+		xen_ctx = xmalloc(sizeof(struct child));
+		xen_ctx->pid = getpid();
+		xen_ctx->up_pipe[0] = -1;
+		xen_ctx->up_pipe[1] = -1;
+		xen_ctx->sigusr1 = 0;
+		xen_ctx->sigusr2 = 0;
+		xen_ctx->sigterm = 0;
+
+		create_context(xen_ctx);
+
+		write_pmu(xen_ctx);
+		
+		load_context(xen_ctx);
+		return;
+	}
+	
+
+	nr = sysconf(_SC_NPROCESSORS_ONLN);
+	if (nr == -1) {
+		fprintf(stderr, "Couldn't determine number of CPUs.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	nr_cpus = nr;
+
+	children = xmalloc(sizeof(struct child) * nr_cpus);
+
+	for (i = 0; i < nr_cpus; ++i) {
+		int ret;
+
+		if (pipe(children[i].up_pipe)) {
+			perror("Couldn't create child pipe.\n");
+			exit(EXIT_FAILURE);
+		}
+
+		ret = fork();
+		if (ret == -1) {
+			fprintf(stderr, "Couldn't fork perfmon child.\n");
+			exit(EXIT_FAILURE);
+		} else if (ret == 0) {
+			printf("Running perfmon child on CPU%d.\n", (int)i);
+			fflush(stdout);
+			run_child(i);
+		} else {
+			children[i].pid = ret;
+			printf("Waiting on CPU%d\n", (int)i);
+			wait_for_child(&children[i]);
+		}
+	}
+}
+
+
+void perfmon_exit(void)
+{
+	size_t i;
+
+	if (cpu_type == CPU_TIMER_INT)
+		return;
+
+	if (!no_xen)
+		return;
+
+	for (i = 0; i < nr_cpus; ++i) {
+		kill(children[i].pid, SIGKILL);
+		waitpid(children[i].pid, NULL, 0);
+	}
+}
+
+
+void perfmon_start(void)
+{
+	size_t i;
+
+	if (cpu_type == CPU_TIMER_INT)
+		return;
+
+	if (!no_xen) {
+		perfmon_start_child(xen_ctx->ctx_fd);
+		return;
+	}
+
+	for (i = 0; i < nr_cpus; ++i)
+		kill(children[i].pid, SIGUSR1);
+}
+
+
+void perfmon_stop(void)
+{
+	size_t i;
+
+	if (cpu_type == CPU_TIMER_INT)
+		return;
+
+	if (!no_xen) {
+		perfmon_stop_child(xen_ctx->ctx_fd);
+		return;
+	}
+	
+	for (i = 0; i < nr_cpus; ++i)
+		kill(children[i].pid, SIGUSR2);
+}
+
+#endif /* __ia64__ */
diff --git a/daemon/opd_perfmon.h b/daemon/opd_perfmon.h
new file mode 100644
index 0000000..9b4267f
--- /dev/null
+++ b/daemon/opd_perfmon.h
@@ -0,0 +1,106 @@
+/**
+ * @file opd_perfmon.h
+ * perfmonctl() handling
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ */
+
+#ifndef OPD_PERFMON_H
+#define OPD_PERFMON_H
+
+#ifdef __ia64__
+
+#include <stdlib.h>
+
+void perfmon_init(void);
+void perfmon_exit(void);
+void perfmon_start(void);
+void perfmon_stop(void);
+
+/* The following is from asm/perfmon.h. When it's installed on
+ * enough boxes, we can remove this and include the platform
+ * perfmon.h
+ */
+
+typedef unsigned char pfm_uuid_t[16];	/* custom sampling buffer identifier type */
+
+/*
+ * Request structure used to define a context
+ */
+typedef struct {
+	pfm_uuid_t     ctx_smpl_buf_id;	 /* which buffer format to use (if needed) */
+	unsigned long  ctx_flags;	 /* noblock/block */
+	unsigned short ctx_nextra_sets;	 /* number of extra event sets (you always get 1) */
+	unsigned short ctx_reserved1;	 /* for future use */
+	int	       ctx_fd;		 /* return arg: unique identification for context */
+	void	       *ctx_smpl_vaddr;	 /* return arg: virtual address of sampling buffer, is used */
+	unsigned long  ctx_reserved2[11];/* for future use */
+} pfarg_context_t;
+
+/*
+ * Request structure used to write/read a PMC or PMD
+ */
+typedef struct {
+	unsigned int	reg_num;	   /* which register */
+	unsigned short	reg_set;	   /* event set for this register */
+	unsigned short	reg_reserved1;	   /* for future use */
+
+	unsigned long	reg_value;	   /* initial pmc/pmd value */
+	unsigned long	reg_flags;	   /* input: pmc/pmd flags, return: reg error */
+
+	unsigned long	reg_long_reset;	   /* reset after buffer overflow notification */
+	unsigned long	reg_short_reset;   /* reset after counter overflow */
+
+	unsigned long	reg_reset_pmds[4]; /* which other counters to reset on overflow */
+	unsigned long	reg_random_seed;   /* seed value when randomization is used */
+	unsigned long	reg_random_mask;   /* bitmask used to limit random value */
+	unsigned long   reg_last_reset_val;/* return: PMD last reset value */
+
+	unsigned long	reg_smpl_pmds[4];  /* which pmds are accessed when PMC overflows */
+	unsigned long	reg_smpl_eventid;  /* opaque sampling event identifier */
+
+	unsigned long   reg_reserved2[3];   /* for future use */
+} pfarg_reg_t;
+
+typedef struct {
+	pid_t		load_pid;	   /* process to load the context into */
+	unsigned short	load_set;	   /* first event set to load */
+	unsigned short	load_reserved1;	   /* for future use */
+	unsigned long	load_reserved2[3]; /* for future use */
+} pfarg_load_t;
+
+#define PFM_WRITE_PMCS      0x01
+#define PFM_WRITE_PMDS      0x02
+#define PFM_STOP            0x04
+#define PFM_START           0x05
+#define PFM_CREATE_CONTEXT  0x08
+#define PFM_LOAD_CONTEXT    0x10
+#define PFM_FL_SYSTEM_WIDE  0x02
+
+#else
+
+void perfmon_init(void)
+{
+}
+
+
+void perfmon_exit(void)
+{
+}
+
+
+void perfmon_start(void)
+{
+}
+
+
+void perfmon_stop(void)
+{
+}
+
+#endif /* __ia64__ */
+
+#endif /* OPD_PERFMON_H */
diff --git a/daemon/opd_pipe.c b/daemon/opd_pipe.c
new file mode 100644
index 0000000..a5c334a
--- /dev/null
+++ b/daemon/opd_pipe.c
@@ -0,0 +1,96 @@
+/**
+ * @file daemon/opd_pipe.c
+ * Functions handling the $SESSIONDIR/opd_pipe FIFO special file.
+ * NOTE: This code is dealing with potentially insecure input.
+ *
+ * @remark Copyright 2008 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Daniel Hansel
+ */
+
+#include "opd_pipe.h"
+#include "opd_printf.h"
+#include "op_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+static int fifo;
+
+void opd_create_pipe(void)
+{
+	mode_t orig_umask = umask(0111);
+	if (mkfifo(op_pipe_file, 0666) == -1) {
+		if (errno != EEXIST) {
+			perror("oprofiled: couldn't create pipe: ");
+			exit(EXIT_FAILURE);
+		}
+	}
+	umask(orig_umask);
+}
+
+
+void opd_open_pipe(void)
+{
+	fifo = open(op_pipe_file, O_RDONLY | O_NONBLOCK);
+	if (fifo == -1) {
+		perror("oprofiled: couldn't open pipe: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+void opd_close_pipe(void)
+{
+	close(fifo);
+}
+
+
+int is_jitconv_requested(void)
+{
+	/* number of dropped (unknown) requests */
+	static long nr_drops = 0;
+	/* modulus to output only a few warnings to avoid flooding oprofiled.log */
+	static int mod_cnt_drops = 1;
+	FILE * fd;
+	char line[256];
+	int i, ret = 0;
+
+	/* get a file descriptor to the pipe */
+	fd = fdopen(fifo, "r");
+
+	if (fd == NULL) {
+		perror("oprofiled: couldn't create file descriptor: ");
+		exit(EXIT_FAILURE);
+	}
+
+	/* read up to 99 lines to check for 'do_jitconv' */
+	for (i = 0; i < 99; i++) {
+		/* just break if no new line is found */
+		if (fgets(line, 256, fd) == NULL)
+			break;
+		line[strlen(line) - 1] = '\0';
+
+		if (strstr(line, "do_jitconv") != NULL) {
+			ret = 1;
+		} else {
+			nr_drops++;
+
+			if (nr_drops % mod_cnt_drops == 0) {
+				printf(
+				       "Warning: invalid pipe request received (dropped request(s): %ld)\n",
+				       nr_drops);
+				/* increase modulus to avoid flooding log file */
+				mod_cnt_drops *= 5;
+			}
+		}
+	}
+
+	return ret;
+}
diff --git a/daemon/opd_pipe.h b/daemon/opd_pipe.h
new file mode 100644
index 0000000..7f96b07
--- /dev/null
+++ b/daemon/opd_pipe.h
@@ -0,0 +1,45 @@
+/**
+ * @file daemon/opd_pipe.h
+ * Functions handling the $SESSIONDIR/opd_pipe FIFO special file.
+ * NOTE: This code is dealing with potencially insecure input.
+ *
+ * @remark Copyright 2008 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Daniel Hansel
+ */
+
+#ifndef OPD_PIPE_H_
+#define OPD_PIPE_H_
+ 
+/**
+ * opd_create_pipe - creates the oprofiled fifo file
+ *
+ * Creates the Oprofile daemon fifo pipe to enable communication between
+ * the daemon and the 'opcontrol --dump' command. Failure to create the pipe
+ * is a fatal error.
+ */
+void opd_create_pipe(void);
+
+/**
+ * opd_open_pipe - opens the oprofiled fifo file
+ */
+void opd_open_pipe(void);
+
+/**
+ * opd_close_pipe - closes the oprofiled fifo file
+ *
+ * Closes the Oprofile daemon fifo pipe.
+ */
+void opd_close_pipe(void);
+
+/**
+ * is_jitconv_requested - check for request to jit conversion
+ *
+ * Checks the Oprofile daemon fifo pipe for do_jitconv request.
+ * If jit conversion is requested ('do_jitconv' is sent) the check returns 1.
+ * Otherwise it returns 0.
+ */
+int is_jitconv_requested(void);
+
+#endif /*OPD_PIPE_H_*/
diff --git a/daemon/opd_printf.h b/daemon/opd_printf.h
new file mode 100644
index 0000000..e1f8476
--- /dev/null
+++ b/daemon/opd_printf.h
@@ -0,0 +1,35 @@
+/**
+ * @file daemon/opd_printf.h
+ * Output routines
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OPD_PRINTF_H
+#define OPD_PRINTF_H
+
+/// log all sample file name manipulation; sample files open, close,
+/// sfile LRU etc. voluminous. FIXME need to be splitted (filename manip, files
+/// handling) ?
+extern int vsfile;
+/// log samples, voluminous.
+extern int vsamples;
+/// log arc, very voluminous.
+extern int varcs;
+/// kernel module handling
+extern int vmodule;
+/// all others not fitting in above category, not voluminous.
+extern int vmisc;
+
+#define verbprintf(x, args...) \
+	do { \
+		/* look like fragile but we must catch verbrintf("%s", "") */ \
+		if (x == 1) \
+			printf(args); \
+	} while (0)
+
+#endif /* OPD_PRINTF_H */
diff --git a/daemon/opd_sfile.c b/daemon/opd_sfile.c
new file mode 100644
index 0000000..03ebf55
--- /dev/null
+++ b/daemon/opd_sfile.c
@@ -0,0 +1,619 @@
+/**
+ * @file daemon/opd_sfile.c
+ * Management of sample files
+ *
+ * @remark Copyright 2002, 2005 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "opd_sfile.h"
+
+#include "opd_trans.h"
+#include "opd_kernel.h"
+#include "opd_mangling.h"
+#include "opd_anon.h"
+#include "opd_printf.h"
+#include "opd_stats.h"
+#include "oprofiled.h"
+
+#include "op_libiberty.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define HASH_SIZE 2048
+#define HASH_BITS (HASH_SIZE - 1)
+
+/** All sfiles are hashed into these lists */
+static struct list_head hashes[HASH_SIZE];
+
+/** All sfiles are on this list. */
+static LIST_HEAD(lru_list);
+
+
+/* FIXME: can undoubtedly improve this hashing */
+/** Hash the transient parameters for lookup. */
+static unsigned long
+sfile_hash(struct transient const * trans, struct kernel_image * ki)
+{
+	unsigned long val = 0;
+	
+	if (separate_thread) {
+		val ^= trans->tid << 2;
+		val ^= trans->tgid << 2;
+	}
+
+	if (separate_kernel || ((trans->anon || separate_lib) && !ki))
+		val ^= trans->app_cookie >> (DCOOKIE_SHIFT + 3);
+
+	if (separate_cpu)
+		val ^= trans->cpu;
+
+	/* cookie meaningless for kernel, shouldn't hash */
+	if (trans->in_kernel) {
+		val ^= ki->start >> 14;
+		val ^= ki->end >> 7;
+		return val & HASH_BITS;
+	}
+
+	if (trans->cookie != NO_COOKIE) {
+		val ^= trans->cookie >> DCOOKIE_SHIFT;
+		return val & HASH_BITS;
+	}
+
+	if (!separate_thread)
+		val ^= trans->tgid << 2;
+
+	if (trans->anon) {
+		val ^= trans->anon->start >> VMA_SHIFT;
+		val ^= trans->anon->end >> (VMA_SHIFT + 1);
+	}
+
+	return val & HASH_BITS;
+}
+
+
+static int
+do_match(struct sfile const * sf, cookie_t cookie, cookie_t app_cookie,
+         struct kernel_image const * ki, struct anon_mapping const * anon,
+         pid_t tgid, pid_t tid, unsigned int cpu)
+{
+	/* this is a simplified check for "is a kernel image" AND
+	 * "is the right kernel image". Also handles no-vmlinux
+	 * correctly.
+	 */
+	if (sf->kernel != ki)
+		return 0;
+
+	if (separate_thread) {
+		if (sf->tid != tid || sf->tgid != tgid)
+			return 0;
+	}
+
+	if (separate_cpu) {
+		if (sf->cpu != cpu)
+			return 0;
+	}
+
+	if (separate_kernel || ((anon || separate_lib) && !ki)) {
+		if (sf->app_cookie != app_cookie)
+			return 0;
+	}
+
+	/* ignore the cached trans->cookie for kernel images,
+	 * it's meaningless and we checked all others already
+	 */
+	if (ki)
+		return 1;
+
+	if (sf->anon != anon)
+		return 0;
+
+	return sf->cookie == cookie;
+}
+
+
+static int
+trans_match(struct transient const * trans, struct sfile const * sfile,
+            struct kernel_image const * ki)
+{
+	return do_match(sfile, trans->cookie, trans->app_cookie, ki,
+	                trans->anon, trans->tgid, trans->tid, trans->cpu);
+}
+
+
+static int
+sfile_equal(struct sfile const * sf, struct sfile const * sf2)
+{
+	return do_match(sf, sf2->cookie, sf2->app_cookie, sf2->kernel,
+	                sf2->anon, sf2->tgid, sf2->tid, sf2->cpu);
+}
+
+
+static int
+is_sf_ignored(struct sfile const * sf)
+{
+	if (sf->kernel) {
+		if (!is_image_ignored(sf->kernel->name))
+			return 0;
+
+		/* Let a dependent kernel image redeem the sf if we're
+		 * executing on behalf of an application.
+		 */
+		return is_cookie_ignored(sf->app_cookie);
+	}
+
+	/* Anon regions are always dependent on the application.
+ 	 * Otherwise, let a dependent image redeem the sf.
+	 */
+	if (sf->anon || is_cookie_ignored(sf->cookie))
+		return is_cookie_ignored(sf->app_cookie);
+
+	return 0;
+}
+
+
+/** create a new sfile matching the current transient parameters */
+static struct sfile *
+create_sfile(unsigned long hash, struct transient const * trans,
+             struct kernel_image * ki)
+{
+	size_t i;
+	struct sfile * sf;
+
+	sf = xmalloc(sizeof(struct sfile));
+
+	sf->hashval = hash;
+
+	/* The logic here: if we're in the kernel, the cached cookie is
+	 * meaningless (though not the app_cookie if separate_kernel)
+	 */
+	sf->cookie = trans->in_kernel ? INVALID_COOKIE : trans->cookie;
+	sf->app_cookie = INVALID_COOKIE;
+	sf->tid = (pid_t)-1;
+	sf->tgid = (pid_t)-1;
+	sf->cpu = 0;
+	sf->kernel = ki;
+	sf->anon = trans->anon;
+
+	for (i = 0 ; i < op_nr_counters ; ++i)
+		odb_init(&sf->files[i]);
+
+	for (i = 0; i < CG_HASH_SIZE; ++i)
+		list_init(&sf->cg_hash[i]);
+
+	if (separate_thread)
+		sf->tid = trans->tid;
+	if (separate_thread || trans->cookie == NO_COOKIE)
+		sf->tgid = trans->tgid;
+
+	if (separate_cpu)
+		sf->cpu = trans->cpu;
+
+	if (separate_kernel || ((trans->anon || separate_lib) && !ki))
+		sf->app_cookie = trans->app_cookie;
+
+	sf->ignored = is_sf_ignored(sf);
+
+	sf->embedded_offset = trans->embedded_offset;
+
+	/* If embedded_offset is a valid value, it means we're
+	 * processing a Cell BE SPU profile; in which case, we
+	 * want sf->app_cookie to hold trans->app_cookie.
+	 */
+	if (trans->embedded_offset != UNUSED_EMBEDDED_OFFSET)
+		sf->app_cookie = trans->app_cookie;
+	return sf;
+}
+
+
+struct sfile * sfile_find(struct transient const * trans)
+{
+	struct sfile * sf;
+	struct list_head * pos;
+	struct kernel_image * ki = NULL;
+	unsigned long hash;
+
+	if (trans->tracing != TRACING_ON) {
+		opd_stats[OPD_SAMPLES]++;
+		opd_stats[trans->in_kernel == 1 ? OPD_KERNEL : OPD_PROCESS]++;
+	}
+
+	/* There is a small race where this *can* happen, see
+	 * caller of cpu_buffer_reset() in the kernel
+	 */
+	if (trans->in_kernel == -1) {
+		verbprintf(vsamples, "Losing sample at 0x%llx of unknown provenance.\n",
+		           trans->pc);
+		opd_stats[OPD_NO_CTX]++;
+		return NULL;
+	}
+
+	/* we might need a kernel image start/end to hash on */
+	if (trans->in_kernel) {
+		ki = find_kernel_image(trans);
+		if (!ki) {
+			verbprintf(vsamples, "Lost kernel sample %llx\n", trans->pc);
+			opd_stats[OPD_LOST_KERNEL]++;
+			return NULL;
+		}
+	} else if (trans->cookie == NO_COOKIE && !trans->anon) {
+		if (vsamples) {
+			char const * app = verbose_cookie(trans->app_cookie);
+			printf("No anon map for pc %llx, app %s.\n",
+			       trans->pc, app);
+		}
+		opd_stats[OPD_LOST_NO_MAPPING]++;
+		return NULL;
+	}
+
+	hash = sfile_hash(trans, ki);
+	list_for_each(pos, &hashes[hash]) {
+		sf = list_entry(pos, struct sfile, hash);
+		if (trans_match(trans, sf, ki)) {
+			sfile_get(sf);
+			goto lru;
+		}
+	}
+
+	sf = create_sfile(hash, trans, ki);
+	list_add(&sf->hash, &hashes[hash]);
+
+lru:
+	sfile_put(sf);
+	return sf;
+}
+
+
+static void sfile_dup(struct sfile * to, struct sfile * from)
+{
+	size_t i;
+
+	memcpy(to, from, sizeof (struct sfile));
+
+	for (i = 0 ; i < op_nr_counters ; ++i)
+		odb_init(&to->files[i]);
+
+	for (i = 0; i < CG_HASH_SIZE; ++i)
+		list_init(&to->cg_hash[i]);
+
+	list_init(&to->hash);
+	list_init(&to->lru);
+}
+
+
+static odb_t * get_file(struct transient const * trans, int is_cg)
+{
+	struct sfile * sf = trans->current;
+	struct sfile * last = trans->last;
+	struct cg_entry * cg;
+	struct list_head * pos;
+	unsigned long hash;
+	odb_t * file;
+
+	if (trans->event >= op_nr_counters) {
+		fprintf(stderr, "%s: Invalid counter %lu\n", __FUNCTION__,
+			trans->event);
+		abort();
+	}
+
+	file = &sf->files[trans->event];
+
+	if (!is_cg)
+		goto open;
+
+	hash = last->hashval & (CG_HASH_SIZE - 1);
+
+	/* Need to look for the right 'to'. Since we're looking for
+	 * 'last', we use its hash.
+	 */
+	list_for_each(pos, &sf->cg_hash[hash]) {
+		cg = list_entry(pos, struct cg_entry, hash);
+		if (sfile_equal(last, &cg->to)) {
+			file = &cg->to.files[trans->event];
+			goto open;
+		}
+	}
+
+	cg = xmalloc(sizeof(struct cg_entry));
+	sfile_dup(&cg->to, last);
+	list_add(&cg->hash, &sf->cg_hash[hash]);
+	file = &cg->to.files[trans->event];
+
+open:
+	if (!odb_open_count(file))
+		opd_open_sample_file(file, last, sf, trans->event, is_cg);
+
+	/* Error is logged by opd_open_sample_file */
+	if (!odb_open_count(file))
+		return NULL;
+
+	return file;
+}
+
+
+static void verbose_print_sample(struct sfile * sf, vma_t pc, uint counter)
+{
+	char const * app = verbose_cookie(sf->app_cookie);
+	printf("0x%llx(%u): ", pc, counter);
+	if (sf->anon) {
+		printf("anon (tgid %u, 0x%llx-0x%llx), ",
+		       (unsigned int)sf->anon->tgid,
+		       sf->anon->start, sf->anon->end);
+	} else if (sf->kernel) {
+		printf("kern (name %s, 0x%llx-0x%llx), ", sf->kernel->name,
+		       sf->kernel->start, sf->kernel->end);
+	} else {
+		printf("%s(%llx), ", verbose_cookie(sf->cookie),  sf->cookie);
+	}
+	printf("app %s(%llx)", app, sf->app_cookie);
+}
+
+
+static void verbose_sample(struct transient const * trans, vma_t pc)
+{
+	printf("Sample ");
+	verbose_print_sample(trans->current, pc, trans->event);
+	printf("\n");
+}
+
+
+static void
+verbose_arc(struct transient const * trans, vma_t from, vma_t to)
+{
+	printf("Arc ");
+	verbose_print_sample(trans->current, from, trans->event);
+	printf(" -> 0x%llx", to);
+	printf("\n");
+}
+
+
+static void sfile_log_arc(struct transient const * trans)
+{
+	int err;
+	vma_t from = trans->pc;
+	vma_t to = trans->last_pc;
+	uint64_t key;
+	odb_t * file;
+
+	file = get_file(trans, 1);
+
+	/* absolute value -> offset */
+	if (trans->current->kernel)
+		from -= trans->current->kernel->start;
+
+	if (trans->last->kernel)
+		to -= trans->last->kernel->start;
+
+	if (trans->current->anon)
+		from -= trans->current->anon->start;
+
+	if (trans->last->anon)
+		to -= trans->last->anon->start;
+
+	if (varcs)
+		verbose_arc(trans, from, to);
+
+	if (!file) {
+		opd_stats[OPD_LOST_SAMPLEFILE]++;
+		return;
+	}
+
+	/* Possible narrowings to 32-bit value only. */
+	key = to & (0xffffffff);
+	key |= ((uint64_t)from) << 32;
+
+	err = odb_update_node(file, key);
+	if (err) {
+		fprintf(stderr, "%s: %s\n", __FUNCTION__, strerror(err));
+		abort();
+	}
+}
+
+
+void sfile_log_sample(struct transient const * trans)
+{
+	int err;
+	vma_t pc = trans->pc;
+	odb_t * file;
+
+	if (trans->tracing == TRACING_ON) {
+		/* can happen if kernel sample falls through the cracks,
+		 * see opd_put_sample() */
+		if (trans->last)
+			sfile_log_arc(trans);
+		return;
+	}
+
+	file = get_file(trans, 0);
+
+	/* absolute value -> offset */
+	if (trans->current->kernel)
+		pc -= trans->current->kernel->start;
+
+	if (trans->current->anon)
+		pc -= trans->current->anon->start;
+ 
+	if (vsamples)
+		verbose_sample(trans, pc);
+
+	if (!file) {
+		opd_stats[OPD_LOST_SAMPLEFILE]++;
+		return;
+	}
+
+	err = odb_update_node(file, (uint64_t)pc);
+	if (err) {
+		fprintf(stderr, "%s: %s\n", __FUNCTION__, strerror(err));
+		abort();
+	}
+}
+
+
+static int close_sfile(struct sfile * sf, void * data __attribute__((unused)))
+{
+	size_t i;
+
+	/* it's OK to close a non-open odb file */
+	for (i = 0; i < op_nr_counters; ++i)
+		odb_close(&sf->files[i]);
+
+	return 0;
+}
+
+
+static void kill_sfile(struct sfile * sf)
+{
+	close_sfile(sf, NULL);
+	list_del(&sf->hash);
+	list_del(&sf->lru);
+}
+
+
+static int sync_sfile(struct sfile * sf, void * data __attribute__((unused)))
+{
+	size_t i;
+
+	for (i = 0; i < op_nr_counters; ++i)
+		odb_sync(&sf->files[i]);
+
+	return 0;
+}
+
+
+static int is_sfile_kernel(struct sfile * sf, void * data __attribute__((unused)))
+{
+	return !!sf->kernel;
+}
+
+
+static int is_sfile_anon(struct sfile * sf, void * data)
+{
+	return sf->anon == data;
+}
+
+
+typedef int (*sfile_func)(struct sfile *, void *);
+
+static void
+for_one_sfile(struct sfile * sf, sfile_func func, void * data)
+{
+	size_t i;
+	int free_sf = func(sf, data);
+
+	for (i = 0; i < CG_HASH_SIZE; ++i) {
+		struct list_head * pos;
+		struct list_head * pos2;
+		list_for_each_safe(pos, pos2, &sf->cg_hash[i]) {
+			struct cg_entry * cg =
+				list_entry(pos, struct cg_entry, hash);
+			if (free_sf || func(&cg->to, data)) {
+				kill_sfile(&cg->to);
+				list_del(&cg->hash);
+				free(cg);
+			}
+		}
+	}
+
+	if (free_sf) {
+		kill_sfile(sf);
+		free(sf);
+	}
+}
+
+
+static void for_each_sfile(sfile_func func, void * data)
+{
+	struct list_head * pos;
+	struct list_head * pos2;
+
+	list_for_each_safe(pos, pos2, &lru_list) {
+		struct sfile * sf = list_entry(pos, struct sfile, lru);
+		for_one_sfile(sf, func, data);
+	}
+}
+
+
+void sfile_clear_kernel(void)
+{
+	for_each_sfile(is_sfile_kernel, NULL);
+}
+
+
+void sfile_clear_anon(struct anon_mapping * anon)
+{
+	for_each_sfile(is_sfile_anon, anon);
+}
+
+
+void sfile_sync_files(void)
+{
+	for_each_sfile(sync_sfile, NULL);
+}
+
+
+void sfile_close_files(void)
+{
+	for_each_sfile(close_sfile, NULL);
+}
+
+
+static int always_true(void)
+{
+	return 1;
+}
+
+
+#define LRU_AMOUNT 256
+
+/*
+ * Clear out older sfiles. Note the current sfiles we're using
+ * will not be present in this list, due to sfile_get/put() pairs
+ * around the caller of this.
+ */
+int sfile_lru_clear(void)
+{
+	struct list_head * pos;
+	struct list_head * pos2;
+	int amount = LRU_AMOUNT;
+
+	if (list_empty(&lru_list))
+		return 1;
+
+	list_for_each_safe(pos, pos2, &lru_list) {
+		struct sfile * sf;
+		if (!--amount)
+			break;
+		sf = list_entry(pos, struct sfile, lru);
+		for_one_sfile(sf, (sfile_func)always_true, NULL);
+	}
+
+	return 0;
+}
+
+
+void sfile_get(struct sfile * sf)
+{
+	if (sf)
+		list_del(&sf->lru);
+}
+
+
+void sfile_put(struct sfile * sf)
+{
+	if (sf)
+		list_add_tail(&sf->lru, &lru_list);
+}
+
+
+void sfile_init(void)
+{
+	size_t i = 0;
+
+	for (; i < HASH_SIZE; ++i)
+		list_init(&hashes[i]);
+}
diff --git a/daemon/opd_sfile.h b/daemon/opd_sfile.h
new file mode 100644
index 0000000..86d5025
--- /dev/null
+++ b/daemon/opd_sfile.h
@@ -0,0 +1,113 @@
+/**
+ * @file daemon/opd_sfile.h
+ * Management of sample files
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OPD_SFILE_H
+#define OPD_SFILE_H
+
+#include "opd_cookie.h"
+
+#include "odb.h"
+#include "op_hw_config.h"
+#include "op_types.h"
+#include "op_list.h"
+
+#include <sys/types.h>
+
+struct kernel_image;
+struct transient;
+
+#define CG_HASH_SIZE 16
+#define UNUSED_EMBEDDED_OFFSET ~0LLU
+
+/**
+ * Each set of sample files (where a set is over the physical counter
+ * types) will have one of these for it. We match against the
+ * descriptions here to find which sample DB file we need to modify.
+ *
+ * cg files are stored in the hash.
+ */
+struct sfile {
+	/** hash value for this sfile */
+	unsigned long hashval;
+	/** cookie value for the binary profiled */
+	cookie_t cookie;
+	/** cookie value for the application owner, INVALID_COOKIE if not set */
+	cookie_t app_cookie;
+	/** thread ID, -1 if not set */
+	pid_t tid;
+	/** thread group ID, -1 if not set */
+	pid_t tgid;
+	/** CPU number */
+	unsigned int cpu;
+	/** kernel image if applicable */
+	struct kernel_image * kernel;
+	/** anonymous mapping */
+	struct anon_mapping * anon;
+	/** embedded offset for Cell BE SPU */
+	uint64_t embedded_offset;
+
+	/** hash table link */
+	struct list_head hash;
+	/** lru list */
+	struct list_head lru;
+	/** true if this file should be ignored in profiles */
+	int ignored;
+	/** opened sample files */
+	odb_t files[OP_MAX_COUNTERS];
+	/** hash table of opened cg sample files */
+	struct list_head cg_hash[CG_HASH_SIZE];
+};
+
+/** a call-graph entry */
+struct cg_entry {
+	/** where arc is to */
+	struct sfile to;
+	/** next in the hash slot */
+	struct list_head hash;
+};
+
+/** clear any sfiles that are for the kernel */
+void sfile_clear_kernel(void);
+
+struct anon_mapping;
+
+/** clear any sfiles for the given anon mapping */
+void sfile_clear_anon(struct anon_mapping *);
+
+/** sync sample files */
+void sfile_sync_files(void);
+
+/** close sample files */
+void sfile_close_files(void);
+
+/** clear out a certain amount of LRU entries
+ * return non-zero if the lru is already empty */
+int sfile_lru_clear(void);
+
+/** remove a sfile from the lru list, protecting it from sfile_lru_clear() */
+void sfile_get(struct sfile * sf);
+
+/** add this sfile to lru list */
+void sfile_put(struct sfile * sf);
+
+/**
+ * Find the sfile for the current parameters. Note that is required
+ * that the PC value be set appropriately (needed for kernel images)
+ */
+struct sfile * sfile_find(struct transient const * trans);
+
+/** Log the sample in a previously located sfile. */
+void sfile_log_sample(struct transient const * trans);
+
+/** initialise hashes */
+void sfile_init(void);
+
+#endif /* OPD_SFILE_H */
diff --git a/daemon/opd_spu.c b/daemon/opd_spu.c
new file mode 100644
index 0000000..62a2c2b
--- /dev/null
+++ b/daemon/opd_spu.c
@@ -0,0 +1,176 @@
+/**
+ * @file daemon/opd_spu.c
+ * Processing the sample buffer for Cell BE SPU profile
+ *
+ * @remark Copyright 2007 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Maynard Johnson
+ * (C) Copyright IBM Corporation 2007
+ */
+
+#include "opd_interface.h"
+#include "opd_printf.h"
+#include "opd_sfile.h"
+#include "opd_stats.h"
+#include "opd_trans.h"
+#include "op_libiberty.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+struct spu_context_info {
+	pid_t tid;
+	pid_t tgid;
+	cookie_t app_cookie;
+	uint64_t embedded_offset;
+	cookie_t spu_cookie;
+};
+
+static struct spu_context_info * spu_context_cache;
+
+/* Forward declaration */
+static void process_spu_samples(struct transient * trans);
+
+void (*special_processor)(struct transient *);
+
+/*
+ * This function is called when the first value found in the
+ * buffer (after the beginning ESCAPE_CODE) is SPU_PROFILING_CODE.
+ * Once we get here, the rest of the processing of the buffer is
+ * Cell-SPU-specific, so we do not need to return until the
+ * trans.buffer is empty.
+ */
+void code_spu_profiling(struct transient * trans)
+{
+	/* Next value in buffer is the number of SPUs. */
+	unsigned long long num_spus = pop_buffer_value(trans);
+	/* Free the cache from previous run */
+	free(spu_context_cache);
+	spu_context_cache = xmalloc(sizeof(struct spu_context_info) * num_spus);
+	special_processor = process_spu_samples;
+	process_spu_samples(trans);
+}
+
+void code_spu_ctx_switch(struct transient * trans)
+{
+	clear_trans_current(trans);
+
+	if (!enough_remaining(trans, 6)) {
+		trans->remaining = 0;
+		return;
+	}
+
+	/* First value in the buffer for an SPU context switch is
+	 * the SPU number.  For SPU profiling, 'cpu' = 'spu'.
+	 */
+	trans->cpu = pop_buffer_value(trans);
+	trans->tid = pop_buffer_value(trans);
+	trans->tgid = pop_buffer_value(trans);
+	trans->app_cookie = pop_buffer_value(trans);
+
+	if (vmisc) {
+		char const * app = find_cookie(trans->app_cookie);
+		printf("SPU_CTX_SWITCH to tid %lu, tgid %lu, cookie %llx(%s)\n",
+		       (unsigned long)trans->tid, (unsigned long)trans->tgid,
+		       trans->app_cookie, app ? app : "none");
+	}
+
+	/* The trans->cookie will point to the binary file where the SPU ELF
+	 * can be found.  If the SPU ELF is embedded, it may be embedded in
+	 * either the executable application binary or a shared lib.  If shared
+	 * library, then trans->cookie will differ from the previously obtained
+	 * trans->app_cookie.  For the non-embedded case, trans->cookie always
+	 * points to a separate binary file.
+	 */
+	trans->cookie = pop_buffer_value(trans);
+	trans->embedded_offset = pop_buffer_value(trans);
+}
+
+
+static void cache_spu_context_info(struct transient * trans)
+{
+	int i = trans->cpu;
+	spu_context_cache[i].tid = trans->tid;
+	spu_context_cache[i].tgid = trans->tgid;
+	spu_context_cache[i].app_cookie = trans->app_cookie;
+	spu_context_cache[i].embedded_offset = trans->embedded_offset;
+	spu_context_cache[i].spu_cookie = trans->cookie;
+}
+
+static void update_trans_for_spu(struct transient * trans)
+{
+	int i = trans->cpu;
+	trans->tid = spu_context_cache[i].tid;
+	trans->tgid = spu_context_cache[i].tgid;
+	trans->app_cookie = spu_context_cache[i].app_cookie;
+	trans->embedded_offset = spu_context_cache[i].embedded_offset;
+	trans->cookie = spu_context_cache[i].spu_cookie;
+}
+#define SPU_NUM_MASK 0xFFFFFFFF00000000ULL
+#define SPU_CYCLES_COUNTER 0
+
+static void opd_put_spu_sample
+(struct transient * trans, unsigned long long pc)
+{
+	unsigned long spu_number = (pc & SPU_NUM_MASK) >> 32;
+	if (trans->cpu != spu_number) {
+		trans->cpu = spu_number;
+	        clear_trans_current(trans);
+		update_trans_for_spu(trans);
+	}
+	/* get the current sfile if needed */
+	if (!trans->current)
+		trans->current = sfile_find(trans);
+
+	if (trans->tracing != TRACING_ON)
+		trans->event = SPU_CYCLES_COUNTER;
+
+	trans->pc = (pc & ~SPU_NUM_MASK);
+	/* log the sample or arc */
+	sfile_log_sample(trans);
+
+	/* switch to trace mode */
+	if (trans->tracing == TRACING_START)
+		trans->tracing = TRACING_ON;
+
+	update_trans_last(trans);
+}
+
+/*
+ * This function processes SPU context switches and
+ * SPU program counter samples.  After processing a
+ * context switch (via handlers[code)), we cache the
+ * SPU context information that has been temporarily
+ * stored in trans.
+ */
+static void process_spu_samples(struct transient * trans)
+{
+	unsigned long long code;
+	trans->in_kernel = 0;
+	while (trans->remaining) {
+		code = pop_buffer_value(trans);
+
+		if (!is_escape_code(code)) {
+			opd_put_spu_sample(trans, code);
+			continue;
+		}
+
+		if (!trans->remaining) {
+			verbprintf(vmisc, "Dangling ESCAPE_CODE.\n");
+			opd_stats[OPD_DANGLING_CODE]++;
+			break;
+		}
+
+		/* started with ESCAPE_CODE, next is type */
+		code = pop_buffer_value(trans);
+
+		if (code >= LAST_CODE) {
+			fprintf(stderr, "Unknown code %llu\n", code);
+			abort();
+		}
+
+		handlers[code](trans);
+		cache_spu_context_info(trans);
+	}
+}
diff --git a/daemon/opd_stats.c b/daemon/opd_stats.c
new file mode 100644
index 0000000..ddb1940
--- /dev/null
+++ b/daemon/opd_stats.c
@@ -0,0 +1,85 @@
+/**
+ * @file daemon/opd_stats.c
+ * Management of daemon statistics
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "opd_stats.h"
+#include "oprofiled.h"
+
+#include "op_get_time.h"
+
+#include <dirent.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+unsigned long opd_stats[OPD_MAX_STATS];
+
+/**
+ * print_if - print an integer value read from file filename,
+ * do nothing if the value read == -1 except if force is non-zero
+ */
+static void print_if(char const * fmt, char const * path, char const * filename, int force)
+{
+	int value = opd_read_fs_int(path, filename, 0);
+	if (value != -1 || force)
+		printf(fmt, value);
+}
+
+/**
+ * opd_print_stats - print out latest statistics
+ */
+void opd_print_stats(void)
+{
+	DIR * dir;
+	struct dirent * dirent;
+
+	printf("\n%s\n", op_get_time());
+	printf("Nr. sample dumps: %lu\n", opd_stats[OPD_DUMP_COUNT]);
+	printf("Nr. non-backtrace samples: %lu\n", opd_stats[OPD_SAMPLES]);
+	printf("Nr. kernel samples: %lu\n", opd_stats[OPD_KERNEL]);
+	printf("Nr. lost samples (no kernel/user): %lu\n", opd_stats[OPD_NO_CTX]);
+	printf("Nr. lost kernel samples: %lu\n", opd_stats[OPD_LOST_KERNEL]);
+	printf("Nr. incomplete code structs: %lu\n", opd_stats[OPD_DANGLING_CODE]);
+	printf("Nr. samples lost due to sample file open failure: %lu\n",
+		opd_stats[OPD_LOST_SAMPLEFILE]);
+	printf("Nr. samples lost due to no permanent mapping: %lu\n",
+		opd_stats[OPD_LOST_NO_MAPPING]);
+	print_if("Nr. event lost due to buffer overflow: %u\n",
+	       "/dev/oprofile/stats", "event_lost_overflow", 1);
+	print_if("Nr. samples lost due to no mapping: %u\n",
+	       "/dev/oprofile/stats", "sample_lost_no_mapping", 1);
+	print_if("Nr. backtraces skipped due to no file mapping: %u\n",
+	       "/dev/oprofile/stats", "bt_lost_no_mapping", 0);
+	print_if("Nr. samples lost due to no mm: %u\n",
+	       "/dev/oprofile/stats", "sample_lost_no_mm", 1);
+
+	if (!(dir = opendir("/dev/oprofile/stats/")))
+		goto out;
+	while ((dirent = readdir(dir))) {
+		int cpu_nr;
+		char path[256];
+		if (sscanf(dirent->d_name, "cpu%d", &cpu_nr) != 1)
+			continue;
+		snprintf(path, 256, "/dev/oprofile/stats/%s", dirent->d_name);
+
+		print_if("Nr. samples lost cpu buffer overflow: %u\n",
+		     path, "sample_lost_overflow", 1);
+		print_if("Nr. samples lost task exit: %u\n",
+		     path, "sample_lost_task_exit", 0);
+		print_if("Nr. samples received: %u\n",
+		     path, "sample_received", 1);
+		print_if("Nr. backtrace aborted: %u\n", 
+		     path, "backtrace_aborted", 0);
+		print_if("Nr. samples lost invalid pc: %u\n", 
+		     path, "sample_invalid_eip", 0);
+	}
+	closedir(dir);
+out:
+	fflush(stdout);
+}
diff --git a/daemon/opd_stats.h b/daemon/opd_stats.h
new file mode 100644
index 0000000..177b86a
--- /dev/null
+++ b/daemon/opd_stats.h
@@ -0,0 +1,31 @@
+/**
+ * @file daemon/opd_stats.h
+ * Management of daemon statistics
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OPD_STATS_H
+#define OPD_STATS_H
+
+extern unsigned long opd_stats[];
+
+enum {	OPD_SAMPLES, /**< nr. samples */
+	OPD_KERNEL, /**< nr. kernel samples */
+	OPD_PROCESS, /**< nr. userspace samples */
+	OPD_NO_CTX, /**< nr. samples lost due to not knowing if in the kernel or not */
+	OPD_LOST_KERNEL,  /**< nr. kernel samples lost */
+	OPD_LOST_SAMPLEFILE, /**< nr samples for which sample file can't be opened */
+	OPD_LOST_NO_MAPPING, /**< nr samples lost due to no mapping */
+	OPD_DUMP_COUNT, /**< nr. of times buffer is read */
+	OPD_DANGLING_CODE, /**< nr. partial code notifications (buffer overflow */
+	OPD_MAX_STATS /**< end of stats */
+};
+
+void opd_print_stats(void);
+
+#endif /* OPD_STATS_H */
diff --git a/daemon/opd_trans.c b/daemon/opd_trans.c
new file mode 100644
index 0000000..871e6e6
--- /dev/null
+++ b/daemon/opd_trans.c
@@ -0,0 +1,349 @@
+/**
+ * @file daemon/opd_trans.c
+ * Processing the sample buffer
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ *
+ * Modified by Maynard Johnson <maynardj@us.ibm.com>
+ * These modifications are:
+ * (C) Copyright IBM Corporation 2007
+ */
+
+#include "opd_trans.h"
+#include "opd_kernel.h"
+#include "opd_sfile.h"
+#include "opd_anon.h"
+#include "opd_stats.h"
+#include "opd_printf.h"
+#include "opd_interface.h"
+ 
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <errno.h>
+
+extern size_t kernel_pointer_size;
+
+
+void clear_trans_last(struct transient * trans)
+{
+	trans->last = NULL;
+	trans->last_anon = NULL;
+}
+
+
+void clear_trans_current(struct transient * trans)
+{
+	trans->current = NULL;
+	trans->anon = NULL;
+}
+
+
+uint64_t pop_buffer_value(struct transient * trans)
+{
+	uint64_t val;
+
+	if (!trans->remaining) {
+		fprintf(stderr, "BUG: popping empty buffer !\n");
+		abort();
+	}
+
+	if (kernel_pointer_size == 4) {
+		uint32_t const * lbuf = (void const *)trans->buffer;
+		val = *lbuf;
+	} else {
+		uint64_t const * lbuf = (void const *)trans->buffer;
+		val = *lbuf;
+	}
+
+	trans->remaining--;
+	trans->buffer += kernel_pointer_size;
+	return val;
+}
+
+
+int enough_remaining(struct transient * trans, size_t size)
+{
+	if (trans->remaining >= size)
+		return 1;
+
+	verbprintf(vmisc, "Dangling ESCAPE_CODE.\n");
+	opd_stats[OPD_DANGLING_CODE]++;
+	return 0;
+}
+
+
+static void opd_put_sample(struct transient * trans, unsigned long long pc)
+{
+	unsigned long long event;
+
+	if (!enough_remaining(trans, 1)) {
+		trans->remaining = 0;
+		return;
+	}
+
+	event = pop_buffer_value(trans);
+
+	if (trans->tracing != TRACING_ON)
+		trans->event = event;
+
+	trans->pc = pc;
+
+	/* sfile can change at each sample for kernel */
+	if (trans->in_kernel != 0)
+		clear_trans_current(trans);
+
+	if (!trans->in_kernel && trans->cookie == NO_COOKIE)
+		trans->anon = find_anon_mapping(trans);
+
+	/* get the current sfile if needed */
+	if (!trans->current)
+		trans->current = sfile_find(trans);
+
+	/*
+	 * can happen if kernel sample falls through the cracks, or if
+	 * it's a sample from an anon region we couldn't find
+	 */
+	if (!trans->current)
+		goto out;
+
+	/* FIXME: this logic is perhaps too harsh? */
+	if (trans->current->ignored || (trans->last && trans->last->ignored))
+		goto out;
+
+	/* log the sample or arc */
+	sfile_log_sample(trans);
+
+out:
+	/* switch to trace mode */
+	if (trans->tracing == TRACING_START)
+		trans->tracing = TRACING_ON;
+
+	update_trans_last(trans);
+}
+
+
+static void code_unknown(struct transient * trans __attribute__((unused)))
+{
+	fprintf(stderr, "Unknown code !\n");
+	abort();
+}
+
+
+static void code_ctx_switch(struct transient * trans)
+{
+	clear_trans_current(trans);
+
+	if (!enough_remaining(trans, 5)) {
+		trans->remaining = 0;
+		return;
+	}
+
+	trans->tid = pop_buffer_value(trans);
+	trans->app_cookie = pop_buffer_value(trans);
+	/* must be ESCAPE_CODE, CTX_TGID_CODE, tgid. Like this
+	 * because tgid was added later in a compatible manner.
+	 */
+	pop_buffer_value(trans);
+	pop_buffer_value(trans);
+	trans->tgid = pop_buffer_value(trans);
+
+	if (vmisc) {
+		char const * app = find_cookie(trans->app_cookie);
+		printf("CTX_SWITCH to tid %lu, tgid %lu, cookie %llx(%s)\n",
+		       (unsigned long)trans->tid, (unsigned long)trans->tgid,
+		       trans->app_cookie, app ? app : "none");
+	}
+}
+
+
+static void code_cpu_switch(struct transient * trans)
+{
+	clear_trans_current(trans);
+
+	if (!enough_remaining(trans, 1)) {
+		trans->remaining = 0;
+		return;
+	}
+
+	trans->cpu = pop_buffer_value(trans);
+	verbprintf(vmisc, "CPU_SWITCH to %lu\n", trans->cpu);
+}
+
+
+static void code_cookie_switch(struct transient * trans)
+{
+	clear_trans_current(trans);
+
+	if (!enough_remaining(trans, 1)) {
+		trans->remaining = 0;
+		return;
+	}
+
+	trans->cookie = pop_buffer_value(trans);
+
+	if (vmisc) {
+		char const * name = verbose_cookie(trans->cookie);
+		verbprintf(vmisc, "COOKIE_SWITCH to cookie %s(%llx)\n",
+		           name, trans->cookie);
+	}
+}
+
+
+static void code_kernel_enter(struct transient * trans)
+{
+	verbprintf(vmisc, "KERNEL_ENTER_SWITCH to kernel\n");
+	trans->in_kernel = 1;
+	clear_trans_current(trans);
+	/* subtlety: we must keep trans->cookie cached,
+	 * even though it's meaningless for the kernel -
+	 * we won't necessarily get a cookie switch on
+	 * kernel exit. See comments in opd_sfile.c
+	 */
+}
+
+
+static void code_user_enter(struct transient * trans)
+{
+	verbprintf(vmisc, "USER_ENTER_SWITCH to user-space\n");
+	trans->in_kernel = 0;
+	clear_trans_current(trans);
+	clear_trans_last(trans);
+}
+
+
+static void code_module_loaded(struct transient * trans __attribute__((unused)))
+{
+	verbprintf(vmodule, "MODULE_LOADED_CODE\n");
+	opd_reread_module_info();
+	clear_trans_current(trans);
+	clear_trans_last(trans);
+}
+
+
+/*
+ * This also implicitly signals the end of the previous
+ * trace, so we never explicitly set TRACING_OFF when
+ * processing a buffer.
+ */
+static void code_trace_begin(struct transient * trans)
+{
+	verbprintf(varcs, "TRACE_BEGIN\n");
+	trans->tracing = TRACING_START;
+}
+
+static void code_xen_enter(struct transient * trans)
+{
+	verbprintf(vmisc, "XEN_ENTER_SWITCH to xen\n");
+	trans->in_kernel = 1;
+	trans->current = NULL;
+	/* subtlety: we must keep trans->cookie cached, even though it's 
+	 * meaningless for Xen - we won't necessarily get a cookie switch 
+	 * on Xen exit. See comments in opd_sfile.c. It seems that we can 
+	 * get away with in_kernel = 1 as long as we supply the correct 
+	 * Xen image, and its address range in startup find_kernel_image 
+	 * is modified to look in the Xen image also
+	 */
+}
+
+extern void code_spu_profiling(struct transient * trans);
+extern void code_spu_ctx_switch(struct transient * trans);
+
+handler_t handlers[LAST_CODE + 1] = {
+	&code_unknown,
+	&code_ctx_switch,
+	&code_cpu_switch,
+	&code_cookie_switch,
+	&code_kernel_enter,
+ 	&code_user_enter,
+	&code_module_loaded,
+	/* tgid handled differently */
+	&code_unknown,
+	&code_trace_begin,
+	&code_unknown,
+ 	&code_xen_enter,
+#if defined(__powerpc__)
+	&code_spu_profiling,
+	&code_spu_ctx_switch,
+#endif
+	&code_unknown,
+};
+
+extern void (*special_processor)(struct transient *);
+
+void opd_process_samples(char const * buffer, size_t count)
+{
+	struct transient trans = {
+		.buffer = buffer,
+		.remaining = count,
+		.tracing = TRACING_OFF,
+		.current = NULL,
+		.last = NULL,
+		.cookie = INVALID_COOKIE,
+		.app_cookie = INVALID_COOKIE,
+		.anon = NULL,
+		.last_anon = NULL,
+		.pc = 0,
+		.last_pc = 0,
+		.event = 0,
+		.in_kernel = -1,
+		.cpu = -1,
+		.tid = -1,
+		.embedded_offset = UNUSED_EMBEDDED_OFFSET,
+		.tgid = -1
+	};
+
+	/* FIXME: was uint64_t but it can't compile on alpha where uint64_t
+	 * is an unsigned long and below the printf("..." %llu\n", code)
+	 * generate a warning, this look like a stopper to use c98 types :/
+	 */
+	unsigned long long code;
+
+	if (special_processor) {
+		special_processor(&trans);
+		return;
+	}
+
+    int i;
+
+    for (i = 0; i < count && i < 200; i++) {
+        verbprintf(vmisc, "buffer[%d] is %x\n", i, buffer[i]);
+    }
+
+	while (trans.remaining) {
+		code = pop_buffer_value(&trans);
+
+        verbprintf(vmisc, "In opd_process_samples (code is %lld)\n", code);
+
+		if (!is_escape_code(code)) {
+			opd_put_sample(&trans, code);
+			continue;
+		}
+
+		if (!trans.remaining) {
+			verbprintf(vmisc, "Dangling ESCAPE_CODE.\n");
+			opd_stats[OPD_DANGLING_CODE]++;
+			break;
+		}
+
+		// started with ESCAPE_CODE, next is type
+		code = pop_buffer_value(&trans);
+	
+        verbprintf(vmisc, "next code is %lld\n", code);
+		if (code >= LAST_CODE) {
+			fprintf(stderr, "Unknown code %llu\n", code);
+			abort();
+		}
+
+		handlers[code](&trans);
+	}
+}
diff --git a/daemon/opd_trans.h b/daemon/opd_trans.h
new file mode 100644
index 0000000..ab4e816
--- /dev/null
+++ b/daemon/opd_trans.h
@@ -0,0 +1,85 @@
+/**
+ * @file daemon/opd_trans.h
+ * Processing the sample buffer
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ *
+ * Modified by Maynard Johnson <maynardj@us.ibm.com>
+ * These modifications are:
+ * (C) Copyright IBM Corporation 2007
+ */
+
+#ifndef OPD_TRANS_H
+#define OPD_TRANS_H
+
+#include "opd_cookie.h"
+#include "op_types.h"
+
+#include <stdint.h>
+
+struct sfile;
+struct anon_mapping;
+
+enum tracing_type {
+	TRACING_OFF,
+	TRACING_START,
+	TRACING_ON
+};
+
+/**
+ * Transient values used for parsing the event buffer.
+ * Note that these are reset for each buffer read, but
+ * that should be ok as in the kernel, cpu_buffer_reset()
+ * ensures that a correct context starts off the buffer.
+ */
+struct transient {
+	char const * buffer;
+	size_t remaining;
+	enum tracing_type tracing;
+	struct sfile * current;
+	struct sfile * last;
+	struct anon_mapping * anon;
+	struct anon_mapping * last_anon;
+	cookie_t cookie;
+	cookie_t app_cookie;
+	vma_t pc;
+	vma_t last_pc;
+	unsigned long event;
+	int in_kernel;
+	unsigned long cpu;
+	pid_t tid;
+	pid_t tgid;
+	uint64_t embedded_offset;
+};
+
+typedef void (*handler_t)(struct transient *);
+extern handler_t handlers[];
+
+uint64_t pop_buffer_value(struct transient * trans);
+int enough_remaining(struct transient * trans, size_t size);
+static inline void update_trans_last(struct transient * trans)
+{
+	trans->last = trans->current;
+	trans->last_anon = trans->anon;
+	trans->last_pc = trans->pc;
+}
+
+extern size_t kernel_pointer_size;
+static inline int is_escape_code(uint64_t code)
+{
+	return kernel_pointer_size == 4 ? code == ~0LU : code == ~0LLU;
+}
+
+void opd_process_samples(char const * buffer, size_t count);
+
+/** used when we need to clear data that's been freed */
+void clear_trans_last(struct transient * trans);
+
+/** used when we need to clear data that's been freed */
+void clear_trans_current(struct transient * trans);
+
+#endif /* OPD_TRANS_H */
diff --git a/daemon/oprofiled.c b/daemon/oprofiled.c
new file mode 100644
index 0000000..ec2ea1b
--- /dev/null
+++ b/daemon/oprofiled.c
@@ -0,0 +1,522 @@
+/**
+ * @file daemon/oprofiled.c
+ * Initialisation and setup
+ *
+ * @remark Copyright 2002, 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ */
+
+#include "config.h"
+ 
+#include "oprofiled.h"
+#include "opd_printf.h"
+#include "opd_events.h"
+
+#include "op_config.h"
+#include "op_version.h"
+#include "op_hw_config.h"
+#include "op_libiberty.h"
+#include "op_file.h"
+#include "op_abi.h"
+#include "op_string.h"
+#include "op_cpu_type.h"
+#include "op_popt.h"
+#include "op_lockfile.h"
+#include "op_list.h"
+#include "op_fileio.h"
+
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <dirent.h>
+#include <limits.h>
+
+sig_atomic_t signal_alarm;
+sig_atomic_t signal_hup;
+sig_atomic_t signal_term;
+sig_atomic_t signal_child;
+sig_atomic_t signal_usr1;
+sig_atomic_t signal_usr2;
+
+uint op_nr_counters;
+op_cpu cpu_type;
+int vsfile;
+int vsamples;
+int varcs;
+int vmodule;
+int vmisc;
+int separate_lib;
+int separate_kernel;
+int separate_thread;
+int separate_cpu;
+int no_vmlinux;
+char * vmlinux;
+char * kernel_range;
+char * session_dir;
+int no_xen;
+char * xenimage;
+char * xen_range;
+static char * verbose;
+static char * binary_name_filter;
+static char * events;
+static int showvers;
+static struct oprofiled_ops * opd_ops;
+extern struct oprofiled_ops opd_24_ops;
+extern struct oprofiled_ops opd_26_ops;
+
+#define OPD_IMAGE_FILTER_HASH_SIZE 32
+static struct list_head images_filter[OPD_IMAGE_FILTER_HASH_SIZE];
+
+static struct poptOption options[] = {
+	{ "session-dir", 0, POPT_ARG_STRING, &session_dir, 0, "place sample database in dir instead of default location", "/var/lib/oprofile", },
+	{ "kernel-range", 'r', POPT_ARG_STRING, &kernel_range, 0, "Kernel VMA range", "start-end", },
+	{ "vmlinux", 'k', POPT_ARG_STRING, &vmlinux, 0, "vmlinux kernel image", "file", },
+	{ "no-vmlinux", 0, POPT_ARG_NONE, &no_vmlinux, 0, "vmlinux kernel image file not available", NULL, },
+	{ "xen-range", 0, POPT_ARG_STRING, &xen_range, 0, "Xen VMA range", "start-end", },
+	{ "xen-image", 0, POPT_ARG_STRING, &xenimage, 0, "Xen image", "file", },
+	{ "image", 0, POPT_ARG_STRING, &binary_name_filter, 0, "image name filter", "profile these comma separated image" },
+	{ "separate-lib", 0, POPT_ARG_INT, &separate_lib, 0, "separate library samples for each distinct application", "[0|1]", },
+	{ "separate-kernel", 0, POPT_ARG_INT, &separate_kernel, 0, "separate kernel samples for each distinct application", "[0|1]", },
+	{ "separate-thread", 0, POPT_ARG_INT, &separate_thread, 0, "thread-profiling mode", "[0|1]" },
+	{ "separate-cpu", 0, POPT_ARG_INT, &separate_cpu, 0, "separate samples for each CPU", "[0|1]" },
+	{ "events", 'e', POPT_ARG_STRING, &events, 0, "events list", "[events]" },
+	{ "version", 'v', POPT_ARG_NONE, &showvers, 0, "show version", NULL, },
+	{ "verbose", 'V', POPT_ARG_STRING, &verbose, 0, "be verbose in log file", "all,sfile,arcs,samples,module,misc", },
+	POPT_AUTOHELP
+	{ NULL, 0, 0, NULL, 0, NULL, NULL, },
+};
+ 
+
+void opd_open_logfile(void)
+{
+	if (open(op_log_file, O_WRONLY|O_CREAT|O_NOCTTY|O_APPEND, 0644) == -1) {
+		perror("oprofiled: couldn't re-open stdout: ");
+		exit(EXIT_FAILURE);
+	}
+
+	if (dup2(1, 2) == -1) {
+		perror("oprofiled: couldn't dup stdout to stderr: ");
+		exit(EXIT_FAILURE);
+	}
+}
+ 
+
+/**
+ * opd_fork - fork and return as child
+ *
+ * fork() and exit the parent with _exit().
+ * Failure is fatal.
+ */
+static void opd_fork(void)
+{
+	switch (fork()) {
+		case -1:
+			perror("oprofiled: fork() failed: ");
+			exit(EXIT_FAILURE);
+			break;
+		case 0:
+			break;
+		default:
+			/* parent */
+			_exit(EXIT_SUCCESS);
+			break;
+	}
+}
+
+ 
+static void opd_go_daemon(void)
+{
+	opd_fork();
+
+	if (chdir(op_session_dir)) {
+		fprintf(stderr, "oprofiled: opd_go_daemon: couldn't chdir to %s: %s",
+			op_session_dir, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	if (setsid() < 0) {
+		perror("oprofiled: opd_go_daemon: couldn't setsid: ");
+		exit(EXIT_FAILURE);
+	}
+
+	opd_fork();
+}
+
+
+static void opd_write_abi(void)
+{
+	char * cbuf;
+ 
+	cbuf = xmalloc(strlen(op_session_dir) + 5);
+	strcpy(cbuf, op_session_dir);
+	strcat(cbuf, "/abi");
+	op_write_abi_to_file(cbuf);
+	free(cbuf);
+}
+
+
+/**
+ * opd_alarm - sync files and report stats
+ */
+static void opd_alarm(int val __attribute__((unused)))
+{
+	signal_alarm = 1;
+}
+ 
+
+/* re-open logfile for logrotate */
+static void opd_sighup(int val __attribute__((unused)))
+{
+	signal_hup = 1;
+}
+
+
+static void opd_sigterm(int val __attribute__((unused)))
+{
+	signal_term = 1;
+}
+
+static void opd_sigchild(int val __attribute__((unused)))
+{
+	signal_child = 1;
+}
+ 
+
+static void opd_sigusr1(int val __attribute__((unused)))
+{
+	signal_usr1 = 1;
+}
+
+ 
+static void opd_sigusr2(int val __attribute__((unused)))
+{
+	signal_usr2 = 1;
+}
+
+
+static void opd_setup_signals(void)
+{
+	struct sigaction act;
+ 
+	act.sa_handler = opd_alarm;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+
+	if (sigaction(SIGALRM, &act, NULL)) {
+		perror("oprofiled: install of SIGALRM handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = opd_sighup;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	sigaddset(&act.sa_mask, SIGALRM);
+
+	if (sigaction(SIGHUP, &act, NULL)) {
+		perror("oprofiled: install of SIGHUP handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = opd_sigterm;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	sigaddset(&act.sa_mask, SIGTERM);
+
+	if (sigaction(SIGTERM, &act, NULL)) {
+		perror("oprofiled: install of SIGTERM handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = opd_sigchild;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	sigaddset(&act.sa_mask, SIGCHLD);
+
+	if (sigaction(SIGCHLD, &act, NULL)) {
+		perror("oprofiled: install of SIGCHLD handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = opd_sigusr1;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	sigaddset(&act.sa_mask, SIGTERM);
+
+	if (sigaction(SIGUSR1, &act, NULL)) {
+		perror("oprofiled: install of SIGUSR1 handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+
+	act.sa_handler = opd_sigusr2;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	sigaddset(&act.sa_mask, SIGTERM);
+
+	if (sigaction(SIGUSR2, &act, NULL)) {
+		perror("oprofiled: install of SIGUSR2 handler failed: ");
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+struct opd_hashed_name {
+	char * name;
+	struct list_head next;
+};
+
+
+static void add_image_filter(char const * name)
+{
+	size_t hash;
+	struct opd_hashed_name * elt = xmalloc(sizeof(struct opd_hashed_name));
+	elt->name = xmalloc(PATH_MAX);
+	if (!realpath(name, elt->name)) {
+		free(elt->name);
+		free(elt);
+		return;
+	}
+	hash = op_hash_string(elt->name);
+	verbprintf(vmisc, "Adding to image filter: \"%s\"\n", elt->name);
+	list_add(&elt->next, &images_filter[hash % OPD_IMAGE_FILTER_HASH_SIZE]);
+}
+
+
+static void opd_parse_image_filter(void)
+{
+	size_t i;
+	char const * last = binary_name_filter;
+	char const * cur = binary_name_filter;
+
+	if (!binary_name_filter)
+		return;
+
+	for (i = 0; i < OPD_IMAGE_FILTER_HASH_SIZE; ++i)
+		list_init(&images_filter[i]);
+
+	while ((cur = strchr(last, ',')) != NULL) {
+		char * tmp = op_xstrndup(last, cur - last);
+		add_image_filter(tmp);
+		free(tmp);
+		last = cur + 1;
+	}
+	add_image_filter(last);
+}
+
+
+int is_image_ignored(char const * name)
+{
+	size_t hash;
+	struct list_head * pos;
+
+	if (!binary_name_filter)
+		return 0;
+	
+	hash = op_hash_string(name);
+
+	list_for_each(pos, &images_filter[hash % OPD_IMAGE_FILTER_HASH_SIZE]) {
+		struct opd_hashed_name * hashed_name =
+			list_entry(pos, struct opd_hashed_name, next);
+		if (!strcmp(hashed_name->name, name))
+			return 0;
+	}
+
+	return 1;
+}
+
+
+/** return the int in the given oprofilefs file */
+int opd_read_fs_int(char const * path, char const * name, int fatal)
+{
+	char filename[PATH_MAX + 1];
+	snprintf(filename, PATH_MAX, "%s/%s", path, name);
+	return op_read_int_from_file(filename, fatal);
+}
+
+
+static void opd_handle_verbose_option(char const * name)
+{
+	if (!strcmp(name, "all")) {
+		vsfile = 1;
+		vsamples = 1;
+		varcs = 1;
+		vmodule = 1;
+		vmisc = 1;
+	} else if (!strcmp(name, "sfile")) {
+		vsfile = 1;
+	} else if (!strcmp(name, "arcs")) {
+		varcs = 1;
+	} else if (!strcmp(name, "samples")) {
+		vsamples = 1;
+	} else if (!strcmp(name, "module")) {
+		vmodule = 1;
+	} else if (!strcmp(name, "misc")) {
+		vmisc = 1;
+	} else {
+		fprintf(stderr, "unknown verbose options\n");
+		exit(EXIT_FAILURE);
+	}
+}
+
+static void opd_parse_verbose(void)
+{
+	char const * last = verbose;
+	char const * cur = verbose;
+
+	if (!verbose)
+		return;
+
+	while ((cur = strchr(last, ',')) != NULL) {
+		char * tmp = op_xstrndup(last, cur - last);
+		opd_handle_verbose_option(tmp);
+		free(tmp);
+		last = cur + 1;
+	}
+	opd_handle_verbose_option(last);
+}
+
+
+static void opd_options(int argc, char const * argv[])
+{
+	poptContext optcon;
+	char * tmp;
+
+	optcon = op_poptGetContext(NULL, argc, argv, options, 0);
+
+	if (showvers)
+		show_version(argv[0]);
+
+	opd_parse_verbose();
+
+	if (separate_kernel)
+		separate_lib = 1;
+
+	cpu_type = op_get_cpu_type();
+	op_nr_counters = op_get_nr_counters(cpu_type);
+
+	if (!no_vmlinux) {
+		if (!vmlinux || !strcmp("", vmlinux)) {
+			fprintf(stderr, "oprofiled: no vmlinux specified.\n");
+			poptPrintHelp(optcon, stderr, 0);
+			exit(EXIT_FAILURE);
+		}
+
+		/* canonicalise vmlinux filename. fix #637805 */
+		tmp = xmalloc(PATH_MAX);
+		if (realpath(vmlinux, tmp))
+			vmlinux = tmp;
+		else
+			free(tmp);
+
+		if (!kernel_range || !strcmp("", kernel_range)) {
+			fprintf(stderr, "oprofiled: no kernel VMA range specified.\n");
+			poptPrintHelp(optcon, stderr, 0);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	if (events == NULL) {
+		fprintf(stderr, "oprofiled: no events specified.\n");
+		poptPrintHelp(optcon, stderr, 0);
+		exit(EXIT_FAILURE);
+	}
+
+	if (!xenimage || !strcmp("", xenimage)) {
+		no_xen = 1;
+	} else {
+		no_xen = 0;
+
+		/* canonicalise xen image filename. */
+		tmp = xmalloc(PATH_MAX);
+		if (realpath(xenimage, tmp))
+			xenimage = tmp;
+		else
+			free(tmp);
+
+		if (!xen_range || !strcmp("", xen_range)) {
+			fprintf(stderr, "oprofiled: no Xen VMA range specified.\n");
+			poptPrintHelp(optcon, stderr, 0);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	opd_parse_events(events);
+
+	opd_parse_image_filter();
+
+	poptFreeContext(optcon);
+}
+
+
+/* determine what kernel we're running and which daemon
+ * to use
+ */
+static struct oprofiled_ops * get_ops(void)
+{
+	switch (op_get_interface()) {
+#ifndef ANDROID
+		case OP_INTERFACE_24:
+			printf("Using 2.4 OProfile kernel interface.\n");
+			return &opd_24_ops;
+#endif
+		case OP_INTERFACE_26:
+			printf("Using 2.6+ OProfile kernel interface.\n");
+			return &opd_26_ops;
+		default:
+			break;
+	}
+
+	fprintf(stderr, "Couldn't determine kernel version.\n");
+	exit(EXIT_FAILURE);
+	return NULL;
+}
+
+
+int main(int argc, char const * argv[])
+{
+	int err;
+	struct rlimit rlim = { 2048, 2048 };
+
+	opd_options(argc, argv);
+	init_op_config_dirs(session_dir);
+
+	opd_setup_signals();
+
+	err = setrlimit(RLIMIT_NOFILE, &rlim);
+	if (err)
+		perror("warning: could not set RLIMIT_NOFILE to 2048: ");
+
+	opd_write_abi();
+
+	opd_ops = get_ops();
+
+	opd_ops->init();
+
+	opd_go_daemon();
+
+	/* clean up every 10 minutes */
+	alarm(60 * 10);
+
+	if (op_write_lock_file(op_lock_file)) {
+		fprintf(stderr, "oprofiled: could not create lock file %s\n",
+			op_lock_file);
+		exit(EXIT_FAILURE);
+	}
+
+	opd_ops->start();
+
+	opd_ops->exit();
+
+	return 0;
+}
diff --git a/daemon/oprofiled.h b/daemon/oprofiled.h
new file mode 100644
index 0000000..b319df1
--- /dev/null
+++ b/daemon/oprofiled.h
@@ -0,0 +1,69 @@
+/**
+ * @file daemon/oprofiled.h
+ * Initialisation and setup
+ *
+ * @remark Copyright 2002, 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * Modified by Aravind Menon for Xen
+ * These modifications are:
+ * Copyright (C) 2005 Hewlett-Packard Co.
+ */
+
+#ifndef OPROFILED_H
+
+#include <signal.h>
+
+struct oprofiled_ops {
+	void (*init)(void);
+	void (*start)(void);
+	void (*exit)(void);
+};
+
+
+/**
+ * opd_open_logfile - open the log file
+ *
+ * Open the logfile on stdout and stderr. This function
+ * assumes that 1 and 2 are the lowest close()d file
+ * descriptors. Failure to open on either descriptor is
+ * a fatal error.
+ */
+void opd_open_logfile(void);
+
+ 
+/**
+ * is_image_ignored - check if we must ignore this image
+ * @param name the name to check
+ *
+ * Return true if the image should not be profiled
+ */
+int is_image_ignored(char const * name);
+
+/** return the int in the given oprofilefs file, error is fatal if !is_fatal */
+int opd_read_fs_int(char const * path, char const * name, int is_fatal);
+
+
+/** global variable positioned by signal handler */
+extern sig_atomic_t signal_alarm;
+extern sig_atomic_t signal_hup;
+extern sig_atomic_t signal_term;
+extern sig_atomic_t signal_child;
+extern sig_atomic_t signal_usr1;
+extern sig_atomic_t signal_usr2;
+
+extern unsigned int op_nr_counters;
+extern int separate_lib;
+extern int separate_kernel;
+extern int separate_thread;
+extern int separate_cpu;
+extern int no_vmlinux;
+extern char * vmlinux;
+extern char * kernel_range;
+extern int no_xen;
+extern char * xenimage;
+extern char * xen_range;
+
+#endif /* OPROFILED_H */
diff --git a/libabi/Android.mk b/libabi/Android.mk
new file mode 100644
index 0000000..3213c1e
--- /dev/null
+++ b/libabi/Android.mk
@@ -0,0 +1,14 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= op_abi.c
+
+LOCAL_MODULE := libabi
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/.. \
+	$(LOCAL_PATH)/../libdb \
+	$(LOCAL_PATH)/../libutil \
+	$(LOCAL_PATH)/../libop
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/libabi/abi.cpp b/libabi/abi.cpp
new file mode 100644
index 0000000..04a6b2d
--- /dev/null
+++ b/libabi/abi.cpp
@@ -0,0 +1,75 @@
+/**
+ * @file abi.cpp
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Graydon Hoare
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "abi.h"
+#include "op_abi.h"
+#include "odb.h"
+#include "op_sample_file.h"
+
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+
+typedef map<string, int> abi_map;
+typedef abi_map::const_iterator abi_iter;
+
+abi_exception::abi_exception(string const d) : desc(d) {}
+
+
+abi::abi()
+{
+	op_abi_entry const * entry = get_abi();
+	for ( ; entry->name != 0; ++entry)
+		slots[entry->name] = entry->offset;
+
+	slots["little_endian"] = op_little_endian();
+}
+
+
+int abi::need(string const key) const throw (abi_exception)
+{
+	if (slots.find(key) != slots.end())
+		return slots.find(key)->second;
+	else
+		throw abi_exception(string("missing ABI key: ") + key);
+}
+
+
+bool abi::operator==(abi const & other) const
+{
+	return slots == other.slots;
+}
+
+
+ostream & operator<<(ostream & o, abi const & abi)
+{
+	abi_iter i = abi.slots.begin();
+	abi_iter e = abi.slots.end();
+
+	for (; i != e; ++i)
+		o << i->first << " " << i->second << endl;
+
+	return o;
+}
+
+
+istream & operator>>(istream & i, abi & abi)
+{
+	string key;
+	int val;
+	abi.slots.clear();
+
+	while(i >> key >> val)
+		abi.slots[key] = val;
+
+	return i;
+}
diff --git a/libabi/abi.h b/libabi/abi.h
new file mode 100644
index 0000000..8b63e7f
--- /dev/null
+++ b/libabi/abi.h
@@ -0,0 +1,42 @@
+/**
+ * @file abi.h
+ *
+ * Contains internal ABI management class
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Graydon Hoare
+ */
+
+#ifndef OPROF_ABI_H
+#define OPROF_ABI_H
+ 
+#include <string>
+#include <map>
+#include <iosfwd>
+
+struct abi_exception : std::exception {
+	std::string const desc;
+ 
+	explicit abi_exception(std::string const d);
+ 
+	~abi_exception() throw() {}
+};
+
+
+class abi {
+public:
+	abi();
+
+	int need(std::string const key) const throw (abi_exception);
+
+	bool operator==(abi const & other) const;
+	friend std::ostream & operator<<(std::ostream & o, abi const & abi);
+	friend std::istream & operator>>(std::istream & i, abi & abi);
+
+private:
+	std::map<std::string, int> slots;
+};
+
+#endif // OPROF_ABI_H
diff --git a/libabi/op_abi.c b/libabi/op_abi.c
new file mode 100644
index 0000000..283e3ff
--- /dev/null
+++ b/libabi/op_abi.c
@@ -0,0 +1,94 @@
+/**
+ * @file op_abi.c
+ * This file contains a simple C interface to the ABI-describing functionality,
+ * the majority of which is implemented in C++. This is the file which is 
+ * intended for use in files outside the /libabi directory.
+ *
+ * @remark Copyright 2002, 2005 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Graydon Hoare
+ * @author Philippe Elie
+ */
+
+#include "op_abi.h"
+#include "odb.h"
+#include "op_sample_file.h"
+
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+static struct op_abi_entry const abi_entries[] = {
+	{ "sizeof_double", sizeof(double) },
+	{ "sizeof_time_t", sizeof(time_t) },
+	{ "sizeof_u8", sizeof(u8) },
+	{ "sizeof_u32", sizeof(u32) },
+	{ "sizeof_int", sizeof(int) },
+	{ "sizeof_unsigned_int", sizeof(unsigned int) },
+	{ "sizeof_odb_key_t", sizeof(odb_key_t) },
+	{ "sizeof_odb_index_t", sizeof(odb_index_t) },
+	{ "sizeof_odb_value_t", sizeof(odb_value_t) },
+	{ "sizeof_odb_node_nr_t", sizeof(odb_node_nr_t) },
+	{ "sizeof_odb_descr_t", sizeof(odb_descr_t) },
+	{ "sizeof_odb_node_t", sizeof(odb_node_t) },
+	{ "sizeof_struct_opd_header", sizeof(struct opd_header) },
+	
+	{ "offsetof_node_key", offsetof(odb_node_t, key) },
+	{ "offsetof_node_value", offsetof(odb_node_t, value) },
+	{ "offsetof_node_next", offsetof(odb_node_t, next) },
+	
+	{ "offsetof_descr_size", offsetof(odb_descr_t, size) },
+	{ "offsetof_descr_current_size", offsetof(odb_descr_t, current_size) },
+	
+	{ "offsetof_header_magic", offsetof(struct opd_header, magic) },
+	{ "offsetof_header_version", offsetof(struct opd_header, version) },
+	{ "offsetof_header_cpu_type", offsetof(struct opd_header, cpu_type) },
+	{ "offsetof_header_ctr_event", offsetof(struct opd_header, ctr_event) },
+	{ "offsetof_header_ctr_um", offsetof(struct opd_header, ctr_um) },
+	{ "offsetof_header_ctr_count", offsetof(struct opd_header, ctr_count) },
+	{ "offsetof_header_is_kernel", offsetof(struct opd_header, is_kernel) },
+	{ "offsetof_header_cpu_speed", offsetof(struct opd_header, cpu_speed) },
+	{ "offsetof_header_mtime", offsetof(struct opd_header, mtime) },
+	{ "offsetof_header_cg_to_is_kernel", offsetof(struct opd_header, cg_to_is_kernel), },
+	{ "offsetof_header_anon_start", offsetof(struct opd_header, anon_start) },
+	{ "offsetof_header_cg_to_anon_start", offsetof(struct opd_header, cg_to_anon_start) },
+	
+	{ NULL, 0 },
+};
+
+
+struct op_abi_entry const * get_abi(void)
+{
+	return abi_entries;
+}
+
+
+int op_little_endian(void)
+{
+	unsigned int probe = 0xff;
+	size_t sz = sizeof(unsigned int);
+	unsigned char * probe_byte = (unsigned char *)&probe;
+
+	assert(probe_byte[0] == 0xff || probe_byte[sz - 1] == 0xff);
+
+	return probe_byte[0] == 0xff;
+}
+
+
+int op_write_abi_to_file(char const * abi_file)
+{
+	FILE * fp;
+	struct op_abi_entry const * abi_entry;
+
+	if ((fp = fopen(abi_file, "w")) == NULL)
+		return 0;
+
+	for (abi_entry = get_abi() ; abi_entry->name != NULL; ++abi_entry)
+		fprintf(fp, "%s %u\n", abi_entry->name, abi_entry->offset);
+	fprintf(fp, "little_endian %d\n", op_little_endian());
+
+	fclose(fp);
+
+	return 1;
+}
diff --git a/libabi/op_abi.h b/libabi/op_abi.h
new file mode 100644
index 0000000..fbd337b
--- /dev/null
+++ b/libabi/op_abi.h
@@ -0,0 +1,43 @@
+/**
+ * @file op_abi.h
+ * This file contains a simple C interface to the ABI-describing functionality,
+ * the majority of which is implemented in C++. this is the file which is 
+ * intended for use in files outside the /libabi directory.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Graydon Hoare
+ * @author Philippe Elie
+ */
+
+#ifndef OP_ABI_H
+#define OP_ABI_H
+
+struct op_abi_entry {
+	char const * name;
+	/// offset or size of the named entry
+	int offset;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// return array is terminated by a NULL entry in name field
+struct op_abi_entry const * get_abi(void);
+
+/// return non zero if the abi is little endian
+int op_little_endian(void);
+
+/**
+ * Write current abi to file.
+ * return 1 on success, 0 on failure
+ */
+int op_write_abi_to_file(char const * abi_file);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // OP_ABI_H
diff --git a/libabi/opimport.cpp b/libabi/opimport.cpp
new file mode 100644
index 0000000..57f74a7
--- /dev/null
+++ b/libabi/opimport.cpp
@@ -0,0 +1,225 @@
+/**
+ * @file opimport.cpp
+ * Import sample files from other ABI
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Graydon Hoare
+ */
+
+#include "abi.h"
+#include "odb.h"
+#include "popt_options.h"
+#include "op_sample_file.h"
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <cassert>
+#include <cstring>
+#include <cstdlib>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <cstdlib>
+#include <cstring>
+
+using namespace std;
+
+namespace {
+	string output_filename;
+	string abi_filename;
+	bool verbose;
+	bool force;
+};
+
+
+popt::option options_array[] = {
+	popt::option(verbose, "verbose", 'V', "verbose output"),
+	popt::option(output_filename, "output", 'o', "output to file", "filename"),
+	popt::option(abi_filename, "abi", 'a', "abi description", "filename"),
+	popt::option(force, "force", 'f', "force conversion, even if identical")
+};
+
+
+struct extractor {
+
+	abi const & theabi;
+
+	unsigned char const * begin;
+	unsigned char const * end;
+	bool little_endian;
+
+	explicit
+	extractor(abi const & a, unsigned char const * src, size_t len)
+		: theabi(a), begin(src), end(src + len) {
+		little_endian = theabi.need(string("little_endian")) == 1;
+		if (verbose) {
+			cerr << "source byte order is: "
+			     << string(little_endian ? "little" : "big")
+			     << " endian" << endl;
+		}
+	}
+
+	template <typename T>
+	void extract(T & targ, void const * src_,
+	             char const * sz, char const * off);
+};
+
+
+template <typename T>
+void extractor::extract(T & targ, void const * src_,
+                        char const * sz, char const * off)
+{
+	unsigned char const * src = static_cast<unsigned char const *>(src_)
+		+ theabi.need(off);
+	size_t nbytes = theabi.need(sz);
+	
+	if (nbytes == 0)
+		return;
+	
+	assert(nbytes <= sizeof(T));
+	assert(src >= begin);
+	assert(src + nbytes <= end);
+	
+	if (verbose)
+		cerr << hex << "get " << sz << " = " << nbytes
+		     << " bytes @ " << off << " = " << (src - begin)
+		     << " : ";
+
+	targ = 0;
+	if (little_endian)
+		while(nbytes--)
+			targ = (targ << 8) | src[nbytes];
+	else
+		for(size_t i = 0; i < nbytes; ++i)
+			targ = (targ << 8) | src[i];
+	
+	if (verbose)
+		cerr << " = " << targ << endl;
+}
+
+
+void import_from_abi(abi const & abi, void const * srcv,
+                     size_t len, odb_t * dest) throw (abi_exception)
+{
+	struct opd_header * head =
+		static_cast<opd_header *>(odb_get_data(dest));
+	unsigned char const * src = static_cast<unsigned char const *>(srcv);
+	unsigned char const * const begin = src;
+	extractor ext(abi, src, len);	
+
+	memcpy(head->magic, src + abi.need("offsetof_header_magic"), 4);
+
+	// begin extracting opd header
+	ext.extract(head->version, src, "sizeof_u32", "offsetof_header_version");
+	ext.extract(head->cpu_type, src, "sizeof_u32", "offsetof_header_cpu_type");
+	ext.extract(head->ctr_event, src, "sizeof_u32", "offsetof_header_ctr_event");
+	ext.extract(head->ctr_um, src, "sizeof_u32", "offsetof_header_ctr_um");
+	ext.extract(head->ctr_count, src, "sizeof_u32", "offsetof_header_ctr_count");
+	ext.extract(head->is_kernel, src, "sizeof_u32", "offsetof_header_is_kernel");
+	// "double" extraction is unlikely to work
+	head->cpu_speed = 0.0;
+	ext.extract(head->mtime, src, "sizeof_time_t", "offsetof_header_mtime");
+	ext.extract(head->cg_to_is_kernel, src, "sizeof_u32",
+		"offsetof_header_cg_to_is_kernel");
+	ext.extract(head->anon_start, src, "sizeof_u32",
+		"offsetof_header_anon_start");
+	ext.extract(head->cg_to_anon_start, src, "sizeof_u32",
+		"offsetof_header_cg_to_anon_start");
+	src += abi.need("sizeof_struct_opd_header");
+	// done extracting opd header
+
+	// begin extracting necessary parts of descr
+	odb_node_nr_t node_nr;
+	ext.extract(node_nr, src, "sizeof_odb_node_nr_t", "offsetof_descr_current_size");
+	src += abi.need("sizeof_odb_descr_t");
+	// done extracting descr
+
+	// skip node zero, it is reserved and contains nothing usefull
+	src += abi.need("sizeof_odb_node_t");
+
+	// begin extracting nodes
+	unsigned int step = abi.need("sizeof_odb_node_t");
+	if (verbose)
+		cerr << "extracting " << node_nr << " nodes of " << step << " bytes each " << endl;
+
+	assert(src + (node_nr * step) <= begin + len);
+
+	for (odb_node_nr_t i = 1 ; i < node_nr ; ++i, src += step) {
+		odb_key_t key;
+		odb_value_t val;
+		ext.extract(key, src, "sizeof_odb_key_t", "offsetof_node_key");
+		ext.extract(val, src, "sizeof_odb_value_t", "offsetof_node_value");
+		int rc = odb_add_node(dest, key, val);
+		if (rc != EXIT_SUCCESS) {
+			cerr << strerror(rc) << endl;
+			exit(EXIT_FAILURE);
+		}
+	}
+	// done extracting nodes
+}
+
+
+int main(int argc, char const ** argv)
+{
+
+	vector<string> inputs;
+	popt::parse_options(argc, argv, inputs);
+
+	if (inputs.size() != 1) {
+		cerr << "error: must specify exactly 1 input file" << endl;
+		exit(1);
+	}
+
+	abi current_abi, input_abi;
+
+	{
+		ifstream abi_file(abi_filename.c_str());
+		if (!abi_file) {
+			cerr << "error: cannot open abi file "
+			     << abi_filename << endl;
+			exit(1);
+		}
+		abi_file >> input_abi;
+	}
+
+	if (!force && current_abi == input_abi) {
+		cerr << "input abi is identical to native. "
+		     << "no conversion necessary." << endl;
+		exit(1);
+	}
+
+	int in_fd;
+	struct stat statb;
+	void * in;
+	odb_t dest;
+	int rc;
+
+	assert((in_fd = open(inputs[0].c_str(), O_RDONLY)) > 0);		
+	assert(fstat(in_fd, &statb) == 0);
+	assert((in = mmap(0, statb.st_size, PROT_READ,
+			  MAP_PRIVATE, in_fd, 0)) != (void *)-1);
+
+	rc = odb_open(&dest, output_filename.c_str(), ODB_RDWR,
+		      sizeof(struct opd_header));
+	if (rc) {
+		cerr << "odb_open() fail:\n"
+		     << strerror(rc) << endl;
+		exit(EXIT_FAILURE);
+	}
+
+	try {
+		import_from_abi(input_abi, in, statb.st_size, &dest);
+	} catch (abi_exception & e) {
+		cerr << "caught abi exception: " << e.desc << endl;
+	}
+
+	odb_close(&dest);
+
+	assert(munmap(in, statb.st_size) == 0);
+}
diff --git a/libdb/Android.mk b/libdb/Android.mk
new file mode 100644
index 0000000..1594fe8
--- /dev/null
+++ b/libdb/Android.mk
@@ -0,0 +1,17 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	db_debug.c \
+	db_insert.c \
+	db_manage.c \
+	db_stat.c \
+	db_travel.c
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/.. \
+	$(LOCAL_PATH)/../libutil
+
+LOCAL_MODULE := libdb
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/libdb/db_debug.c b/libdb/db_debug.c
new file mode 100644
index 0000000..0575570
--- /dev/null
+++ b/libdb/db_debug.c
@@ -0,0 +1,132 @@
+/**
+ * @file db_debug.c
+ * Debug routines for libdb
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "odb.h"
+
+static int check_circular_list(odb_data_t const * data)
+{
+	odb_node_nr_t pos;
+	int do_abort = 0;
+	unsigned char * bitmap = malloc(data->descr->current_size);
+	memset(bitmap, '\0', data->descr->current_size);
+
+	for (pos = 0 ; pos < data->descr->size * BUCKET_FACTOR ; ++pos) {
+
+		odb_index_t index = data->hash_base[pos];
+		if (index && !do_abort) {
+			while (index) {
+				if (bitmap[index])
+					do_abort = 1;
+
+				bitmap[index] = 1;
+				index = data->node_base[index].next;
+			}
+		}
+
+		if (do_abort) {
+			printf("circular list detected size: %d\n",
+			       data->descr->current_size);
+
+			memset(bitmap, '\0', data->descr->current_size);
+
+			index = data->hash_base[pos];
+			while (index) {
+				printf("%d ", index);
+				if (bitmap[index])
+					exit(1);
+
+				bitmap[index] = 1;
+				index = data->node_base[index].next;
+			}
+		}
+
+		/* purely an optimization: intead of memset the map reset only
+		 * the needed part: not my use to optimize test but here the
+		 * test was so slow it was useless */
+		index = data->hash_base[pos];
+		while (index) {
+			bitmap[index] = 1;
+			index = data->node_base[index].next;
+		}
+	}
+
+	free(bitmap);
+
+	return do_abort;
+}
+
+static int check_redundant_key(odb_data_t const * data, odb_key_t max)
+{
+	odb_node_nr_t pos;
+
+	unsigned char * bitmap = malloc(max + 1);
+	memset(bitmap, '\0', max + 1);
+
+	for (pos = 1 ; pos < data->descr->current_size ; ++pos) {
+		if (bitmap[data->node_base[pos].key]) {
+			printf("redundant key found %lld\n",
+			       (unsigned long long)data->node_base[pos].key);
+			return 1;
+		}
+		bitmap[data->node_base[pos].key] = 1;
+	}
+	free(bitmap);
+
+	return 0;
+}
+
+int odb_check_hash(odb_t const * odb)
+{
+	odb_node_nr_t pos;
+	odb_node_nr_t nr_node = 0;
+	odb_node_nr_t nr_node_out_of_bound = 0;
+	int ret = 0;
+	odb_key_t max = 0;
+	odb_data_t * data = odb->data;
+
+	for (pos = 0 ; pos < data->descr->size * BUCKET_FACTOR ; ++pos) {
+		odb_index_t index = data->hash_base[pos];
+		while (index) {
+			if (index >= data->descr->current_size) {
+				nr_node_out_of_bound++;
+				break;
+			}
+			++nr_node;
+
+			if (data->node_base[index].key > max)
+				max = data->node_base[index].key;
+
+			index = data->node_base[index].next;
+		}
+	}
+
+	if (nr_node != data->descr->current_size - 1) {
+		printf("hash table walk found %d node expect %d node\n",
+		       nr_node, data->descr->current_size - 1);
+		ret = 1;
+	}
+
+	if (nr_node_out_of_bound) {
+		printf("out of bound node index: %d\n", nr_node_out_of_bound);
+		ret = 1;
+	}
+
+	if (ret == 0)
+		ret = check_circular_list(data);
+
+	if (ret == 0)
+		ret = check_redundant_key(data, max);
+
+	return ret;
+}
diff --git a/libdb/db_insert.c b/libdb/db_insert.c
new file mode 100644
index 0000000..018c294
--- /dev/null
+++ b/libdb/db_insert.c
@@ -0,0 +1,102 @@
+/**
+ * @file db_insert.c
+ * Inserting a key-value pair into a DB
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "odb.h"
+
+
+static inline int add_node(odb_data_t * data, odb_key_t key, odb_value_t value)
+{
+	odb_index_t new_node;
+	odb_node_t * node;
+	odb_index_t index;
+
+	/* no locking is necessary: iteration interface retrieve data through
+	 * the node_base array, we doesn't increase current_size now but it's
+	 * done by odb_commit_reservation() so the new slot is visible only
+	 * after the increment
+	 */
+	if (data->descr->current_size >= data->descr->size) {
+		if (odb_grow_hashtable(data))
+			return EINVAL;
+	}
+	new_node = data->descr->current_size;
+
+	node = &data->node_base[new_node];
+	node->value = value;
+	node->key = key;
+
+	index = odb_do_hash(data, key);
+	node->next = data->hash_base[index];
+	data->hash_base[index] = new_node;
+
+	/* FIXME: we need wrmb() here */
+	odb_commit_reservation(data);
+
+	return 0;
+}
+
+int odb_update_node(odb_t * odb, odb_key_t key)
+{
+	odb_index_t index;
+	odb_node_t * node;
+	odb_data_t * data;
+
+	data = odb->data;
+	index = data->hash_base[odb_do_hash(data, key)];
+	while (index) {
+		node = &data->node_base[index];
+		if (node->key == key) {
+			if (node->value + 1 != 0) {
+				node->value += 1;
+			} else {
+				/* post profile tools must handle overflow */
+				/* FIXME: the tricky way will be just to add
+				 * a goto to jump right before the return
+				 * add_node(), in this way we no longer can
+				 * overflow. It'll work because new node are
+				 * linked at the start of the node list for
+				 * this bucket so this loop will see first a
+				 * non overflowed node if one exist. When we
+				 * grow the hashtable the most recently
+				 * allocated node for this key will be setup
+				 * last, so again it'll be linked at start of
+				 * the list. pp tools looke like ok with this
+				 * change.
+				 *
+				 * This change doesn't involve any file format
+				 * change but perhaps it's a bit hacky to do
+				 * this w/o bumping the sample file format
+				 * version. The drawback of this is the added
+				 * node are additive not multiplicative.
+				 * (multiplicative as if we add more bits to
+				 * store a value)
+				 */
+			}
+			return 0;
+		}
+
+		index = node->next;
+	}
+
+	return add_node(data, key, 1);
+}
+
+
+int odb_add_node(odb_t * odb, odb_key_t key, odb_value_t value)
+{
+	return add_node(odb->data, key, value);
+}
diff --git a/libdb/db_manage.c b/libdb/db_manage.c
new file mode 100644
index 0000000..d8a6fcb
--- /dev/null
+++ b/libdb/db_manage.c
@@ -0,0 +1,311 @@
+/**
+ * @file db_manage.c
+ * Management of a DB file
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#ifndef ANDROID
+#include <sys/fcntl.h>
+#else
+#include <fcntl.h>
+#endif
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "odb.h"
+#include "op_string.h"
+#include "op_libiberty.h"
+
+ 
+static __inline odb_descr_t * odb_to_descr(odb_data_t * data)
+{
+	return (odb_descr_t *)(((char*)data->base_memory) + data->sizeof_header);
+}
+
+ 
+static __inline odb_node_t * odb_to_node_base(odb_data_t * data)
+{
+	return (odb_node_t *)(((char *)data->base_memory) + data->offset_node);
+}
+
+ 
+static __inline odb_index_t * odb_to_hash_base(odb_data_t * data)
+{
+	return (odb_index_t *)(((char *)data->base_memory) + 
+				data->offset_node +
+				(data->descr->size * sizeof(odb_node_t)));
+}
+
+ 
+/**
+ * return the number of bytes used by hash table, node table and header.
+ */
+static unsigned int tables_size(odb_data_t const * data, odb_node_nr_t node_nr)
+{
+	size_t size;
+
+	size = node_nr * (sizeof(odb_index_t) * BUCKET_FACTOR);
+	size += node_nr * sizeof(odb_node_t);
+	size += data->offset_node;
+
+	return size;
+}
+
+
+int odb_grow_hashtable(odb_data_t * data)
+{
+	unsigned int old_file_size;
+	unsigned int new_file_size;
+	unsigned int pos;
+	void * new_map;
+
+	old_file_size = tables_size(data, data->descr->size);
+	new_file_size = tables_size(data, data->descr->size * 2);
+
+	if (ftruncate(data->fd, new_file_size))
+		return 1;
+
+	new_map = mremap(data->base_memory,
+			 old_file_size, new_file_size, MREMAP_MAYMOVE);
+
+	if (new_map == MAP_FAILED)
+		return 1;
+
+	data->base_memory = new_map;
+	data->descr = odb_to_descr(data);
+	data->descr->size *= 2;
+	data->node_base = odb_to_node_base(data);
+	data->hash_base = odb_to_hash_base(data);
+	data->hash_mask = (data->descr->size * BUCKET_FACTOR) - 1;
+
+	/* rebuild the hash table, node zero is never used. This works
+	 * because layout of file is node table then hash table,
+	 * sizeof(node) > sizeof(bucket) and when we grow table we
+	 * double size ==> old hash table and new hash table can't
+	 * overlap so on the new hash table is entirely in the new
+	 * memory area (the grown part) and we know the new hash
+	 * hash table is zeroed. That's why we don't need to zero init
+	 * the new table */
+	/* OK: the above is not exact
+	 * if BUCKET_FACTOR < sizeof(bd_node_t) / sizeof(bd_node_nr_t)
+	 * all things are fine and we don't need to init the hash
+	 * table because in this case the new hash table is completely
+	 * inside the new growed part. Avoiding to touch this memory is
+	 * useful.
+	 */
+#if 0
+	for (pos = 0 ; pos < data->descr->size*BUCKET_FACTOR ; ++pos)
+		data->hash_base[pos] = 0;
+#endif
+
+	for (pos = 1; pos < data->descr->current_size; ++pos) {
+		odb_node_t * node = &data->node_base[pos];
+		size_t index = odb_do_hash(data, node->key);
+		node->next = data->hash_base[index];
+		data->hash_base[index] = pos;
+	}
+
+	return 0;
+}
+
+
+void odb_init(odb_t * odb)
+{
+	odb->data = NULL;
+}
+
+
+/* the default number of page, calculated to fit in 4096 bytes */
+#define DEFAULT_NODE_NR(offset_node)	128
+#define FILES_HASH_SIZE                 512
+
+static struct list_head files_hash[FILES_HASH_SIZE];
+
+
+static void init_hash()
+{
+	size_t i;
+	for (i = 0; i < FILES_HASH_SIZE; ++i)
+		list_init(&files_hash[i]);
+}
+
+
+static odb_data_t *
+find_samples_data(size_t hash, char const * filename)
+{
+	struct list_head * pos;
+
+	/* FIXME: maybe an initial init routine ? */
+	if (files_hash[0].next == NULL) {
+		init_hash();
+		return NULL;
+	}
+
+	list_for_each(pos, &files_hash[hash]) {
+		odb_data_t * entry = list_entry(pos, odb_data_t, list);
+		if (strcmp(entry->filename, filename) == 0)
+			return entry;
+	}
+
+	return NULL;
+}
+
+
+int odb_open(odb_t * odb, char const * filename, enum odb_rw rw,
+	     size_t sizeof_header)
+{
+	struct stat stat_buf;
+	odb_node_nr_t nr_node;
+	odb_data_t * data;
+	size_t hash;
+	int err = 0;
+
+	int flags = (rw == ODB_RDWR) ? (O_CREAT | O_RDWR) : O_RDONLY;
+	int mmflags = (rw == ODB_RDWR) ? (PROT_READ | PROT_WRITE) : PROT_READ;
+
+	hash = op_hash_string(filename) % FILES_HASH_SIZE;
+	data = find_samples_data(hash, filename);
+	if (data) {
+		odb->data = data;
+		data->ref_count++;
+		return 0;
+	}
+
+	data = xmalloc(sizeof(odb_data_t));
+	memset(data, '\0', sizeof(odb_data_t));
+	list_init(&data->list);
+	data->offset_node = sizeof_header + sizeof(odb_descr_t);
+	data->sizeof_header = sizeof_header;
+	data->ref_count = 1;
+	data->filename = xstrdup(filename);
+
+	data->fd = open(filename, flags, 0644);
+	if (data->fd < 0) {
+		err = errno;
+		goto out;
+	}
+
+	if (fstat(data->fd, &stat_buf)) {
+		err = errno;
+		goto fail;
+	}
+
+	if (stat_buf.st_size == 0) {
+		size_t file_size;
+
+		if (rw == ODB_RDONLY) {
+			err = EIO;
+			goto fail;
+		}
+
+		nr_node = DEFAULT_NODE_NR(data->offset_node);
+
+		file_size = tables_size(data, nr_node);
+		if (ftruncate(data->fd, file_size)) {
+			err = errno;
+			goto fail;
+		}
+	} else {
+		/* Calculate nr node allowing a sanity check later */
+		nr_node = (stat_buf.st_size - data->offset_node) /
+			((sizeof(odb_index_t) * BUCKET_FACTOR) + sizeof(odb_node_t));
+	}
+
+	data->base_memory = mmap(0, tables_size(data, nr_node), mmflags,
+				MAP_SHARED, data->fd, 0);
+
+	if (data->base_memory == MAP_FAILED) {
+		err = errno;
+		goto fail;
+	}
+
+	data->descr = odb_to_descr(data);
+
+	if (stat_buf.st_size == 0) {
+		data->descr->size = nr_node;
+		/* page zero is not used */
+		data->descr->current_size = 1;
+	} else {
+		/* file already exist, sanity check nr node */
+		if (nr_node != data->descr->size) {
+			err = EINVAL;
+			goto fail_unmap;
+		}
+	}
+
+	data->hash_base = odb_to_hash_base(data);
+	data->node_base = odb_to_node_base(data);
+	data->hash_mask = (data->descr->size * BUCKET_FACTOR) - 1;
+
+	list_add(&data->list, &files_hash[hash]);
+	odb->data = data;
+out:
+	return err;
+fail_unmap:
+	munmap(data->base_memory, tables_size(data, nr_node));
+fail:
+	close(data->fd);
+	free(data->filename);
+	free(data);
+	odb->data = NULL;
+	goto out;
+}
+
+
+void odb_close(odb_t * odb)
+{
+	odb_data_t * data = odb->data;
+
+	if (data) {
+		data->ref_count--;
+		if (data->ref_count == 0) {
+			size_t size = tables_size(data, data->descr->size);
+			list_del(&data->list);
+			munmap(data->base_memory, size);
+			if (data->fd >= 0)
+				close(data->fd);
+			free(data->filename);
+			free(data);
+			odb->data = NULL;
+		}
+	}
+}
+
+
+int odb_open_count(odb_t const * odb)
+{
+	if (!odb->data)
+		return 0;
+	return odb->data->ref_count;
+}
+
+
+void * odb_get_data(odb_t * odb)
+{
+	return odb->data->base_memory;
+}
+
+
+void odb_sync(odb_t const * odb)
+{
+	odb_data_t * data = odb->data;
+	size_t size;
+
+	if (!data)
+		return;
+
+	size = tables_size(data, data->descr->size);
+	msync(data->base_memory, size, MS_ASYNC);
+}
diff --git a/libdb/db_stat.c b/libdb/db_stat.c
new file mode 100644
index 0000000..6d29e9a
--- /dev/null
+++ b/libdb/db_stat.c
@@ -0,0 +1,88 @@
+/**
+ * @file db_stat.c
+ * Statistics routines for libdb
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "odb.h"
+#include "op_types.h"
+
+/// hold various statistics data for a db file
+struct odb_hash_stat_t {
+	odb_node_nr_t node_nr;			/**< allocated node number */
+	odb_node_nr_t used_node_nr;		/**< in use node number */
+	count_type    total_count;		/**< cumulated samples count */
+	odb_index_t   hash_table_size;		/**< hash table entry number */
+	odb_node_nr_t max_list_length;		/**< worst case   */
+	double       average_list_length;	/**< average case */
+	/* do we need variance ? */
+};
+
+odb_hash_stat_t * odb_hash_stat(odb_t const * odb)
+{
+	size_t max_length = 0;
+	double total_length = 0.0;
+	size_t nr_non_empty_list = 0;
+	size_t pos;
+	odb_data_t * data = odb->data;
+
+	odb_hash_stat_t * result = calloc(1, sizeof(odb_hash_stat_t));
+	if (!result) {
+		fprintf(stderr, "not enough memory\n");
+		exit(EXIT_FAILURE);
+	}
+
+	result->node_nr = data->descr->size;
+	result->used_node_nr = data->descr->current_size;
+	result->hash_table_size = data->descr->size * BUCKET_FACTOR;
+
+	/* FIXME: I'm dubious if this do right statistics for hash table
+	 * efficiency check */
+
+	for (pos = 0 ; pos < result->hash_table_size ; ++pos) {
+		size_t cur_length = 0;
+		size_t index = data->hash_base[pos];
+		while (index) {
+			result->total_count += data->node_base[index].value;
+			index = data->node_base[index].next;
+			++cur_length;
+		}
+
+		if (cur_length > max_length)
+			max_length = cur_length;
+
+		if (cur_length) {
+			total_length += cur_length;
+			++nr_non_empty_list;
+		}
+	}
+
+	result->max_list_length = max_length;
+	result->average_list_length = total_length / nr_non_empty_list;
+
+	return result;
+}
+
+
+void odb_hash_display_stat(odb_hash_stat_t const * stat)
+{
+	printf("total node number:   %d\n", stat->node_nr);
+	printf("total used node:     %d\n", stat->used_node_nr);
+	printf("total count:         %llu\n", stat->total_count);
+	printf("hash table size:     %d\n", stat->hash_table_size);
+	printf("greater list length: %d\n", stat->max_list_length);
+	printf("average non empty list length: %2.4f\n", stat->average_list_length);
+}
+
+
+void odb_hash_free_stat(odb_hash_stat_t * stat)
+{
+	free(stat);
+}
diff --git a/libdb/db_travel.c b/libdb/db_travel.c
new file mode 100644
index 0000000..3ed467b
--- /dev/null
+++ b/libdb/db_travel.c
@@ -0,0 +1,18 @@
+/**
+ * @file db_travel.c
+ * Inspection of a DB
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#include "odb.h"
+
+odb_node_t * odb_get_iterator(odb_t const * odb, odb_node_nr_t * nr)
+{
+	/* node zero is unused */
+	*nr = odb->data->descr->current_size - 1;
+	return odb->data->node_base + 1;
+}
diff --git a/libdb/odb.h b/libdb/odb.h
new file mode 100644
index 0000000..c190b57
--- /dev/null
+++ b/libdb/odb.h
@@ -0,0 +1,223 @@
+/**
+ * @file odb.h
+ * This file contains various definitions and interface for management
+ * of in-memory, through mmaped file, growable hash table, that stores
+ * sample files.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#ifndef ODB_HASH_H
+#define ODB_HASH_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "op_list.h"
+
+/** the type of key. 64-bit because CG needs 32-bit pair {from,to} */
+typedef uint64_t odb_key_t;
+/** the type of an information in the database */
+typedef unsigned int odb_value_t;
+/** the type of index (node number), list are implemented through index */
+typedef unsigned int odb_index_t;
+/** the type store node number */
+typedef odb_index_t odb_node_nr_t;
+/** store the hash mask, hash table size are always power of two */
+typedef odb_index_t odb_hash_mask_t;
+
+/* there is (bucket factor * nr node) entry in hash table, this can seem
+ * excessive but hash coding eip don't give a good distributions and our
+ * goal is to get a O(1) amortized insert time. bucket factor must be a
+ * power of two. FIXME: see big comment in odb_hash_add_node, you must
+ * re-enable zeroing hash table if BUCKET_FACTOR > 2 (roughly exact, you
+ * want to read the comment in odb_hash_add_node() if you tune this define)
+ */
+#define BUCKET_FACTOR 1
+
+/** a db hash node */
+typedef struct {
+	odb_key_t key;			/**< eip */
+	odb_value_t value;		/**< samples count */
+	odb_index_t next;		/**< next entry for this bucket */
+} odb_node_t;
+
+/** the minimal information which must be stored in the file to reload
+ * properly the data base, following this header is the node array then
+ * the hash table (when growing we avoid to copy node array)
+ */
+typedef struct {
+	odb_node_nr_t size;		/**< in node nr (power of two) */
+	odb_node_nr_t current_size;	/**< nr used node + 1, node 0 unused */
+	int padding[6];			/**< for padding and future use */
+} odb_descr_t;
+
+/** a "database". this is an in memory only description.
+ *
+ * We allow to manage a database inside a mapped file with an "header" of
+ * unknown size so odb_open get a parameter to specify the size of this header.
+ * A typical use is:
+ *
+ * struct header { int etc; ... };
+ * odb_open(&hash, filename, ODB_RW, sizeof(header));
+ * so on this library have no dependency on the header type.
+ *
+ * the internal memory layout from base_memory is:
+ *  the unknown header (sizeof_header)
+ *  odb_descr_t
+ *  the node array: (descr->size * sizeof(odb_node_t) entries
+ *  the hash table: array of odb_index_t indexing the node array 
+ *    (descr->size * BUCKET_FACTOR) entries
+ */
+typedef struct odb_data {
+	odb_node_t * node_base;		/**< base memory area of the page */
+	odb_index_t * hash_base;	/**< base memory of hash table */
+	odb_descr_t * descr;		/**< the current state of database */
+	odb_hash_mask_t hash_mask;	/**< == descr->size - 1 */
+	unsigned int sizeof_header;	/**< from base_memory to odb header */
+	unsigned int offset_node;	/**< from base_memory to node array */
+	void * base_memory;		/**< base memory of the maped memory */
+	int fd;				/**< mmaped memory file descriptor */
+	char * filename;                /**< full path name of sample file */
+	int ref_count;                  /**< reference count */
+	struct list_head list;          /**< hash bucket list */
+} odb_data_t;
+
+typedef struct {
+	odb_data_t * data;
+} odb_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* db_manage.c */
+
+/** how to open the DB file */
+enum odb_rw {
+	ODB_RDONLY = 0,	/**< open for read only */
+	ODB_RDWR = 1	/**< open for read and/or write */
+};
+
+/**
+ * odb_init - initialize a DB file
+ * @param odb the DB file to init
+ */
+void odb_init(odb_t * odb);
+
+/**
+ * odb_open - open a DB file
+ * @param odb the data base object to setup
+ * @param filename the filename where go the maped memory
+ * @param rw \enum ODB_RW if opening for writing, else \enum ODB_RDONLY
+ * @param sizeof_header size of the file header if any
+ *
+ * The sizeof_header parameter allows the data file to have a header
+ * at the start of the file which is skipped.
+ * odb_open() always preallocate a few number of pages.
+ * returns 0 on success, errno on failure
+ */
+int odb_open(odb_t * odb, char const * filename,
+             enum odb_rw rw, size_t sizeof_header);
+
+/** Close the given ODB file */
+void odb_close(odb_t * odb);
+
+/** return the number of times this sample file is open */
+int odb_open_count(odb_t const * odb);
+
+/** return the start of the mapped data */
+void * odb_get_data(odb_t * odb);
+
+/** issue a msync on the used size of the mmaped file */
+void odb_sync(odb_t const * odb);
+
+/**
+ * grow the hashtable in such way current_size is the index of the first free
+ * node. Take care all node pointer can be invalidated by this call.
+ *
+ * Node allocation is done in a two step way 1st) ensure a free node exist
+ * eventually, caller can setup it, 2nd) commit the node allocation with
+ * odb_commit_reservation().
+ * This is done in this way to ensure node setup is visible from another
+ * process like pp tools in an atomic way.
+ *
+ * returns 0 on success, non zero on failure in this case this function do
+ * nothing and errno is set by the first libc call failure allowing to retry
+ * after cleanup some program resource.
+ */
+int odb_grow_hashtable(odb_data_t * data);
+/**
+ * commit a previously successfull node reservation. This can't fail.
+ */
+static __inline void odb_commit_reservation(odb_data_t * data)
+{
+	++data->descr->current_size;
+}
+
+/** "immpossible" node number to indicate an error from odb_hash_add_node() */
+#define ODB_NODE_NR_INVALID ((odb_node_nr_t)-1)
+
+/* db_debug.c */
+/** check that the hash is well built */
+int odb_check_hash(odb_t const * odb);
+
+/* db_stat.c */
+typedef struct odb_hash_stat_t odb_hash_stat_t;
+odb_hash_stat_t * odb_hash_stat(odb_t const * odb);
+void odb_hash_display_stat(odb_hash_stat_t const * stats);
+void odb_hash_free_stat(odb_hash_stat_t * stats);
+
+/* db_insert.c */
+/** update info at key by incrementing its associated value by one, 
+ * if the key does not exist a new node is created and the value associated
+ * is set to one.
+ *
+ * returns EXIT_SUCCESS on success, EXIT_FAILURE on failure
+ */
+int odb_update_node(odb_t * odb, odb_key_t key);
+
+/** Add a new node w/o regarding if a node with the same key already exists
+ *
+ * returns EXIT_SUCCESS on success, EXIT_FAILURE on failure
+ */
+int odb_add_node(odb_t * odb, odb_key_t key, odb_value_t value);
+
+/* db_travel.c */
+/**
+ * return a base pointer to the node array and number of node in this array
+ * caller then will iterate through:
+ *
+ * odb_node_nr_t node_nr, pos;
+ * odb_node_t * node = odb_get_iterator(odb, &node_nr);
+ *	for ( pos = 0 ; pos < node_nr ; ++pos)
+ *		// do something
+ *
+ *  note than caller does not need to filter nil key as it's a valid key,
+ * The returned range is all valid (i.e. should never contain zero value).
+ */
+odb_node_t * odb_get_iterator(odb_t const * odb, odb_node_nr_t * nr);
+
+static __inline unsigned int
+odb_do_hash(odb_data_t const * data, odb_key_t value)
+{
+	/* FIXME: better hash for eip value, needs to instrument code
+	 * and do a lot of tests ... */
+	/* trying to combine high order bits his a no-op: inside a binary image
+	 * high order bits don't vary a lot, hash table start with 7 bits mask
+	 * so this hash coding use bits 0-7, 8-15. Hash table is stored in
+	 * files avoiding to rebuilding them at profiling re-start so
+	 * on changing do_hash() change the file format!
+	 */
+	uint32_t temp = (value >> 32) ^ value;
+	return ((temp << 0) ^ (temp >> 8)) & data->hash_mask;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !ODB_H */
diff --git a/libop/Android.mk b/libop/Android.mk
new file mode 100644
index 0000000..8fbd1e6
--- /dev/null
+++ b/libop/Android.mk
@@ -0,0 +1,19 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	op_alloc_counter.c \
+	op_config.c \
+	op_cpu_type.c \
+	op_events.c \
+	op_get_interface.c \
+	op_mangle.c \
+	op_parse_event.c
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/.. \
+	$(LOCAL_PATH)/../libutil
+
+LOCAL_MODULE := libop
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/libop/op_alloc_counter.c b/libop/op_alloc_counter.c
new file mode 100644
index 0000000..353100a
--- /dev/null
+++ b/libop/op_alloc_counter.c
@@ -0,0 +1,213 @@
+/**
+ * @file op_alloc_counter.c
+ * hardware counter allocation
+ *
+ * You can have silliness here.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <stdlib.h>
+#include <ctype.h>
+#include <dirent.h>
+
+#include "op_events.h"
+#include "op_libiberty.h"
+
+
+typedef struct counter_arc_head {
+	/** the head of allowed counter for this event */
+	struct list_head next;
+} counter_arc_head;
+
+
+typedef struct counter_arc {
+	/** counter nr */
+	int counter;
+	/** the next counter allowed for this event */
+	struct list_head next;
+} counter_arc;
+
+
+/**
+ * @param pev  an array of event
+ * @param nr_events  number of entry in pev
+ *
+ * build an array of counter list allowed for each events
+ *  counter_arc_head[i] is the list of allowed counter for pev[i] events
+ * The returned pointer is an array of nr_events entry
+ */
+static counter_arc_head *
+build_counter_arc(struct op_event const * pev[], int nr_events)
+{
+	counter_arc_head * ctr_arc;
+	int i;
+
+	ctr_arc = xmalloc(nr_events * sizeof(*ctr_arc));
+
+	for (i = 0; i < nr_events; ++i) {
+		int j;
+		u32 mask = pev[i]->counter_mask;
+
+		list_init(&ctr_arc[i].next);
+		for (j = 0; mask; ++j) {
+			if (mask & (1 << j)) {
+				counter_arc * arc = 
+					xmalloc(sizeof(counter_arc));
+				arc->counter = j;
+				/* we are looping by increasing counter number,
+				 * allocation use a left to right tree walking
+				 * so we add at end to ensure counter will
+				 * be allocated by increasing number: it's not
+				 * required but a bit less surprising when
+				 * debugging code
+				 */
+				list_add_tail(&arc->next, &ctr_arc[i].next);
+				mask &= ~(1 << j);
+			}
+		}
+	}
+
+	return ctr_arc;
+}
+
+
+/**
+ * @param ctr_arc  the array to deallocate
+ * @param nr_events  number of entry in array
+ *
+ *  deallocate all previously allocated resource by build_counter_arc()
+ */
+static void delete_counter_arc(counter_arc_head * ctr_arc, int nr_events)
+{
+	int i;
+	for (i = 0; i < nr_events; ++i) {
+		struct list_head * pos, * pos2;
+		list_for_each_safe(pos, pos2, &ctr_arc[i].next) {
+			counter_arc * arc = list_entry(pos, counter_arc, next);
+			list_del(&arc->next);
+			free(arc);
+		}
+	}
+	free(ctr_arc);
+}
+
+
+/**
+ * @param ctr_arc  tree description, ctr_arc[i] is the i-th level of tree.
+ * @param max_depth  number of entry in array ctr_arc == depth of tree
+ * @param depth  current level we are exploring
+ * @param allocated_mask  current counter already allocated mask
+ * @param counter_map  array of counter number mapping, returned results go
+ *   here
+ *
+ * return non zero on succees, in this case counter_map is set to the counter
+ * mapping number.
+ *
+ * Solution is searched through a simple backtracking exploring recursively all
+ * possible solution until one is found, prunning is done in O(1) by tracking
+ * a bitmask of already allocated counter. Walking through node is done in
+ * preorder left to right.
+ *
+ * Possible improvment if neccessary: partition counters in class of counter,
+ * two counter belong to the same class if they allow exactly the same set of
+ * event. Now using a variant of the backtrack algo can works on class of
+ * counter rather on counter (this is not an improvment if each counter goes
+ * in it's own class)
+ */
+static int
+allocate_counter(counter_arc_head const * ctr_arc, int max_depth, int depth,
+		 u32 allocated_mask, size_t * counter_map)
+{
+	struct list_head * pos;
+
+	if (depth == max_depth)
+		return 1;
+
+	list_for_each(pos, &ctr_arc[depth].next) {
+		counter_arc const * arc = list_entry(pos, counter_arc, next);
+
+		if (allocated_mask & (1 << arc->counter))
+			continue;
+
+		counter_map[depth] = arc->counter;
+
+		if (allocate_counter(ctr_arc, max_depth, depth + 1,
+		                     allocated_mask | (1 << arc->counter),
+		                     counter_map))
+			return 1;
+	}
+
+	return 0;
+}
+
+/* determine which directories are counter directories
+ */
+static int perfcounterdir(const struct dirent * entry)
+{
+	return (isdigit(entry->d_name[0]));
+}
+
+
+/**
+ * @param mask pointer where to place bit mask of unavailable counters
+ *
+ * return >= 0 number of counters that are available
+ *        < 0  could not determine number of counters
+ *
+ */
+static int op_get_counter_mask(u32 * mask)
+{
+	struct dirent **counterlist;
+	int count, i;
+	/* assume nothing is available */
+	u32 available=0;
+
+	count = scandir("/dev/oprofile", &counterlist, perfcounterdir, alphasort);
+	if (count < 0)
+		/* unable to determine bit mask */
+		return -1;
+	/* convert to bit map (0 where counter exists) */
+	for (i=0; i<count; ++i) {
+		available |= 1 << atoi(counterlist[i]->d_name);
+		free(counterlist[i]);
+	}
+	*mask=~available;
+	free(counterlist);
+	return count;
+}
+
+size_t * map_event_to_counter(struct op_event const * pev[], int nr_events,
+                              op_cpu cpu_type)
+{
+	counter_arc_head * ctr_arc;
+	size_t * counter_map;
+	int nr_counters;
+	u32 unavailable_counters = 0;
+
+	nr_counters = op_get_counter_mask(&unavailable_counters);
+	/* no counters then probably perfmon managing perfmon hw */
+	if (nr_counters <= 0) {
+		nr_counters = op_get_nr_counters(cpu_type);
+		unavailable_counters = (~0) << nr_counters;
+	}
+	if (nr_counters < nr_events)
+		return 0;
+
+	ctr_arc = build_counter_arc(pev, nr_events);
+
+	counter_map = xmalloc(nr_counters * sizeof(size_t));
+
+	if (!allocate_counter(ctr_arc, nr_events, 0, unavailable_counters,
+			      counter_map)) {
+		free(counter_map);
+		counter_map = 0;
+	}
+
+	delete_counter_arc(ctr_arc, nr_events);
+	return counter_map;
+}
diff --git a/libop/op_alloc_counter.h b/libop/op_alloc_counter.h
new file mode 100644
index 0000000..40b4ebf
--- /dev/null
+++ b/libop/op_alloc_counter.h
@@ -0,0 +1,43 @@
+/**
+ * @file op_alloc_counter.h
+ * hardware counter allocation
+ *
+ * You can have silliness here.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_ALLOC_COUNTER_H
+#define OP_ALLOC_COUNTER_H
+
+#include <stddef.h>
+
+#include "op_cpu_type.h"
+
+struct op_event;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @param pev  array of selected event we want to bind to counter
+ * @param nr_events  size of pev array
+ * @param cpu_type  cpu type
+ *
+ * Try to calculate a binding between passed event in pev and counter number.
+ * The binding is returned in a size_t * where returned ptr[i] is the counter
+ * number bound to pev[i]
+ */
+size_t * map_event_to_counter(struct op_event const * pev[], int nr_events,
+                              op_cpu cpu_type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !OP_ALLOC_COUNTER_H */
diff --git a/libop/op_config.c b/libop/op_config.c
new file mode 100644
index 0000000..837242b
--- /dev/null
+++ b/libop/op_config.c
@@ -0,0 +1,77 @@
+/**
+ * @file op_config.c
+ * Oprofile configuration parameters.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Nathan Tallent
+ * @Modifications Daniel Hansel
+ */
+
+#include "op_config.h"
+#include "op_config_24.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+/* paths in op_config.h */
+char op_session_dir[PATH_MAX];
+char op_samples_dir[PATH_MAX];
+char op_samples_current_dir[PATH_MAX];
+char op_lock_file[PATH_MAX];
+char op_log_file[PATH_MAX];
+char op_pipe_file[PATH_MAX];
+char op_dump_status[PATH_MAX];
+
+/* paths in op_config_24.h */
+char op_device[PATH_MAX];
+char op_note_device[PATH_MAX];
+char op_hash_device[PATH_MAX];
+
+void
+init_op_config_dirs(char const * session_dir)
+{
+	int session_dir_len;
+
+	assert(session_dir);	
+	session_dir_len = strlen(session_dir);
+
+	if (session_dir_len + strlen("/samples/oprofiled.log") > PATH_MAX) {
+		fprintf(stderr, "Session_dir string \"%s\" is too large.\n", 
+			session_dir);
+		exit(EXIT_FAILURE);
+	}
+	
+	strcpy(op_session_dir, session_dir);
+	
+	strcpy(op_samples_dir, op_session_dir);
+	strcat(op_samples_dir, "/samples/");
+	
+	strcpy(op_samples_current_dir, op_samples_dir);
+	strcat(op_samples_current_dir, "/current/");
+
+	strcpy(op_lock_file, op_session_dir);
+	strcat(op_lock_file, "/lock");
+
+	strcpy(op_pipe_file, op_session_dir);
+	strcat(op_pipe_file, "/opd_pipe");
+
+	strcpy(op_log_file, op_samples_dir);
+	strcat(op_log_file, "oprofiled.log");
+
+	strcpy(op_dump_status, op_session_dir);
+	strcat(op_dump_status, "/complete_dump");
+
+	strcpy(op_device, op_session_dir);
+	strcat(op_device, "/opdev");
+
+	strcpy(op_note_device, op_session_dir);
+	strcat(op_note_device, "/opnotedev");
+
+	strcpy(op_hash_device, op_session_dir);
+	strcat(op_hash_device, "/ophashmapdev");
+}
diff --git a/libop/op_config.h b/libop/op_config.h
new file mode 100644
index 0000000..b384497
--- /dev/null
+++ b/libop/op_config.h
@@ -0,0 +1,58 @@
+/**
+ * @file op_config.h
+ *
+ * Parameters a user may want to change. See
+ * also op_config_24.h
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ * @Modifications Daniel Hansel
+ */
+
+#ifndef OP_CONFIG_H
+#define OP_CONFIG_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+  
+/** 
+ * must be called to initialize the paths below.
+ * @param session_dir  the non-NULL value of the base session directory
+ */
+void init_op_config_dirs(char const * session_dir);
+
+/* 
+ * various paths, corresponding to opcontrol, that should be
+ * initialized by init_op_config_dirs() above. 
+ */
+extern char op_session_dir[];
+extern char op_samples_dir[];
+extern char op_samples_current_dir[];
+extern char op_lock_file[];
+extern char op_log_file[];
+extern char op_pipe_file[];
+extern char op_dump_status[];
+
+#define OP_DRIVER_BASE  "/dev/oprofile"
+#define OP_DATA_DIR     "/data/oprofile"
+
+/* Global directory that stores debug files */
+#ifndef DEBUGDIR
+#define DEBUGDIR "/usr/lib/debug"
+#endif
+
+#define OPD_MAGIC "DAE\n"
+#define OPD_VERSION 0x11
+
+#define OP_MIN_CPU_BUF_SIZE 2048
+#define OP_MAX_CPU_BUF_SIZE 131072
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* OP_CONFIG_H */
diff --git a/libop/op_config_24.h b/libop/op_config_24.h
new file mode 100644
index 0000000..1786fae
--- /dev/null
+++ b/libop/op_config_24.h
@@ -0,0 +1,79 @@
+/**
+ * @file op_config_24.h
+ *
+ * Parameters a user may want to change
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_CONFIG_24_H
+#define OP_CONFIG_24_H
+
+#define OP_MOUNT "/proc/sys/dev/oprofile/"
+
+extern char op_device[];
+extern char op_note_device[];
+extern char op_hash_device[];
+
+/*@{\name module default/min/max settings */
+
+/** 65536 * sizeof(op_sample) */
+#define OP_DEFAULT_BUF_SIZE 65536
+/** 
+ * we don't try to wake-up daemon until it remains more than this free entry
+ * in eviction buffer 
+ */
+#define OP_PRE_WATERMARK(buffer_size)			\
+	(((buffer_size) / 8) < OP_MIN_PRE_WATERMARK	\
+		? OP_MIN_PRE_WATERMARK			\
+		: (buffer_size) / 8)
+/** minimal buffer water mark before we try to wakeup daemon */
+#define OP_MIN_PRE_WATERMARK 8192
+/** maximum number of entry in samples eviction buffer */
+#define OP_MAX_BUF_SIZE	1048576
+/** minimum number of entry in samples eviction buffer */
+#define OP_MIN_BUF_SIZE	(32768 + OP_PRE_WATERMARK(32768))
+
+/** 16384 * sizeof(op_note) = 273680 bytes default */
+#define OP_DEFAULT_NOTE_SIZE 16384
+/** 
+ * we don't try to wake-up daemon until it remains more than this free entry
+ * in note buffer 
+ */
+#define OP_PRE_NOTE_WATERMARK(note_size)		\
+	(((note_size) / 32) < OP_MIN_NOTE_PRE_WATERMARK	\
+		? OP_MIN_NOTE_PRE_WATERMARK		\
+		: (note_size) / 32)
+/** minimal note buffer water mark before we try to wakeup daemon */
+#define OP_MIN_NOTE_PRE_WATERMARK 512
+/** maximum number of entry in note buffer */
+#define OP_MAX_NOTE_TABLE_SIZE	1048576
+/** minimum number of entry in note buffer */
+#define OP_MIN_NOTE_TABLE_SIZE	(1024 + OP_PRE_NOTE_WATERMARK(1024))
+
+/** maximum sampling rate when using RTC */
+#define OP_MAX_RTC_COUNT	4096
+/** minimum sampling rate when using RTC */
+#define OP_MIN_RTC_COUNT	2
+
+/*@}*/
+
+/** 
+ * nr entries in hash map. This is the maximum number of name components
+ * allowed. Must be a prime number 
+ */
+#define OP_HASH_MAP_NR 4093
+
+/** size of string pool in bytes */
+#define POOL_SIZE 65536
+
+#ifndef NR_CPUS
+/** maximum number of cpus present in the box */
+#define NR_CPUS 32
+#endif
+
+#endif /* OP_CONFIG_24_H */
diff --git a/libop/op_cpu_type.c b/libop/op_cpu_type.c
new file mode 100644
index 0000000..b9d13de
--- /dev/null
+++ b/libop/op_cpu_type.c
@@ -0,0 +1,158 @@
+/**
+ * @file op_cpu_type.c
+ * CPU type determination
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "op_cpu_type.h"
+
+struct cpu_descr {
+	char const * pretty;
+	char const * name;
+	op_cpu cpu;
+	unsigned int nr_counters;
+};
+
+static struct cpu_descr const cpu_descrs[MAX_CPU_TYPE] = {
+	{ "Pentium Pro", "i386/ppro", CPU_PPRO, 2 },
+	{ "PII", "i386/pii", CPU_PII, 2 },
+	{ "PIII", "i386/piii", CPU_PIII, 2 },
+	{ "Athlon", "i386/athlon", CPU_ATHLON, 4 },
+	{ "CPU with timer interrupt", "timer", CPU_TIMER_INT, 1 },
+	{ "CPU with RTC device", "rtc", CPU_RTC, 1 },
+	{ "P4 / Xeon", "i386/p4", CPU_P4, 8 },
+	{ "IA64", "ia64/ia64", CPU_IA64, 4 },
+	{ "Itanium", "ia64/itanium", CPU_IA64_1, 4 },
+	{ "Itanium 2", "ia64/itanium2", CPU_IA64_2, 4 },
+	{ "AMD64 processors", "x86-64/hammer", CPU_HAMMER, 4 },
+	{ "P4 / Xeon with 2 hyper-threads", "i386/p4-ht", CPU_P4_HT2, 4 },
+	{ "Alpha EV4", "alpha/ev4", CPU_AXP_EV4, 2 },
+	{ "Alpha EV5", "alpha/ev5", CPU_AXP_EV5, 3 },
+	{ "Alpha PCA56", "alpha/pca56", CPU_AXP_PCA56, 3 },
+	{ "Alpha EV6", "alpha/ev6", CPU_AXP_EV6, 2 },
+	{ "Alpha EV67", "alpha/ev67", CPU_AXP_EV67, 20 },
+	{ "Pentium M (P6 core)", "i386/p6_mobile", CPU_P6_MOBILE, 2 },
+	{ "ARM/XScale PMU1", "arm/xscale1", CPU_ARM_XSCALE1, 3 },
+	{ "ARM/XScale PMU2", "arm/xscale2", CPU_ARM_XSCALE2, 5 },
+	{ "ppc64 POWER4", "ppc64/power4", CPU_PPC64_POWER4, 8 },
+	{ "ppc64 POWER5", "ppc64/power5", CPU_PPC64_POWER5, 6 },
+	{ "ppc64 POWER5+", "ppc64/power5+", CPU_PPC64_POWER5p, 6 },
+	{ "ppc64 970", "ppc64/970", CPU_PPC64_970, 8 },
+	{ "MIPS 20K", "mips/20K", CPU_MIPS_20K, 1},
+	{ "MIPS 24K", "mips/24K", CPU_MIPS_24K, 2},
+	{ "MIPS 25K", "mips/25K", CPU_MIPS_25K, 2},
+	{ "MIPS 34K", "mips/34K", CPU_MIPS_34K, 4},
+	{ "MIPS 5K", "mips/5K", CPU_MIPS_5K, 2},
+	{ "MIPS R10000", "mips/r10000", CPU_MIPS_R10000, 2 },
+	{ "MIPS R12000", "mips/r12000", CPU_MIPS_R12000, 4 },
+	{ "QED RM7000", "mips/rm7000", CPU_MIPS_RM7000, 1 },
+	{ "PMC-Sierra RM9000", "mips/rm9000", CPU_MIPS_RM9000, 2 },
+	{ "Sibyte SB1", "mips/sb1", CPU_MIPS_SB1, 4 },
+	{ "NEC VR5432", "mips/vr5432", CPU_MIPS_VR5432, 2 },
+	{ "NEC VR5500", "mips/vr5500", CPU_MIPS_VR5500, 2 },
+	{ "e500", "ppc/e500", CPU_PPC_E500, 4 },
+	{ "e500v2", "ppc/e500v2", CPU_PPC_E500_2, 4 },
+	{ "Core Solo / Duo", "i386/core", CPU_CORE, 2 },
+	{ "PowerPC G4", "ppc/7450",  CPU_PPC_7450, 6 },
+	{ "Core 2", "i386/core_2", CPU_CORE_2, 2 },
+	{ "ppc64 POWER6", "ppc64/power6", CPU_PPC64_POWER6, 4 },
+	{ "ppc64 970MP", "ppc64/970MP", CPU_PPC64_970MP, 8 },
+	{ "ppc64 Cell Broadband Engine", "ppc64/cell-be", CPU_PPC64_CELL, 8 },
+	{ "AMD64 family10", "x86-64/family10", CPU_FAMILY10, 4 },
+	{ "ppc64 PA6T", "ppc64/pa6t", CPU_PPC64_PA6T, 6 },
+	{ "ARM MPCore", "arm/mpcore", CPU_ARM_MPCORE, 2 },
+	{ "ARM V6 PMU", "arm/armv6", CPU_ARM_V6, 3 },
+	{ "ppc64 POWER5++", "ppc64/power5++", CPU_PPC64_POWER5pp, 6 },
+	{ "e300", "ppc/e300", CPU_PPC_E300, 4 },
+	{ "AVR32", "avr32", CPU_AVR32, 3 },
+};
+ 
+static size_t const nr_cpu_descrs = sizeof(cpu_descrs) / sizeof(struct cpu_descr);
+
+op_cpu op_get_cpu_type(void)
+{
+	int cpu_type = CPU_NO_GOOD;
+	char str[100];
+	FILE * fp;
+
+	fp = fopen("/proc/sys/dev/oprofile/cpu_type", "r");
+	if (!fp) {
+		/* Try 2.6's oprofilefs one instead. */
+		fp = fopen("/dev/oprofile/cpu_type", "r");
+		if (!fp) {
+			fprintf(stderr, "Unable to open cpu_type file for reading\n");
+			fprintf(stderr, "Make sure you have done opcontrol --init\n");
+			return cpu_type;
+		}
+	}
+
+	if (!fgets(str, 99, fp)) {
+		fprintf(stderr, "Could not read cpu type.\n");
+		return CPU_NO_GOOD;
+	}
+
+	cpu_type = op_get_cpu_number(str);
+
+	fclose(fp);
+
+	return cpu_type;
+}
+
+
+op_cpu op_get_cpu_number(char const * cpu_string)
+{
+	int cpu_type = CPU_NO_GOOD;
+	size_t i;
+	
+	for (i = 0; i < nr_cpu_descrs; ++i) {
+		if (!strcmp(cpu_descrs[i].name, cpu_string)) {
+			cpu_type = cpu_descrs[i].cpu;
+			break;
+		}
+	}
+
+	/* Attempt to convert into a number */
+	if (cpu_type == CPU_NO_GOOD)
+		sscanf(cpu_string, "%d\n", &cpu_type);
+	
+	if (cpu_type <= CPU_NO_GOOD || cpu_type >= MAX_CPU_TYPE)
+		cpu_type = CPU_NO_GOOD;
+
+	return cpu_type;
+}
+
+
+char const * op_get_cpu_type_str(op_cpu cpu_type)
+{
+	if (cpu_type <= CPU_NO_GOOD || cpu_type >= MAX_CPU_TYPE)
+		return "invalid cpu type";
+
+	return cpu_descrs[cpu_type].pretty;
+}
+
+
+char const * op_get_cpu_name(op_cpu cpu_type)
+{
+	if (cpu_type <= CPU_NO_GOOD || cpu_type >= MAX_CPU_TYPE)
+		return "invalid cpu type";
+
+	return cpu_descrs[cpu_type].name;
+}
+
+
+int op_get_nr_counters(op_cpu cpu_type)
+{
+	if (cpu_type <= CPU_NO_GOOD || cpu_type >= MAX_CPU_TYPE)
+		return 0;
+
+	return cpu_descrs[cpu_type].nr_counters;
+}
diff --git a/libop/op_cpu_type.h b/libop/op_cpu_type.h
new file mode 100644
index 0000000..be95ae2
--- /dev/null
+++ b/libop/op_cpu_type.h
@@ -0,0 +1,139 @@
+/**
+ * @file op_cpu_type.h
+ * CPU type determination
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_CPU_TYPE_H
+#define OP_CPU_TYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Supported cpu type.  Always add new CPU types at the very end.
+ */
+typedef enum {
+	CPU_NO_GOOD = -1, /**< unsupported CPU type */
+	CPU_PPRO, /**< Pentium Pro */
+	CPU_PII, /**< Pentium II series */
+	CPU_PIII, /**< Pentium III series */
+	CPU_ATHLON, /**< AMD P6 series */
+	CPU_TIMER_INT, /**< CPU using the timer interrupt */
+	CPU_RTC, /**< other CPU to use the RTC */
+	CPU_P4,  /**< Pentium 4 / Xeon series */
+	CPU_IA64, /**< Generic IA64 */
+	CPU_IA64_1, /**< IA64 Merced */
+	CPU_IA64_2, /**< IA64 McKinley */
+	CPU_HAMMER, /**< AMD Hammer family */
+	CPU_P4_HT2, /**< Pentium 4 / Xeon series with 2 hyper-threads */
+	CPU_AXP_EV4, /**< Alpha EV4 family */
+	CPU_AXP_EV5, /**< Alpha EV5 family */
+	CPU_AXP_PCA56, /**< Alpha PCA56 family */
+	CPU_AXP_EV6, /**< Alpha EV6 family */
+	CPU_AXP_EV67, /**< Alpha EV67 family */
+	CPU_P6_MOBILE, /**< Pentium M series */
+	CPU_ARM_XSCALE1, /**< ARM XScale 1 */
+	CPU_ARM_XSCALE2, /**< ARM XScale 2 */
+	CPU_PPC64_POWER4, /**< ppc64 POWER4 family */
+	CPU_PPC64_POWER5, /**< ppc64 POWER5 family */
+	CPU_PPC64_POWER5p, /**< ppc64 Power5+ family */
+	CPU_PPC64_970, /**< ppc64 970 family */
+	CPU_MIPS_20K, /**< MIPS 20K */
+	CPU_MIPS_24K, /**< MIPS 24K */
+	CPU_MIPS_25K, /**< MIPS 25K */
+	CPU_MIPS_34K, /**< MIPS 34K */
+	CPU_MIPS_5K, /**< MIPS 5K */
+	CPU_MIPS_R10000, /**< MIPS R10000 */
+	CPU_MIPS_R12000, /**< MIPS R12000 */
+	CPU_MIPS_RM7000, /**< QED  RM7000 */
+	CPU_MIPS_RM9000, /**< PMC-Sierra RM9000 */
+	CPU_MIPS_SB1, /**< Broadcom SB1 */
+	CPU_MIPS_VR5432, /**< NEC VR5432 */
+	CPU_MIPS_VR5500, /**< MIPS VR5500, VR5532 and VR7701 */
+	CPU_PPC_E500,	/**< e500 */
+	CPU_PPC_E500_2,	/**< e500v2 */
+	CPU_CORE, /**< Core Solo / Duo series */
+	CPU_PPC_7450, /**< PowerPC G4 */
+	CPU_CORE_2, /**< Intel Core 2 */
+	CPU_PPC64_POWER6, /**< ppc64 POWER6 family */
+	CPU_PPC64_970MP, /**< ppc64 970MP */
+	CPU_PPC64_CELL, /**< ppc64 Cell Broadband Engine*/
+	CPU_FAMILY10, /**< AMD family 10 */
+ 	CPU_PPC64_PA6T, /**< ppc64 PA6T */
+	CPU_ARM_MPCORE, /**< ARM MPCore */
+	CPU_ARM_V6, /**< ARM V6 */
+	CPU_PPC64_POWER5pp,  /**< ppc64 Power5++ family */
+	CPU_PPC_E300, /**< e300 */
+	CPU_AVR32, /**< AVR32 */
+	MAX_CPU_TYPE
+} op_cpu;
+
+/**
+ * get the CPU type from the kernel
+ *
+ * returns CPU_NO_GOOD if the CPU could not be identified.
+ * This function can not work if the module is not loaded
+ */
+op_cpu op_get_cpu_type(void);
+
+/**
+ * get the cpu number based on string
+ * @param cpu_string with either the cpu type identifier or cpu type number
+ *
+ * The function returns CPU_NO_GOOD if no matching string was found.
+ */
+op_cpu op_get_cpu_number(char const * cpu_string);
+
+/**
+ * get the cpu string.
+ * @param cpu_type the cpu type identifier
+ *
+ * The function always return a valid char const * the core cpu denomination
+ * or "invalid cpu type" if cpu_type is not valid.
+ */
+char const * op_get_cpu_type_str(op_cpu cpu_type);
+
+/**
+ * op_get_cpu_name - get the cpu name
+ * @param cpu_type  the cpu identifier name
+ *
+ * The function always return a valid char const *
+ * Return the OProfile CPU name, e.g. "i386/pii"
+ */
+char const * op_get_cpu_name(op_cpu cpu_type);
+
+/**
+ * compute the number of counters available
+ * @param cpu_type numeric processor type
+ *
+ * returns 0 if the CPU could not be identified
+ */
+int op_get_nr_counters(op_cpu cpu_type);
+
+typedef enum {
+	OP_INTERFACE_NO_GOOD = -1,
+	OP_INTERFACE_24,
+	OP_INTERFACE_26
+} op_interface;
+
+/**
+ * get the INTERFACE used to communicate between daemon and the kernel
+ *
+ * returns OP_INTERFACE_NO_GOOD if the INTERFACE could not be identified.
+ * This function will identify the interface as OP_INTERFACE_NO_GOOD if
+ * the module is not loaded.
+ */
+op_interface op_get_interface(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_CPU_TYPE_H */
diff --git a/libop/op_events.c b/libop/op_events.c
new file mode 100644
index 0000000..b4a10e7
--- /dev/null
+++ b/libop/op_events.c
@@ -0,0 +1,862 @@
+/**
+ * @file op_events.c
+ * Details of PMC profiling events
+ *
+ * You can have silliness here.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "op_events.h"
+#include "op_libiberty.h"
+#include "op_fileio.h"
+#include "op_string.h"
+#include "op_cpufreq.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static LIST_HEAD(events_list);
+static LIST_HEAD(um_list);
+
+static char const * filename;
+static unsigned int line_nr;
+
+static void parse_error(char const * context)
+{
+	fprintf(stderr, "oprofile: parse error in %s, line %u\n",
+		filename, line_nr);
+	fprintf(stderr, "%s\n", context);
+	exit(EXIT_FAILURE);
+}
+
+
+static int parse_int(char const * str)
+{
+	int value;
+	if (sscanf(str, "%d", &value) != 1)
+		parse_error("expected decimal value");
+
+	return value;
+}
+
+
+static int parse_hex(char const * str)
+{
+	int value;
+	/* 0x/0X to force the use of hexa notation for field intended to
+	   be in hexadecimal */
+	if (sscanf(str, "0x%x", &value) != 1 &&
+	    sscanf(str, "0X%x", &value) != 1)
+		parse_error("expected hexadecimal value");
+
+	return value;
+}
+
+
+static u64 parse_long_hex(char const * str)
+{
+	u64 value;
+	if (sscanf(str, "%Lx", &value) != 1)
+		parse_error("expected long hexadecimal value");
+
+	fflush(stderr);
+	return value;
+}
+
+
+/* name:MESI type:bitmask default:0x0f */
+static void parse_um(struct op_unit_mask * um, char const * line)
+{
+	int seen_name = 0;
+	int seen_type = 0;
+       	int seen_default = 0;
+	char const * valueend = line + 1;
+       	char const * tagend = line + 1;
+	char const * start = line;
+
+	while (*valueend) {
+		valueend = skip_nonws(valueend);
+
+		while (*tagend != ':' && *tagend)
+			++tagend;
+
+		if (valueend == tagend)
+			break;
+
+		if (!*tagend)
+			parse_error("parse_um() expected :value");
+
+		++tagend;
+
+		if (strisprefix(start, "name")) {
+			if (seen_name)
+				parse_error("duplicate name: tag");
+			seen_name = 1;
+			um->name = op_xstrndup(tagend, valueend - tagend);
+		} else if (strisprefix(start, "type")) {
+			if (seen_type)
+				parse_error("duplicate type: tag");
+			seen_type = 1;
+			if (strisprefix(tagend, "mandatory")) {
+				um->unit_type_mask = utm_mandatory;
+			} else if (strisprefix(tagend, "bitmask")) {
+				um->unit_type_mask = utm_bitmask;
+			} else if (strisprefix(tagend, "exclusive")) {
+				um->unit_type_mask = utm_exclusive;
+			} else {
+				parse_error("invalid unit mask type");
+			}
+		} else if (strisprefix(start, "default")) {
+			if (seen_default)
+				parse_error("duplicate default: tag");
+			seen_default = 1;
+			um->default_mask = parse_hex(tagend);
+		} else {
+			parse_error("invalid unit mask tag");
+		}
+
+		valueend = skip_ws(valueend);
+		tagend = valueend;
+		start = valueend;
+	}
+}
+
+
+/* \t0x08 (M)odified cache state */
+static void parse_um_entry(struct op_described_um * entry, char const * line)
+{
+	char const * c = line;
+
+	c = skip_ws(c);
+	entry->value = parse_hex(c);
+	c = skip_nonws(c);
+
+	if (!*c)
+		parse_error("invalid unit mask entry");
+
+	c = skip_ws(c);
+
+	if (!*c)
+		parse_error("invalid unit mask entry");
+
+	entry->desc = xstrdup(c);
+}
+
+
+static struct op_unit_mask * new_unit_mask(void)
+{
+	struct op_unit_mask * um = xmalloc(sizeof(struct op_unit_mask));
+	memset(um, '\0', sizeof(struct op_unit_mask));
+	list_add_tail(&um->um_next, &um_list);
+
+	return um;
+}
+
+
+/*
+ * name:zero type:mandatory default:0x0
+ * \t0x0 No unit mask
+ */
+static void read_unit_masks(char const * file)
+{
+	struct op_unit_mask * um = NULL;
+	char * line;
+	FILE * fp = fopen(file, "r");
+
+	if (!fp) {
+		fprintf(stderr,
+			"oprofile: could not open unit mask description file %s\n", file);
+		exit(EXIT_FAILURE);
+	}
+
+	filename = file;
+	line_nr = 1;
+
+	line = op_get_line(fp);
+
+	while (line) {
+		if (empty_line(line) || comment_line(line))
+			goto next;
+
+		if (line[0] != '\t') {
+			um = new_unit_mask();
+			parse_um(um, line);
+		} else {
+			if (!um)
+				parse_error("no unit mask name line");
+			if (um->num >= MAX_UNIT_MASK)
+				parse_error("oprofile: maximum unit mask entries exceeded");
+
+			parse_um_entry(&um->um[um->num], line);
+			++(um->num);
+		}
+
+next:
+		free(line);
+		line = op_get_line(fp);
+		++line_nr;
+	}
+
+	fclose(fp);
+}
+
+
+static u32 parse_counter_mask(char const * str)
+{
+	u32 mask = 0;
+	char const * numstart = str;
+
+	while (*numstart) {
+		mask |= 1 << parse_int(numstart);
+
+		while (*numstart && *numstart != ',')
+			++numstart;
+		/* skip , unless we reach eos */
+		if (*numstart)
+			++numstart;
+
+		numstart = skip_ws(numstart);
+	}
+
+	return mask;
+}
+
+
+static struct op_unit_mask * find_um(char const * value)
+{
+	struct list_head * pos;
+
+	list_for_each(pos, &um_list) {
+		struct op_unit_mask * um = list_entry(pos, struct op_unit_mask, um_next);
+		if (strcmp(value, um->name) == 0)
+			return um;
+	}
+
+	fprintf(stderr, "oprofile: could not find unit mask %s\n", value);
+	exit(EXIT_FAILURE);
+}
+
+
+/* parse either a "tag:value" or a ": trailing description string" */
+static int next_token(char const ** cp, char ** name, char ** value)
+{
+	size_t tag_len;
+	size_t val_len;
+	char const * c = *cp;
+	char const * end;
+	char const * colon;
+
+	c = skip_ws(c);
+	end = colon = c;
+	end = skip_nonws(end);
+
+	colon = strchr(colon, ':');
+
+	if (!colon) {
+		if (*c)
+			parse_error("next_token(): garbage at end of line");
+		return 0;
+	}
+
+	if (colon >= end)
+		parse_error("next_token() expected ':'");
+
+	tag_len = colon - c;
+	val_len = end - (colon + 1);
+
+	if (!tag_len) {
+		/* : trailing description */
+		end = skip_ws(end);
+		*name = xstrdup("desc");
+		*value = xstrdup(end);
+		end += strlen(end);
+	} else {
+		/* tag:value */
+		*name = op_xstrndup(c, tag_len);
+		*value = op_xstrndup(colon + 1, val_len);
+		end = skip_ws(end);
+	}
+
+	*cp = end;
+	return 1;
+}
+
+
+static struct op_event * new_event(void)
+{
+	struct op_event * event = xmalloc(sizeof(struct op_event));
+	memset(event, '\0', sizeof(struct op_event));
+	list_add_tail(&event->event_next, &events_list);
+
+	return event;
+}
+
+
+/* event:0x00 counters:0 um:zero minimum:4096 name:ISSUES : Total issues */
+static void read_events(char const * file)
+{
+	struct op_event * event = NULL;
+	char * line;
+	char * name;
+	char * value;
+	char const * c;
+	int seen_event, seen_counters, seen_um, seen_minimum, seen_name;
+	FILE * fp = fopen(file, "r");
+
+	if (!fp) {
+		fprintf(stderr, "oprofile: could not open event description file %s\n", file);
+		exit(EXIT_FAILURE);
+	}
+
+	filename = file;
+	line_nr = 1;
+
+	line = op_get_line(fp);
+
+	while (line) {
+		if (empty_line(line) || comment_line(line))
+			goto next;
+
+		seen_name = 0;
+		seen_event = 0;
+		seen_counters = 0;
+		seen_um = 0;
+		seen_minimum = 0;
+		event = new_event();
+
+		c = line;
+		while (next_token(&c, &name, &value)) {
+			if (strcmp(name, "name") == 0) {
+				if (seen_name)
+					parse_error("duplicate name: tag");
+				seen_name = 1;
+				if (strchr(value, '/') != NULL)
+					parse_error("invalid event name");
+				if (strchr(value, '.') != NULL)
+					parse_error("invalid event name");
+				event->name = value;
+			} else if (strcmp(name, "event") == 0) {
+				if (seen_event)
+					parse_error("duplicate event: tag");
+				seen_event = 1;
+				event->val = parse_hex(value);
+				free(value);
+			} else if (strcmp(name, "counters") == 0) {
+				if (seen_counters)
+					parse_error("duplicate counters: tag");
+				seen_counters = 1;
+				event->counter_mask = parse_counter_mask(value);
+				free(value);
+			} else if (strcmp(name, "um") == 0) {
+				if (seen_um)
+					parse_error("duplicate um: tag");
+				seen_um = 1;
+				event->unit = find_um(value);
+				event->unit->used = 1;
+				free(value);
+			} else if (strcmp(name, "minimum") == 0) {
+				if (seen_minimum)
+					parse_error("duplicate minimum: tag");
+				seen_minimum = 1;
+				event->min_count = parse_int(value);
+				free(value);
+			} else if (strcmp(name, "desc") == 0) {
+				event->desc = value;
+			} else {
+				parse_error("unknown tag");
+			}
+
+			free(name);
+		}
+next:
+		free(line);
+		line = op_get_line(fp);
+		++line_nr;
+	}
+
+	fclose(fp);
+}
+
+
+/* usefull for make check */
+static void check_unit_mask(struct op_unit_mask const * um,
+	char const * cpu_name)
+{
+	u32 i;
+
+	if (!um->used) {
+		fprintf(stderr, "um %s is not used\n", um->name);
+		exit(EXIT_FAILURE);
+	}
+
+	if (um->unit_type_mask == utm_mandatory && um->num != 1) {
+		fprintf(stderr, "mandatory um %s doesn't contain exactly one "
+			"entry (%s)\n", um->name, cpu_name);
+		exit(EXIT_FAILURE);
+	} else if (um->unit_type_mask == utm_bitmask) {
+		u32 default_mask = um->default_mask;
+		for (i = 0; i < um->num; ++i)
+			default_mask &= ~um->um[i].value;
+
+		if (default_mask) {
+			fprintf(stderr, "um %s default mask is not valid "
+				"(%s)\n", um->name, cpu_name);
+			exit(EXIT_FAILURE);
+		}
+	} else {
+		for (i = 0; i < um->num; ++i) {
+			if (um->default_mask == um->um[i].value)
+				break;
+		}
+
+		if (i == um->num) {
+			fprintf(stderr, "exclusive um %s default value is not "
+				"valid (%s)\n", um->name, cpu_name);
+			exit(EXIT_FAILURE);
+		}
+	}
+}
+
+
+static void load_events(op_cpu cpu_type)
+{
+	char const * cpu_name = op_get_cpu_name(cpu_type);
+	char * event_dir;
+	char * event_file;
+	char * um_file;
+	char * dir;
+	struct list_head * pos;
+
+	if (!list_empty(&events_list))
+		return;
+
+	dir = getenv("OPROFILE_EVENTS_DIR");
+	if (dir == NULL)
+		dir = OP_DATADIR;
+
+	event_dir = xmalloc(strlen(dir) + strlen("/") + strlen(cpu_name) +
+                            strlen("/") + 1);
+	strcpy(event_dir, dir);
+	strcat(event_dir, "/"); 
+
+	strcat(event_dir, cpu_name);
+	strcat(event_dir, "/");
+
+	event_file = xmalloc(strlen(event_dir) + strlen("events") + 1);
+	strcpy(event_file, event_dir);
+	strcat(event_file, "events");
+
+	um_file = xmalloc(strlen(event_dir) + strlen("unit_masks") + 1);
+	strcpy(um_file, event_dir);
+	strcat(um_file, "unit_masks");
+
+	read_unit_masks(um_file);
+	read_events(event_file);
+
+	/* sanity check: all unit mask must be used */
+	list_for_each(pos, &um_list) {
+		struct op_unit_mask * um = list_entry(pos, struct op_unit_mask, um_next);
+
+		check_unit_mask(um, cpu_name);
+	}
+	
+	free(um_file);
+	free(event_file);
+	free(event_dir);
+}
+
+
+struct list_head * op_events(op_cpu cpu_type)
+{
+	load_events(cpu_type);
+	return &events_list;
+}
+
+
+static void delete_unit_mask(struct op_unit_mask * unit)
+{
+	u32 cur;
+	for (cur = 0 ; cur < unit->num ; ++cur) {
+		if (unit->um[cur].desc)
+			free(unit->um[cur].desc);
+	}
+
+	if (unit->name)
+		free(unit->name);
+
+	list_del(&unit->um_next);
+	free(unit);
+}
+
+
+static void delete_event(struct op_event * event)
+{
+	if (event->name)
+		free(event->name);
+	if (event->desc)
+		free(event->desc);
+
+	list_del(&event->event_next);
+	free(event);
+}
+
+
+void op_free_events(void)
+{
+	struct list_head * pos, * pos2;
+	list_for_each_safe(pos, pos2, &events_list) {
+		struct op_event * event = list_entry(pos, struct op_event, event_next);
+		delete_event(event);
+	}
+
+	list_for_each_safe(pos, pos2, &um_list) {
+		struct op_unit_mask * unit = list_entry(pos, struct op_unit_mask, um_next);
+		delete_unit_mask(unit);
+	}
+}
+
+
+static struct op_event * find_event(u32 nr)
+{
+	struct list_head * pos;
+
+	list_for_each(pos, &events_list) {
+		struct op_event * event = list_entry(pos, struct op_event, event_next);
+		if (event->val == nr)
+			return event;
+	}
+
+	return NULL;
+}
+
+
+static FILE * open_event_mapping_file(char const * cpu_name) 
+{
+	char * ev_map_file;
+	char * dir;
+	dir = getenv("OPROFILE_EVENTS_DIR");
+	if (dir == NULL)
+		dir = OP_DATADIR;
+
+	ev_map_file = xmalloc(strlen(dir) + strlen("/") + strlen(cpu_name) +
+	                    strlen("/") + + strlen("event_mappings") + 1);
+	strcpy(ev_map_file, dir);
+	strcat(ev_map_file, "/");
+
+	strcat(ev_map_file, cpu_name);
+	strcat(ev_map_file, "/");
+	strcat(ev_map_file, "event_mappings");
+	filename = ev_map_file;
+	return (fopen(ev_map_file, "r"));
+}
+
+
+/**
+ *  This function is PPC64-specific.
+ */
+static char const * get_mapping(u32 nr, FILE * fp) 
+{
+	char * line;
+	char * name;
+	char * value;
+	char const * c;
+	char * map = NULL;
+	int seen_event = 0, seen_mmcr0 = 0, seen_mmcr1 = 0, seen_mmcra = 0;
+	u32 mmcr0 = 0;
+	u64 mmcr1 = 0;
+	u32 mmcra = 0;
+	int event_found = 0;
+
+	line_nr = 1;
+	line = op_get_line(fp);
+	while (line && !event_found) {
+		if (empty_line(line) || comment_line(line))
+			goto next;
+
+		seen_event = 0;
+		seen_mmcr0 = 0;
+		seen_mmcr1 = 0;
+		seen_mmcra = 0;
+		mmcr0 = 0;
+		mmcr1 = 0;
+		mmcra = 0;
+
+		c = line;
+		while (next_token(&c, &name, &value)) {
+			if (strcmp(name, "event") == 0) {
+				u32 evt;
+				if (seen_event)
+					parse_error("duplicate event tag");
+				seen_event = 1;
+				evt = parse_hex(value);
+				if (evt == nr)
+					event_found = 1;
+				free(value);
+			} else if (strcmp(name, "mmcr0") == 0) {
+				if (seen_mmcr0)
+					parse_error("duplicate mmcr0 tag");
+				seen_mmcr0 = 1;
+				mmcr0 = parse_hex(value);
+				free(value);
+			} else if (strcmp(name, "mmcr1") == 0) {
+				if (seen_mmcr1)
+					parse_error("duplicate mmcr1: tag");
+				seen_mmcr1 = 1;
+				mmcr1 = parse_long_hex(value);
+				free(value);
+			} else if (strcmp(name, "mmcra") == 0) {
+				if (seen_mmcra)
+					parse_error("duplicate mmcra: tag");
+				seen_mmcra = 1;
+				mmcra = parse_hex(value);
+				free(value);
+			} else {
+				parse_error("unknown tag");
+			}
+
+			free(name);
+		}
+next:
+		free(line);
+		line = op_get_line(fp);
+		++line_nr;
+	}
+	if (event_found) {
+		if (!seen_mmcr0 || !seen_mmcr1 || !seen_mmcra) {
+			fprintf(stderr, "Error: Missing information in line %d of event mapping file %s\n", line_nr, filename);
+			exit(EXIT_FAILURE);
+		}
+		map = xmalloc(70);
+		snprintf(map, 70, "mmcr0:%u mmcr1:%Lu mmcra:%u",
+		         mmcr0, mmcr1, mmcra);
+	}
+
+	return map;
+}
+
+
+char const * find_mapping_for_event(u32 nr, op_cpu cpu_type)
+{
+	char const * cpu_name = op_get_cpu_name(cpu_type);
+	FILE * fp = open_event_mapping_file(cpu_name);
+	char const * map = NULL;
+	switch (cpu_type) {
+		case CPU_PPC64_PA6T:
+		case CPU_PPC64_970:
+		case CPU_PPC64_970MP:
+		case CPU_PPC64_POWER4:
+		case CPU_PPC64_POWER5:
+		case CPU_PPC64_POWER5p:
+		case CPU_PPC64_POWER5pp:
+		case CPU_PPC64_POWER6:
+			if (!fp) {
+				fprintf(stderr, "oprofile: could not open event mapping file %s\n", filename);
+				exit(EXIT_FAILURE);
+			} else {
+				map = get_mapping(nr, fp);
+			}
+			break;			
+		default:
+			break;
+	}
+
+	if (fp)
+		fclose(fp);
+
+	return map;
+}
+
+
+struct op_event * find_event_by_name(char const * name)
+{
+	struct list_head * pos;
+
+	list_for_each(pos, &events_list) {
+		struct op_event * event = list_entry(pos, struct op_event, event_next);
+		if (strcmp(event->name, name) == 0)
+			return event;
+	}
+
+	return NULL;
+}
+
+
+struct op_event * op_find_event(op_cpu cpu_type, u32 nr)
+{
+	struct op_event * event;
+
+	load_events(cpu_type);
+
+	event = find_event(nr);
+
+	return event;
+}
+
+
+int op_check_events(int ctr, u32 nr, u32 um, op_cpu cpu_type)
+{
+	int ret = OP_OK_EVENT;
+	struct op_event * event;
+	size_t i;
+	u32 ctr_mask = 1 << ctr;
+
+	load_events(cpu_type);
+
+	event = find_event(nr);
+
+	if (!event) {
+		ret |= OP_INVALID_EVENT;
+		return ret;
+	}
+
+	if ((event->counter_mask & ctr_mask) == 0)
+		ret |= OP_INVALID_COUNTER;
+
+	if (event->unit->unit_type_mask == utm_bitmask) {
+		for (i = 0; i < event->unit->num; ++i)
+			um &= ~(event->unit->um[i].value);			
+		
+		if (um)
+			ret |= OP_INVALID_UM;
+
+	} else {
+		for (i = 0; i < event->unit->num; ++i) {
+			if (event->unit->um[i].value == um)
+				break;
+		}
+
+		if (i == event->unit->num)
+			ret |= OP_INVALID_UM;
+	}
+
+	return ret;
+}
+
+
+void op_default_event(op_cpu cpu_type, struct op_default_event_descr * descr)
+{
+	descr->name = "";
+	descr->um = 0x0;
+	/* A fixed value of CPU cycles; this should ensure good
+	 * granulity even on faster CPUs, though it will generate more
+	 * interrupts.
+	 */
+	descr->count = 100000;
+
+	switch (cpu_type) {
+		case CPU_PPRO:
+		case CPU_PII:
+		case CPU_PIII:
+		case CPU_P6_MOBILE:
+		case CPU_CORE:
+		case CPU_CORE_2:
+		case CPU_ATHLON:
+		case CPU_HAMMER:
+		case CPU_FAMILY10:
+			descr->name = "CPU_CLK_UNHALTED";
+			break;
+
+		case CPU_RTC:
+			descr->name = "RTC_INTERRUPTS";
+			descr->count = 1024;
+			break;
+
+		case CPU_P4:
+		case CPU_P4_HT2:
+			descr->name = "GLOBAL_POWER_EVENTS";
+			descr->um = 0x1;
+			break;
+
+		case CPU_IA64:
+		case CPU_IA64_1:
+		case CPU_IA64_2:
+			descr->count = 1000000;
+			descr->name = "CPU_CYCLES";
+			break;
+
+		case CPU_AXP_EV4:
+		case CPU_AXP_EV5:
+		case CPU_AXP_PCA56:
+		case CPU_AXP_EV6:
+		case CPU_AXP_EV67:
+			descr->name = "CYCLES";
+			break;
+
+		// we could possibly use the CCNT
+		case CPU_ARM_XSCALE1:
+		case CPU_ARM_XSCALE2:
+		case CPU_ARM_MPCORE:
+		case CPU_ARM_V6:
+		case CPU_AVR32:
+			descr->name = "CPU_CYCLES";
+			break;
+
+		case CPU_PPC64_PA6T:
+		case CPU_PPC64_970:
+		case CPU_PPC64_970MP:
+		case CPU_PPC_7450:
+		case CPU_PPC64_POWER4:
+		case CPU_PPC64_POWER5:
+		case CPU_PPC64_POWER6:
+		case CPU_PPC64_POWER5p:
+		case CPU_PPC64_POWER5pp:
+		case CPU_PPC64_CELL:
+			descr->name = "CYCLES";
+			break;
+
+		case CPU_MIPS_20K:
+			descr->name = "CYCLES";
+			break;
+
+		case CPU_MIPS_24K:
+			descr->name = "INSTRUCTIONS";
+			break;
+
+		case CPU_MIPS_34K:
+			descr->name = "INSTRUCTIONS";
+			break;
+
+		case CPU_MIPS_5K:
+		case CPU_MIPS_25K:
+			descr->name = "CYCLES";
+			break;
+
+		case CPU_MIPS_R10000:
+		case CPU_MIPS_R12000:
+			descr->name = "INSTRUCTIONS_GRADUATED";
+			break;
+
+		case CPU_MIPS_RM7000:
+		case CPU_MIPS_RM9000:
+			descr->name = "INSTRUCTIONS_ISSUED";
+			break;
+
+		case CPU_MIPS_SB1:
+			descr->name = "INSN_SURVIVED_STAGE7";
+			break;
+
+		case CPU_MIPS_VR5432:
+		case CPU_MIPS_VR5500:
+			descr->name = "INSTRUCTIONS_EXECUTED";
+			break;
+
+		case CPU_PPC_E500:
+		case CPU_PPC_E500_2:
+		case CPU_PPC_E300:
+			descr->name = "CPU_CLK";
+			break;
+
+		// don't use default, if someone add a cpu he wants a compiler
+		// warning if he forgets to handle it here.
+		case CPU_TIMER_INT:
+		case CPU_NO_GOOD:
+		case MAX_CPU_TYPE:
+			break;
+	}
+}
diff --git a/libop/op_events.h b/libop/op_events.h
new file mode 100644
index 0000000..f6462fc
--- /dev/null
+++ b/libop/op_events.h
@@ -0,0 +1,125 @@
+/**
+ * @file op_events.h
+ * Details of PMC profiling events
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_EVENTS_H
+#define OP_EVENTS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "op_cpu_type.h"
+#include "op_types.h"
+#include "op_list.h"
+
+/** Describe an unit mask type. Events can optionally use a filter called
+ * the unit mask. the mask type can be a bitmask or a discrete value */
+enum unit_mask_type {
+	utm_mandatory,		/**< useless but required by the hardware */
+	utm_exclusive,		/**< only one of the values is allowed */
+	utm_bitmask		/**< bitmask */
+};
+
+/** up to thirty two allowed unit masks */
+#define MAX_UNIT_MASK 32
+
+
+/** Describe an unit mask. */
+struct op_unit_mask {
+	char * name;		/**< name of unit mask type */
+	u32 num;		/**< number of possible unit masks */
+	enum unit_mask_type unit_type_mask;
+	u32 default_mask;	/**< only the gui use it */
+	struct op_described_um {
+		u32 value;
+		char * desc;
+	} um[MAX_UNIT_MASK];
+	struct list_head um_next; /**< next um in list */
+	int used;                 /**< used by events file parser */
+};
+
+
+/** Describe an event. */
+struct op_event {
+	u32 counter_mask;	/**< bitmask of allowed counter  */
+	u32 val;		/**< event number */
+	/** which unit mask if any allowed */
+	struct op_unit_mask * unit;			
+	char * name;		/**< the event name */
+	char * desc;      	/**< the event description */
+	int min_count;		/**< minimum counter value allowed */
+	struct list_head event_next;   /**< next event in list */
+};
+
+/** Return the known events list. Idempotent */
+struct list_head * op_events(op_cpu cpu_type);
+
+/** Find a given event, returns NULL on error */
+struct op_event * op_find_event(op_cpu cpu_type, u32 nr);
+
+/** Find a given event by name */
+struct op_event * find_event_by_name(char const * name);
+
+/**
+ * Find a mapping for a given event ID for architectures requiring additional information
+ * from what is held in the events file. 
+ */
+char const * find_mapping_for_event(u32 val, op_cpu cpu_type);
+
+
+/** op_check_events() return code */
+enum op_event_check {
+	OP_OK_EVENT = 0, /**< event is valid and allowed */
+	OP_INVALID_EVENT = 1, /**< event number is invalid */
+	OP_INVALID_UM = 2, /**< unit mask is invalid */
+	OP_INVALID_COUNTER = 4 /**< event is not allowed for the given counter */
+};
+
+/**
+ * sanity check event values
+ * @param ctr counter number
+ * @param event value for counter
+ * @param um unit mask for counter
+ * @param cpu_type processor type
+ *
+ * Check that the counter event and unit mask values are allowed.
+ *
+ * The function returns bitmask of failure cause 0 otherwise
+ *
+ * \sa op_cpu, OP_EVENTS_OK
+ */
+int op_check_events(int ctr, u32 event, u32 um, op_cpu cpu_type);
+
+/**
+ * free memory used by any call to above function. Need to be called only once
+ */
+void op_free_events(void);
+
+struct op_default_event_descr {
+	char * name;
+	unsigned long count;
+	unsigned long um;
+};
+
+/**
+ * op_default_event - return the details of the default event
+ * @param cpu_type  cpu type
+ * @param descr filled event description
+ *
+ * Fills in the event description if applicable
+ */
+void op_default_event(op_cpu cpu_type, struct op_default_event_descr * descr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_EVENTS_H */
diff --git a/libop/op_get_interface.c b/libop/op_get_interface.c
new file mode 100644
index 0000000..bdf72a5
--- /dev/null
+++ b/libop/op_get_interface.c
@@ -0,0 +1,32 @@
+/**
+ * @file op_get_interface.c
+ * Determine which oprofile kernel interface used
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Will Cohen
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "op_cpu_type.h"
+#include "op_file.h"
+
+op_interface op_get_interface(void)
+{
+	static op_interface current_interface = OP_INTERFACE_NO_GOOD;
+
+	if (current_interface != OP_INTERFACE_NO_GOOD)
+		return current_interface;
+
+	if (op_file_readable("/proc/sys/dev/oprofile/cpu_type")) {
+		current_interface = OP_INTERFACE_24;
+	} else if (op_file_readable("/dev/oprofile/cpu_type")) {
+		current_interface = OP_INTERFACE_26;
+	}
+
+	return current_interface;
+}
diff --git a/libop/op_hw_config.h b/libop/op_hw_config.h
new file mode 100644
index 0000000..169b36b
--- /dev/null
+++ b/libop/op_hw_config.h
@@ -0,0 +1,30 @@
+/**
+ * @file op_hw_config.h
+ * Configuration parameters that are dependent on CPU/architecture
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_HW_CONFIG_H
+#define OP_HW_CONFIG_H
+
+/** maximum number of counters, up to 4 for Athlon (18 for P4). The primary
+ * use of this variable is for static/local array dimension. Never use it in
+ * loop or in array index access/index checking unless you know what you
+ * made. */
+#ifdef __alpha__
+#define OP_MAX_COUNTERS	20
+#else
+#define OP_MAX_COUNTERS	8
+#endif
+
+/** maximum number of events between interrupts. Counters are 40 bits, but
+ * for convenience we only use 32 bits. The top bit is used for overflow
+ * detection, so user can set up to (2^31)-1 */
+#define OP_MAX_PERF_COUNT	2147483647UL
+
+#endif /* OP_HW_CONFIG_H */
diff --git a/libop/op_interface.h b/libop/op_interface.h
new file mode 100644
index 0000000..fa2ecbd
--- /dev/null
+++ b/libop/op_interface.h
@@ -0,0 +1,87 @@
+/**
+ * @file op_interface.h
+ *
+ * Module / user space interface for 2.4
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_INTERFACE_H
+#define OP_INTERFACE_H
+
+#include "op_config.h"
+#include "op_types.h"
+
+/*@{\name notifications types encoded in op_note::type */
+/** fork(),vfork(),clone() */
+#define OP_FORK 1
+/** mapping */
+#define OP_MAP 2
+/** execve() */
+#define OP_EXEC 4
+/** init_module() */
+#define OP_DROP_MODULES 8
+/** exit() */
+#define OP_EXIT 16
+/*@}*/
+
+/** Data type to transfer samples counts from the module to the daemon */
+struct op_sample {
+	unsigned long eip; /**< eip value where occur interrupt */
+	u32 counter; /**< counter nr */
+	u32 pid; /**< 32 bits can hold any pid */
+	u32 tgid; /**< always equal to pid for kernel < 2.4.0 */
+};
+
+/** the current kernel-side profiler state */
+enum oprof_state {
+	STOPPED = 0,
+	STOPPING = 1,
+	RUNNING = 2
+};
+ 
+/**
+ * The head structure of a kernel sample buffer.
+ */
+struct op_buffer_head {
+	int cpu_nr; /**< the CPU number of this buffer */
+	size_t count; /**< number of samples in this buffer */
+	enum oprof_state state; /**< current profiler state */
+	struct op_sample buffer[0]; /**< the sample buffer */
+} __attribute__((__packed__));
+	 
+/**
+ * Data type used by the module to notify daemon of fork/exit/mapping etc.
+ * Meanings of fields depend on the type of notification encoded in the type
+ * field.
+ * \sa OP_FORK, OP_EXEC, OP_MAP, OP_DROP_MODULES and OP_EXIT
+ */
+struct op_note {
+	unsigned long   addr;
+	unsigned long   len;
+	unsigned long   offset;
+	unsigned int    hash;
+	unsigned int	pid;
+	unsigned int    tgid;
+	unsigned short	type;
+};
+
+/**
+ * A path component. Directory name are stored as a stack of path components.
+ * Note than the name index acts also as an unique identifier
+ */
+struct op_hash_index {
+	/** index inside the string pool */
+	u32 name;
+	/** parent component, zero if this component is the root */
+	u32 parent;
+} __attribute__((__packed__));
+
+/** size of hash map in bytes */
+#define OP_HASH_MAP_SIZE (OP_HASH_MAP_NR * sizeof(struct op_hash_index) + POOL_SIZE)
+
+#endif /* OP_INTERFACE_H */
diff --git a/libop/op_mangle.c b/libop/op_mangle.c
new file mode 100644
index 0000000..1efe5b1
--- /dev/null
+++ b/libop/op_mangle.c
@@ -0,0 +1,104 @@
+/**
+ * @file op_mangle.c
+ * Mangling of sample file names
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "op_mangle.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "op_libiberty.h"
+
+#include "op_sample_file.h"
+#include "op_config.h"
+
+static void append_image(char * dest, int flags, int anon, char const * name, char const * anon_name)
+{
+	if ((flags & MANGLE_KERNEL) && !strchr(name, '/')) {
+		strcat(dest, "{kern}/");
+	} else if (anon) {
+		strcat(dest, "{anon:");
+		strcat(dest, anon_name);
+		strcat(dest,"}/");
+	} else {
+		strcat(dest, "{root}/");
+	}
+
+	strcat(dest, name);
+	strcat(dest, "/");
+}
+
+char * op_mangle_filename(struct mangle_values const * values)
+{
+	char * mangled;
+	size_t len;
+	int anon = values->flags & MANGLE_ANON;
+	int cg_anon = values->flags & MANGLE_CG_ANON;
+	/* if dep_name != image_name we need to invert them (and so revert them
+	 * unconditionally because if they are equal it doesn't hurt to invert
+	 * them), see P:3, FIXME: this is a bit weirds, we prolly need to
+	 * reword pp_interface */
+	char const * image_name = values->dep_name;
+	char const * anon_name = values->anon_name;
+	char const * dep_name = values->image_name;
+	char const * cg_image_name = values->cg_image_name;
+
+	len = strlen(op_samples_current_dir) + strlen(dep_name) + 1
+		+ strlen(values->event_name) + 1 + strlen(image_name) + 1;
+
+	if (values->flags & MANGLE_CALLGRAPH)
+		len += strlen(cg_image_name) + 1;
+
+	if (anon || cg_anon)
+		len += strlen(anon_name);
+
+	/* provision for tgid, tid, unit_mask, cpu and some {root}, {dep},
+	 * {kern}, {anon} and {cg} marker */
+	/* FIXME: too ugly */
+	len += 256;
+
+	mangled = xmalloc(len);
+
+	strcpy(mangled, op_samples_current_dir);
+	append_image(mangled, values->flags, 0, image_name, anon_name);
+
+	strcat(mangled, "{dep}" "/");
+	append_image(mangled, values->flags, anon, dep_name, anon_name);
+
+	if (values->flags & MANGLE_CALLGRAPH) {
+		strcat(mangled, "{cg}" "/");
+		append_image(mangled, values->flags, cg_anon,
+		             cg_image_name, anon_name);
+	}
+
+	strcat(mangled, values->event_name);
+	sprintf(mangled + strlen(mangled), ".%d.%d.",
+	        values->count, values->unit_mask);
+
+	if (values->flags & MANGLE_TGID) {
+		sprintf(mangled + strlen(mangled), "%d.", values->tgid);
+	} else {
+		sprintf(mangled + strlen(mangled), "%s.", "all");
+	}
+
+	if (values->flags & MANGLE_TID) {
+		sprintf(mangled + strlen(mangled), "%d.", values->tid);
+	} else {
+		sprintf(mangled + strlen(mangled), "%s.", "all");
+	}
+
+	if (values->flags & MANGLE_CPU) {
+		sprintf(mangled + strlen(mangled), "%d", values->cpu);
+	} else {
+		sprintf(mangled + strlen(mangled), "%s", "all");
+	}
+
+	return mangled;
+}
diff --git a/libop/op_mangle.h b/libop/op_mangle.h
new file mode 100644
index 0000000..9b600dc
--- /dev/null
+++ b/libop/op_mangle.h
@@ -0,0 +1,66 @@
+/**
+ * @file op_mangle.h
+ * Mangling of sample file names
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_MANGLE_H
+#define OP_MANGLE_H
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum mangle_flags {
+	MANGLE_NONE      = 0,
+	MANGLE_CPU       = (1 << 0),
+	MANGLE_TGID      = (1 << 1),
+	MANGLE_TID       = (1 << 2),
+	MANGLE_KERNEL    = (1 << 3),
+	MANGLE_CALLGRAPH = (1 << 4),
+	MANGLE_ANON      = (1 << 5),
+	MANGLE_CG_ANON   = (1 << 6),
+};
+
+/**
+ * Temporary structure for passing parameters to
+ * op_mangle_filename.
+ */
+struct mangle_values {
+	int flags;
+
+	char const * image_name;
+	char const * anon_name;
+	char const * dep_name;
+	char const * cg_image_name;
+	char const * event_name;
+	int count;
+	unsigned int unit_mask;
+	pid_t tgid;
+	pid_t tid;
+	int cpu;
+};
+
+/**
+ * op_mangle_filename - mangle a sample filename
+ * @param values  parameters to use as mangling input
+ *
+ * See also PP:3 for the encoding scheme
+ *
+ * Returns a char* pointer to the mangled string. Caller
+ * is responsible for freeing this string.
+ */
+char * op_mangle_filename(struct mangle_values const * values);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_MANGLE_H */
diff --git a/libop/op_parse_event.c b/libop/op_parse_event.c
new file mode 100644
index 0000000..920d617
--- /dev/null
+++ b/libop/op_parse_event.c
@@ -0,0 +1,120 @@
+/**
+ * @file op_parse_event.c
+ * event parsing
+ *
+ * You can have silliness here.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "op_parse_event.h"
+#include "op_string.h"
+
+static char * next_part(char const ** str)
+{
+	char const * c;
+	char * ret;
+
+	if ((*str)[0] == '\0')
+		return NULL;
+
+	if ((*str)[0] == ':')
+		++(*str);
+
+	c = *str;
+
+	while (*c != '\0' && *c != ':')
+		++c;
+
+	if (c == *str)
+		return NULL;
+
+	ret = op_xstrndup(*str, c - *str);
+	*str += c - *str;
+	return ret;
+}
+
+
+static int parse_ulong(char const * str)
+{
+	unsigned long value;
+	char * end;
+	value = strtoul(str, &end, 0);
+	if (end && *end) {
+		fprintf(stderr, "Invalid event part %s\n", str);
+		exit(EXIT_FAILURE);
+	}
+
+	return value;
+}
+
+
+size_t parse_events(struct parsed_event * parsed_events, size_t max_events,
+                  char const * const * events)
+{
+	size_t i = 0;
+
+	while (events[i]) {
+		char const * cp = events[i];
+		char * part = next_part(&cp);
+
+		if (i >= max_events) {
+			fprintf(stderr, "Too many events specified: CPU "
+			        "only has %lu counters.\n",
+				(unsigned long) max_events);
+			exit(EXIT_FAILURE);
+		}
+
+		if (!part) {
+			fprintf(stderr, "Invalid event %s\n", cp);
+			exit(EXIT_FAILURE);
+		}
+
+		parsed_events[i].name = part;
+
+		part = next_part(&cp);
+
+		if (!part) {
+			fprintf(stderr, "Invalid count for event %s\n", events[i]);
+			exit(EXIT_FAILURE);
+		}
+
+		parsed_events[i].count = parse_ulong(part);
+		free(part);
+
+		parsed_events[i].unit_mask = 0;
+		part = next_part(&cp);
+
+		if (part) {
+			parsed_events[i].unit_mask = parse_ulong(part);
+			free(part);
+		}
+
+		parsed_events[i].kernel = 1;
+		part = next_part(&cp);
+
+		if (part) {
+			parsed_events[i].kernel = parse_ulong(part);
+			free(part);
+		}
+
+		parsed_events[i].user = 1;
+		part = next_part(&cp);
+
+		if (part) {
+			parsed_events[i].user = parse_ulong(part);
+			free(part);
+		}
+	
+		++i;
+	}
+
+	return i;
+}
diff --git a/libop/op_parse_event.h b/libop/op_parse_event.h
new file mode 100644
index 0000000..247a355
--- /dev/null
+++ b/libop/op_parse_event.h
@@ -0,0 +1,42 @@
+/**
+ * @file op_parse_event.h
+ * event parsing
+ *
+ * You can have silliness here.
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_PARSE_EVENT_H
+#define OP_PARSE_EVENT_H
+
+#include <stddef.h>
+
+struct parsed_event {
+	char * name;
+	int count;
+	int unit_mask;
+	int kernel;
+	int user;
+};
+
+/**
+ * @param parsed_events  array of events to fill in
+ * @param max_events  size of parsed_events
+ * @param events  null terminated array of events string on the form
+ *   event_name:count[:unit_mask:kernel:user]
+ *
+ * parse events given by the nil terminated array events and fill in
+ * parsed_events with results. Events validity are not checked except.
+ * A fatal error occur if number of events is greater than max_events.
+ *
+ * Return the number of events parsed.
+ */
+size_t parse_events(struct parsed_event * parsed_events, size_t max_events,
+                    char const * const * events);
+
+#endif /* !OP_PARSE_EVENT_H */
diff --git a/libop/op_sample_file.h b/libop/op_sample_file.h
new file mode 100644
index 0000000..4f9f1d0
--- /dev/null
+++ b/libop/op_sample_file.h
@@ -0,0 +1,42 @@
+/**
+ * @file op_sample_file.h
+ * Sample file format
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_SAMPLE_FILE_H
+#define OP_SAMPLE_FILE_H
+
+#include "op_types.h"
+
+#include <stdint.h>
+#include <time.h>
+
+/* header of the sample files */
+struct opd_header {
+	u8 magic[4];
+	u32 version;
+	u32 cpu_type;
+	u32 ctr_event;
+	u32 ctr_um;
+	u32 ctr_count;
+	// for cg file the from_cg_is_kernel
+	u32 is_kernel;
+	double cpu_speed;
+	time_t mtime;
+	u32 cg_to_is_kernel;
+	/* spu_profile=1 says sample file contains Cell BE SPU profile data */
+	u32 spu_profile;
+	uint64_t embedded_offset;
+	u64 anon_start;
+	u64 cg_to_anon_start;
+	/* binary compatibility reserve */
+	u32 reserved1[1];
+};
+
+#endif /* OP_SAMPLE_FILE_H */
diff --git a/libpopt/Android.mk b/libpopt/Android.mk
new file mode 100644
index 0000000..b20cf55
--- /dev/null
+++ b/libpopt/Android.mk
@@ -0,0 +1,15 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	findme.c \
+	popt.c \
+	poptconfig.c \
+	popthelp.c \
+	poptparse.c
+
+LOCAL_CFLAGS += -DHAVE_CONFIG_H
+
+LOCAL_MODULE := libpopt
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/libpopt/config.h b/libpopt/config.h
new file mode 100644
index 0000000..73a0817
--- /dev/null
+++ b/libpopt/config.h
@@ -0,0 +1,329 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
+   systems. This function is required for `alloca.c' support on those systems.
+   */
+#undef CRAY_STACKSEG_END
+
+/* Define to 1 if using `alloca.c'. */
+#undef C_ALLOCA
+
+/* Define to 1 if translation of program messages to the user's native
+   language is requested. */
+#undef ENABLE_NLS
+
+/* Define to 1 if you have `alloca', as a function or macro. */
+#undef HAVE_ALLOCA
+
+/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
+   */
+#undef HAVE_ALLOCA_H
+
+/* Define to 1 if you have the <argz.h> header file. */
+#undef HAVE_ARGZ_H
+
+/* Define to 1 if you have the `asprintf' function. */
+#undef HAVE_ASPRINTF
+
+/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the
+   CoreFoundation framework. */
+#undef HAVE_CFLOCALECOPYCURRENT
+
+/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in
+   the CoreFoundation framework. */
+#undef HAVE_CFPREFERENCESCOPYAPPVALUE
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+#undef HAVE_DCGETTEXT
+
+/* Define to 1 if you have the declaration of `feof_unlocked', and to 0 if you
+   don't. */
+#undef HAVE_DECL_FEOF_UNLOCKED
+
+/* Define to 1 if you have the declaration of `fgets_unlocked', and to 0 if
+   you don't. */
+#undef HAVE_DECL_FGETS_UNLOCKED
+
+/* Define to 1 if you have the declaration of `getc_unlocked', and to 0 if you
+   don't. */
+#undef HAVE_DECL_GETC_UNLOCKED
+
+/* Define to 1 if you have the declaration of `_snprintf', and to 0 if you
+   don't. */
+#undef HAVE_DECL__SNPRINTF
+
+/* Define to 1 if you have the declaration of `_snwprintf', and to 0 if you
+   don't. */
+#undef HAVE_DECL__SNWPRINTF
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <float.h> header file. */
+#define HAVE_FLOAT_H 1
+
+/* Define to 1 if you have the `fwprintf' function. */
+#undef HAVE_FWPRINTF
+
+/* Define to 1 if you have the `getcwd' function. */
+#undef HAVE_GETCWD
+
+/* Define to 1 if you have the `getegid' function. */
+#undef HAVE_GETEGID
+
+/* Define to 1 if you have the `geteuid' function. */
+#undef HAVE_GETEUID
+
+/* Define to 1 if you have the `getgid' function. */
+#undef HAVE_GETGID
+
+/* Define to 1 if you have the `getpagesize' function. */
+#undef HAVE_GETPAGESIZE
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+#undef HAVE_GETTEXT
+
+/* Define to 1 if you have the `getuid' function. */
+#undef HAVE_GETUID
+
+/* Define if you have the iconv() function. */
+#undef HAVE_ICONV
+
+/* Define if you have the 'intmax_t' type in <stdint.h> or <inttypes.h>. */
+#undef HAVE_INTMAX_T
+
+/* Define if <inttypes.h> exists and doesn't clash with <sys/types.h>. */
+#define HAVE_INTTYPES_H 1
+
+/* Define if <inttypes.h> exists, doesn't clash with <sys/types.h>, and
+   declares uintmax_t. */
+#undef HAVE_INTTYPES_H_WITH_UINTMAX
+
+/* Define if you have <langinfo.h> and nl_langinfo(CODESET). */
+#undef HAVE_LANGINFO_CODESET
+
+/* Define if your <locale.h> file defines LC_MESSAGES. */
+#undef HAVE_LC_MESSAGES
+
+/* Define to 1 if you have the <libintl.h> header file. */
+#undef HAVE_LIBINTL_H
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <locale.h> header file. */
+#undef HAVE_LOCALE_H
+
+/* Define if you have the 'long double' type. */
+#undef HAVE_LONG_DOUBLE
+
+/* Define if you have the 'long long' type. */
+#define HAVE_LONG_LONG 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
+
+/* Define to 1 if you have the <mcheck.h> header file. */
+#undef HAVE_MCHECK_H
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `mempcpy' function. */
+#define HAVE_MEMPCPY 1
+
+/* Define to 1 if you have a working `mmap' system call. */
+#define HAVE_MMAP 1
+
+/* Define to 1 if you have the `mtrace' function. */
+#undef HAVE_MTRACE
+
+/* Define to 1 if you have the `munmap' function. */
+#define HAVE_MUNMAP 1
+
+/* Define to 1 if you have the <nl_types.h> header file. */
+#undef HAVE_NL_TYPES_H
+
+/* Define if your printf() function supports format strings with positions. */
+#define HAVE_POSIX_PRINTF 1
+
+/* Define to 1 if you have the `putenv' function. */
+#undef HAVE_PUTENV
+
+/* Define to 1 if you have the `setenv' function. */
+#undef HAVE_SETENV
+
+/* Define to 1 if you have the `setlocale' function. */
+#undef HAVE_SETLOCALE
+
+/* Define to 1 if you have the `setregid' function. */
+#undef HAVE_SETREGID
+
+/* Define to 1 if you have the `snprintf' function. */
+#define HAVE_SNPRINTF 1
+
+/* Define to 1 if you have the <stddef.h> header file. */
+#define HAVE_STDDEF_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define if <stdint.h> exists, doesn't clash with <sys/types.h>, and declares
+   uintmax_t. */
+#undef HAVE_STDINT_H_WITH_UINTMAX
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `stpcpy' function. */
+#undef HAVE_STPCPY
+
+/* Define to 1 if you have the `strcasecmp' function. */
+#undef HAVE_STRCASECMP
+
+/* Define to 1 if you have the `strdup' function. */
+#undef HAVE_STRDUP
+
+/* Define to 1 if you have the `strerror' function. */
+#define HAVE_STRERROR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the `strtoul' function. */
+#undef HAVE_STRTOUL
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#undef HAVE_SYS_PARAM_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the `tsearch' function. */
+#undef HAVE_TSEARCH
+
+/* Define if you have the 'uintmax_t' type in <stdint.h> or <inttypes.h>. */
+#undef HAVE_UINTMAX_T
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define if you have the 'unsigned long long' type. */
+#undef HAVE_UNSIGNED_LONG_LONG
+
+/* Define if you have the 'wchar_t' type. */
+#undef HAVE_WCHAR_T
+
+/* Define to 1 if you have the `wcslen' function. */
+#undef HAVE_WCSLEN
+
+/* Define if you have the 'wint_t' type. */
+#undef HAVE_WINT_T
+
+/* Define to 1 if you have the `__argz_count' function. */
+#undef HAVE___ARGZ_COUNT
+
+/* Define to 1 if you have the `__argz_next' function. */
+#undef HAVE___ARGZ_NEXT
+
+/* Define to 1 if you have the `__argz_stringify' function. */
+#undef HAVE___ARGZ_STRINGIFY
+
+/* Define to 1 if you have the `__fsetlocking' function. */
+#undef HAVE___FSETLOCKING
+
+/* Define to 1 if you have the `__secure_getenv' function. */
+#undef HAVE___SECURE_GETENV
+
+/* Define as const if the declaration of iconv() needs const. */
+#undef ICONV_CONST
+
+/* Define if integer division by zero raises signal SIGFPE. */
+#undef INTDIV0_RAISES_SIGFPE
+
+/* Name of package */
+#define PACKAGE "popt"
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Full path to popt top_srcdir. */
+#undef POPT_SOURCE_PATH
+
+/* Define if <inttypes.h> exists and defines unusable PRI* macros. */
+#undef PRI_MACROS_BROKEN
+
+/* Define to 1 if the C compiler supports function prototypes. */
+#undef PROTOTYPES
+
+/* Define as the maximum value of type 'size_t', if the system doesn't define
+   it. */
+#undef SIZE_MAX
+
+/* If using the C implementation of alloca, define if you know the
+   direction of stack growth for your system; otherwise it will be
+   automatically deduced at run-time.
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown */
+#undef STACK_DIRECTION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+#undef _FILE_OFFSET_BITS
+
+/* Define for large files, on AIX-style hosts. */
+#undef _LARGE_FILES
+
+/* Define like PROTOTYPES; this can be used by system headers. */
+#undef __PROTOTYPES
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#undef const
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+#undef inline
+#endif
+
+/* Define to `long' if <sys/types.h> does not define. */
+#undef off_t
+
+/* Define as the type of the result of subtracting two pointers, if the system
+   doesn't define it. */
+#undef ptrdiff_t
+
+/* Define to empty if the C compiler doesn't support this keyword. */
+#undef signed
+
+/* Define to `unsigned' if <sys/types.h> does not define. */
+#undef size_t
+
+/* Define to unsigned long or unsigned long long if <stdint.h> and
+   <inttypes.h> don't define. */
+#undef uintmax_t
diff --git a/libpopt/findme.c b/libpopt/findme.c
new file mode 100644
index 0000000..78363e5
--- /dev/null
+++ b/libpopt/findme.c
@@ -0,0 +1,52 @@
+/** \ingroup popt
+ * \file popt/findme.c
+ */
+
+/* (C) 1998-2002 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+#include "findme.h"
+#include <unistd.h>
+
+const char * findProgramPath(const char * argv0)
+{
+    char * path = getenv("PATH");
+    char * pathbuf;
+    char * start, * chptr;
+    char * buf;
+
+    if (argv0 == NULL) return NULL;	/* XXX can't happen */
+    /* If there is a / in the argv[0], it has to be an absolute path */
+    if (strchr(argv0, '/'))
+	return xstrdup(argv0);
+
+    if (path == NULL) return NULL;
+
+    start = pathbuf = alloca(strlen(path) + 1);
+    buf = malloc(strlen(path) + strlen(argv0) + sizeof("/"));
+    if (buf == NULL) return NULL;	/* XXX can't happen */
+    strcpy(pathbuf, path);
+
+    chptr = NULL;
+    /*@-branchstate@*/
+    do {
+	if ((chptr = strchr(start, ':')))
+	    *chptr = '\0';
+	sprintf(buf, "%s/%s", start, argv0);
+
+	if (!access(buf, X_OK))
+	    return buf;
+
+	if (chptr) 
+	    start = chptr + 1;
+	else
+	    start = NULL;
+    } while (start && *start);
+    /*@=branchstate@*/
+
+    free(buf);
+
+    return NULL;
+}
diff --git a/libpopt/findme.h b/libpopt/findme.h
new file mode 100644
index 0000000..a016b86
--- /dev/null
+++ b/libpopt/findme.h
@@ -0,0 +1,20 @@
+/** \ingroup popt
+ * \file popt/findme.h
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_FINDME
+#define H_FINDME
+
+/**
+ * Return absolute path to executable by searching PATH.
+ * @param argv0		name of executable
+ * @return		(malloc'd) absolute path to executable (or NULL)
+ */
+/*@null@*/ const char * findProgramPath(/*@null@*/ const char * argv0)
+	/*@*/;
+
+#endif
diff --git a/libpopt/popt.c b/libpopt/popt.c
new file mode 100644
index 0000000..4f9e325
--- /dev/null
+++ b/libpopt/popt.c
@@ -0,0 +1,1262 @@
+/** \ingroup popt
+ * \file popt/popt.c
+ */
+
+/* (C) 1998-2002 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from
+   ftp://ftp.rpm.org/pub/rpm/dist */
+
+#undef	MYDEBUG
+
+#include "system.h"
+
+#if HAVE_FLOAT_H
+#include <float.h>
+#endif
+#include <math.h>
+
+#include "findme.h"
+#include "poptint.h"
+
+#ifdef	MYDEBUG
+/*@unchecked@*/
+int _popt_debug = 0;
+#endif
+
+#if !defined(HAVE_STRERROR) && !defined(__LCLINT__)
+static char * strerror(int errno)
+{
+    extern int sys_nerr;
+    extern char * sys_errlist[];
+
+    if ((0 <= errno) && (errno < sys_nerr))
+	return sys_errlist[errno];
+    else
+	return POPT_("unknown errno");
+}
+#endif
+
+#ifdef MYDEBUG
+/*@unused@*/
+static void prtcon(const char *msg, poptContext con)
+{
+    if (msg) fprintf(stderr, "%s", msg);
+    fprintf(stderr, "\tcon %p os %p nextCharArg \"%s\" nextArg \"%s\" argv[%d] \"%s\"\n",
+	con, con->os,
+	(con->os->nextCharArg ? con->os->nextCharArg : ""),
+	(con->os->nextArg ? con->os->nextArg : ""),
+	con->os->next,
+	(con->os->argv && con->os->argv[con->os->next]
+		? con->os->argv[con->os->next] : ""));
+}
+#endif
+
+void poptSetExecPath(poptContext con, const char * path, int allowAbsolute)
+{
+    con->execPath = _free(con->execPath);
+    con->execPath = xstrdup(path);
+    con->execAbsolute = allowAbsolute;
+    /*@-nullstate@*/ /* LCL: con->execPath not NULL */
+    return;
+    /*@=nullstate@*/
+}
+
+static void invokeCallbacksPRE(poptContext con, const struct poptOption * opt)
+	/*@globals internalState@*/
+	/*@modifies internalState@*/
+{
+    if (opt != NULL)
+    for (; opt->longName || opt->shortName || opt->arg; opt++) {
+	if (opt->arg == NULL) continue;		/* XXX program error. */
+	if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    void * arg = opt->arg;
+/*@-branchstate@*/
+	    /* XXX sick hack to preserve pretense of ABI. */
+	    if (arg == poptHelpOptions) arg = poptHelpOptionsI18N;
+/*@=branchstate@*/
+	    /* Recurse on included sub-tables. */
+	    invokeCallbacksPRE(con, arg);
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_CALLBACK &&
+		   (opt->argInfo & POPT_CBFLAG_PRE))
+	{   /*@-castfcnptr@*/
+	    poptCallbackType cb = (poptCallbackType)opt->arg;
+	    /*@=castfcnptr@*/
+	    /* Perform callback. */
+	    /*@-noeffectuncon @*/
+	    cb(con, POPT_CALLBACK_REASON_PRE, NULL, NULL, opt->descrip);
+	    /*@=noeffectuncon @*/
+	}
+    }
+}
+
+static void invokeCallbacksPOST(poptContext con, const struct poptOption * opt)
+	/*@globals internalState@*/
+	/*@modifies internalState@*/
+{
+    if (opt != NULL)
+    for (; opt->longName || opt->shortName || opt->arg; opt++) {
+	if (opt->arg == NULL) continue;		/* XXX program error. */
+	if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    void * arg = opt->arg;
+/*@-branchstate@*/
+	    /* XXX sick hack to preserve pretense of ABI. */
+	    if (arg == poptHelpOptions) arg = poptHelpOptionsI18N;
+/*@=branchstate@*/
+	    /* Recurse on included sub-tables. */
+	    invokeCallbacksPOST(con, arg);
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_CALLBACK &&
+		   (opt->argInfo & POPT_CBFLAG_POST))
+	{   /*@-castfcnptr@*/
+	    poptCallbackType cb = (poptCallbackType)opt->arg;
+	    /*@=castfcnptr@*/
+	    /* Perform callback. */
+	    /*@-noeffectuncon @*/
+	    cb(con, POPT_CALLBACK_REASON_POST, NULL, NULL, opt->descrip);
+	    /*@=noeffectuncon @*/
+	}
+    }
+}
+
+static void invokeCallbacksOPTION(poptContext con,
+				  const struct poptOption * opt,
+				  const struct poptOption * myOpt,
+				  /*@null@*/ const void * myData, int shorty)
+	/*@globals internalState@*/
+	/*@modifies internalState@*/
+{
+    const struct poptOption * cbopt = NULL;
+
+    if (opt != NULL)
+    for (; opt->longName || opt->shortName || opt->arg; opt++) {
+	if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    void * arg = opt->arg;
+/*@-branchstate@*/
+	    /* XXX sick hack to preserve pretense of ABI. */
+	    if (arg == poptHelpOptions) arg = poptHelpOptionsI18N;
+/*@=branchstate@*/
+	    /* Recurse on included sub-tables. */
+	    if (opt->arg != NULL)	/* XXX program error */
+		invokeCallbacksOPTION(con, opt->arg, myOpt, myData, shorty);
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_CALLBACK &&
+		  !(opt->argInfo & POPT_CBFLAG_SKIPOPTION)) {
+	    /* Save callback info. */
+	    cbopt = opt;
+	} else if (cbopt != NULL &&
+		   ((myOpt->shortName && opt->shortName && shorty &&
+			myOpt->shortName == opt->shortName) ||
+		    (myOpt->longName && opt->longName &&
+		/*@-nullpass@*/		/* LCL: opt->longName != NULL */
+			!strcmp(myOpt->longName, opt->longName)))
+		/*@=nullpass@*/
+		   )
+	{   /*@-castfcnptr@*/
+	    poptCallbackType cb = (poptCallbackType)cbopt->arg;
+	    /*@=castfcnptr@*/
+	    const void * cbData = (cbopt->descrip ? cbopt->descrip : myData);
+	    /* Perform callback. */
+	    if (cb != NULL) {	/* XXX program error */
+		/*@-noeffectuncon @*/
+		cb(con, POPT_CALLBACK_REASON_OPTION, myOpt,
+			con->os->nextArg, cbData);
+		/*@=noeffectuncon @*/
+	    }
+	    /* Terminate (unless explcitly continuing). */
+	    if (!(cbopt->argInfo & POPT_CBFLAG_CONTINUE))
+		return;
+	}
+    }
+}
+
+poptContext poptGetContext(const char * name, int argc, const char ** argv,
+			   const struct poptOption * options, int flags)
+{
+    poptContext con = malloc(sizeof(*con));
+
+    if (con == NULL) return NULL;	/* XXX can't happen */
+    memset(con, 0, sizeof(*con));
+
+    con->os = con->optionStack;
+    con->os->argc = argc;
+    /*@-dependenttrans -assignexpose@*/	/* FIX: W2DO? */
+    con->os->argv = argv;
+    /*@=dependenttrans =assignexpose@*/
+    con->os->argb = NULL;
+
+    if (!(flags & POPT_CONTEXT_KEEP_FIRST))
+	con->os->next = 1;			/* skip argv[0] */
+
+    con->leftovers = calloc( (argc + 1), sizeof(*con->leftovers) );
+    /*@-dependenttrans -assignexpose@*/	/* FIX: W2DO? */
+    con->options = options;
+    /*@=dependenttrans =assignexpose@*/
+    con->aliases = NULL;
+    con->numAliases = 0;
+    con->flags = flags;
+    con->execs = NULL;
+    con->numExecs = 0;
+    con->finalArgvAlloced = argc * 2;
+    con->finalArgv = calloc( con->finalArgvAlloced, sizeof(*con->finalArgv) );
+    con->execAbsolute = 1;
+    con->arg_strip = NULL;
+
+    if (getenv("POSIXLY_CORRECT") || getenv("POSIX_ME_HARDER"))
+	con->flags |= POPT_CONTEXT_POSIXMEHARDER;
+
+    if (name) {
+	char * t = malloc(strlen(name) + 1);
+	if (t) con->appName = strcpy(t, name);
+    }
+
+    /*@-internalglobs@*/
+    invokeCallbacksPRE(con, con->options);
+    /*@=internalglobs@*/
+
+    return con;
+}
+
+static void cleanOSE(/*@special@*/ struct optionStackEntry *os)
+	/*@uses os @*/
+	/*@releases os->nextArg, os->argv, os->argb @*/
+	/*@modifies os @*/
+{
+    os->nextArg = _free(os->nextArg);
+    os->argv = _free(os->argv);
+    os->argb = PBM_FREE(os->argb);
+}
+
+/*@-boundswrite@*/
+void poptResetContext(poptContext con)
+{
+    int i;
+
+    if (con == NULL) return;
+    while (con->os > con->optionStack) {
+	cleanOSE(con->os--);
+    }
+    con->os->argb = PBM_FREE(con->os->argb);
+    con->os->currAlias = NULL;
+    con->os->nextCharArg = NULL;
+    con->os->nextArg = NULL;
+    con->os->next = 1;			/* skip argv[0] */
+
+    con->numLeftovers = 0;
+    con->nextLeftover = 0;
+    con->restLeftover = 0;
+    con->doExec = NULL;
+
+    if (con->finalArgv != NULL)
+    for (i = 0; i < con->finalArgvCount; i++) {
+	/*@-unqualifiedtrans@*/		/* FIX: typedef double indirection. */
+	con->finalArgv[i] = _free(con->finalArgv[i]);
+	/*@=unqualifiedtrans@*/
+    }
+
+    con->finalArgvCount = 0;
+    con->arg_strip = PBM_FREE(con->arg_strip);
+    /*@-nullstate@*/	/* FIX: con->finalArgv != NULL */
+    return;
+    /*@=nullstate@*/
+}
+/*@=boundswrite@*/
+
+/* Only one of longName, shortName should be set, not both. */
+/*@-boundswrite@*/
+static int handleExec(/*@special@*/ poptContext con,
+		/*@null@*/ const char * longName, char shortName)
+	/*@uses con->execs, con->numExecs, con->flags, con->doExec,
+		con->finalArgv, con->finalArgvAlloced, con->finalArgvCount @*/
+	/*@modifies con @*/
+{
+    poptItem item;
+    int i;
+
+    if (con->execs == NULL || con->numExecs <= 0) /* XXX can't happen */
+	return 0;
+
+    for (i = con->numExecs - 1; i >= 0; i--) {
+	item = con->execs + i;
+	if (longName && !(item->option.longName &&
+			!strcmp(longName, item->option.longName)))
+	    continue;
+	else if (shortName != item->option.shortName)
+	    continue;
+	break;
+    }
+    if (i < 0) return 0;
+
+
+    if (con->flags & POPT_CONTEXT_NO_EXEC)
+	return 1;
+
+    if (con->doExec == NULL) {
+	con->doExec = con->execs + i;
+	return 1;
+    }
+
+    /* We already have an exec to do; remember this option for next
+       time 'round */
+    if ((con->finalArgvCount + 1) >= (con->finalArgvAlloced)) {
+	con->finalArgvAlloced += 10;
+	con->finalArgv = realloc(con->finalArgv,
+			sizeof(*con->finalArgv) * con->finalArgvAlloced);
+    }
+
+    i = con->finalArgvCount++;
+    if (con->finalArgv != NULL)	/* XXX can't happen */
+    {	char *s  = malloc((longName ? strlen(longName) : 0) + 3);
+	if (s != NULL) {	/* XXX can't happen */
+	    if (longName)
+		sprintf(s, "--%s", longName);
+	    else
+		sprintf(s, "-%c", shortName);
+	    con->finalArgv[i] = s;
+	} else
+	    con->finalArgv[i] = NULL;
+    }
+
+    /*@-nullstate@*/	/* FIX: con->finalArgv[] == NULL */
+    return 1;
+    /*@=nullstate@*/
+}
+/*@=boundswrite@*/
+
+/* Only one of longName, shortName may be set at a time */
+static int handleAlias(/*@special@*/ poptContext con,
+		/*@null@*/ const char * longName, char shortName,
+		/*@exposed@*/ /*@null@*/ const char * nextCharArg)
+	/*@uses con->aliases, con->numAliases, con->optionStack, con->os,
+		con->os->currAlias, con->os->currAlias->option.longName @*/
+	/*@modifies con @*/
+{
+    poptItem item = con->os->currAlias;
+    int rc;
+    int i;
+
+    if (item) {
+	if (longName && (item->option.longName &&
+		!strcmp(longName, item->option.longName)))
+	    return 0;
+	if (shortName && shortName == item->option.shortName)
+	    return 0;
+    }
+
+    if (con->aliases == NULL || con->numAliases <= 0) /* XXX can't happen */
+	return 0;
+
+    for (i = con->numAliases - 1; i >= 0; i--) {
+	item = con->aliases + i;
+	if (longName && !(item->option.longName &&
+			!strcmp(longName, item->option.longName)))
+	    continue;
+	else if (shortName != item->option.shortName)
+	    continue;
+	break;
+    }
+    if (i < 0) return 0;
+
+    if ((con->os - con->optionStack + 1) == POPT_OPTION_DEPTH)
+	return POPT_ERROR_OPTSTOODEEP;
+
+/*@-boundsread@*/
+    if (nextCharArg && *nextCharArg)
+	con->os->nextCharArg = nextCharArg;
+/*@=boundsread@*/
+
+    con->os++;
+    con->os->next = 0;
+    con->os->stuffed = 0;
+    con->os->nextArg = NULL;
+    con->os->nextCharArg = NULL;
+    con->os->currAlias = con->aliases + i;
+    rc = poptDupArgv(con->os->currAlias->argc, con->os->currAlias->argv,
+		&con->os->argc, &con->os->argv);
+    con->os->argb = NULL;
+
+    return (rc ? rc : 1);
+}
+
+/*@-bounds -boundswrite @*/
+static int execCommand(poptContext con)
+	/*@globals internalState @*/
+	/*@modifies internalState @*/
+{
+    poptItem item = con->doExec;
+    const char ** argv;
+    int argc = 0;
+    int rc;
+
+    if (item == NULL) /*XXX can't happen*/
+	return POPT_ERROR_NOARG;
+
+    if (item->argv == NULL || item->argc < 1 ||
+	(!con->execAbsolute && strchr(item->argv[0], '/')))
+	    return POPT_ERROR_NOARG;
+
+    argv = malloc(sizeof(*argv) *
+			(6 + item->argc + con->numLeftovers + con->finalArgvCount));
+    if (argv == NULL) return POPT_ERROR_MALLOC;
+
+    if (!strchr(item->argv[0], '/') && con->execPath != NULL) {
+	char *s = alloca(strlen(con->execPath) + strlen(item->argv[0]) + sizeof("/"));
+	sprintf(s, "%s/%s", con->execPath, item->argv[0]);
+	argv[argc] = s;
+    } else
+	argv[argc] = findProgramPath(item->argv[0]);
+    if (argv[argc++] == NULL) return POPT_ERROR_NOARG;
+
+    if (item->argc > 1) {
+	memcpy(argv + argc, item->argv + 1, sizeof(*argv) * (item->argc - 1));
+	argc += (item->argc - 1);
+    }
+
+    if (con->finalArgv != NULL && con->finalArgvCount > 0) {
+	memcpy(argv + argc, con->finalArgv,
+		sizeof(*argv) * con->finalArgvCount);
+	argc += con->finalArgvCount;
+    }
+
+    if (con->leftovers != NULL && con->numLeftovers > 0) {
+	memcpy(argv + argc, con->leftovers, sizeof(*argv) * con->numLeftovers);
+	argc += con->numLeftovers;
+    }
+
+    argv[argc] = NULL;
+
+#if defined(hpux) || defined(__hpux)
+    rc = setresgid(getgid(), getgid(),-1);
+    if (rc) return POPT_ERROR_ERRNO;
+    rc = setresuid(getuid(), getuid(),-1);
+    if (rc) return POPT_ERROR_ERRNO;
+#else
+/*
+ * XXX " ... on BSD systems setuid() should be preferred over setreuid()"
+ * XXX 	sez' Timur Bakeyev <mc@bat.ru>
+ * XXX	from Norbert Warmuth <nwarmuth@privat.circular.de>
+ */
+#if defined(HAVE_SETUID)
+    rc = setgid(getgid());
+    if (rc) return POPT_ERROR_ERRNO;
+    rc = setuid(getuid());
+    if (rc) return POPT_ERROR_ERRNO;
+#elif defined (HAVE_SETREUID)
+    rc = setregid(getgid(), getgid());
+    if (rc) return POPT_ERROR_ERRNO;
+    rc = setreuid(getuid(), getuid());
+    if (rc) return POPT_ERROR_ERRNO;
+#else
+    ; /* Can't drop privileges */
+#endif
+#endif
+
+    if (argv[0] == NULL)
+	return POPT_ERROR_NOARG;
+
+#ifdef	MYDEBUG
+if (_popt_debug)
+    {	const char ** avp;
+	fprintf(stderr, "==> execvp(%s) argv[%d]:", argv[0], argc);
+	for (avp = argv; *avp; avp++)
+	    fprintf(stderr, " '%s'", *avp);
+	fprintf(stderr, "\n");
+    }
+#endif
+
+    rc = execvp(argv[0], (char *const *)argv);
+
+    return POPT_ERROR_ERRNO;
+}
+/*@=bounds =boundswrite @*/
+
+/*@-boundswrite@*/
+/*@observer@*/ /*@null@*/ static const struct poptOption *
+findOption(const struct poptOption * opt, /*@null@*/ const char * longName,
+		char shortName,
+		/*@null@*/ /*@out@*/ poptCallbackType * callback,
+		/*@null@*/ /*@out@*/ const void ** callbackData,
+		int singleDash)
+	/*@modifies *callback, *callbackData */
+{
+    const struct poptOption * cb = NULL;
+
+    /* This happens when a single - is given */
+    if (singleDash && !shortName && (longName && *longName == '\0'))
+	shortName = '-';
+
+    for (; opt->longName || opt->shortName || opt->arg; opt++) {
+
+	if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    const struct poptOption * opt2;
+	    void * arg = opt->arg;
+
+/*@-branchstate@*/
+	    /* XXX sick hack to preserve pretense of ABI. */
+	    if (arg == poptHelpOptions) arg = poptHelpOptionsI18N;
+/*@=branchstate@*/
+	    /* Recurse on included sub-tables. */
+	    if (arg == NULL) continue;	/* XXX program error */
+	    opt2 = findOption(arg, longName, shortName, callback,
+			      callbackData, singleDash);
+	    if (opt2 == NULL) continue;
+	    /* Sub-table data will be inheirited if no data yet. */
+	    if (!(callback && *callback)) return opt2;
+	    if (!(callbackData && *callbackData == NULL)) return opt2;
+	    /*@-observertrans -dependenttrans @*/
+	    *callbackData = opt->descrip;
+	    /*@=observertrans =dependenttrans @*/
+	    return opt2;
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_CALLBACK) {
+	    cb = opt;
+	} else if (longName && opt->longName &&
+		   (!singleDash || (opt->argInfo & POPT_ARGFLAG_ONEDASH)) &&
+		/*@-nullpass@*/		/* LCL: opt->longName != NULL */
+		   !strcmp(longName, opt->longName))
+		/*@=nullpass@*/
+	{
+	    break;
+	} else if (shortName && shortName == opt->shortName) {
+	    break;
+	}
+    }
+
+    if (!opt->longName && !opt->shortName)
+	return NULL;
+    /*@-modobserver -mods @*/
+    if (callback) *callback = NULL;
+    if (callbackData) *callbackData = NULL;
+    if (cb) {
+	if (callback)
+	/*@-castfcnptr@*/
+	    *callback = (poptCallbackType)cb->arg;
+	/*@=castfcnptr@*/
+	if (!(cb->argInfo & POPT_CBFLAG_INC_DATA)) {
+	    if (callbackData)
+		/*@-observertrans@*/	/* FIX: typedef double indirection. */
+		*callbackData = cb->descrip;
+		/*@=observertrans@*/
+	}
+    }
+    /*@=modobserver =mods @*/
+
+    return opt;
+}
+/*@=boundswrite@*/
+
+static const char * findNextArg(/*@special@*/ poptContext con,
+		unsigned argx, int delete_arg)
+	/*@uses con->optionStack, con->os,
+		con->os->next, con->os->argb, con->os->argc, con->os->argv @*/
+	/*@modifies con @*/
+{
+    struct optionStackEntry * os = con->os;
+    const char * arg;
+
+    do {
+	int i;
+	arg = NULL;
+	while (os->next == os->argc && os > con->optionStack) os--;
+	if (os->next == os->argc && os == con->optionStack) break;
+	if (os->argv != NULL)
+	for (i = os->next; i < os->argc; i++) {
+	    /*@-sizeoftype@*/
+	    if (os->argb && PBM_ISSET(i, os->argb))
+		/*@innercontinue@*/ continue;
+	    if (*os->argv[i] == '-')
+		/*@innercontinue@*/ continue;
+	    if (--argx > 0)
+		/*@innercontinue@*/ continue;
+	    arg = os->argv[i];
+	    if (delete_arg) {
+		if (os->argb == NULL) os->argb = PBM_ALLOC(os->argc);
+		if (os->argb != NULL)	/* XXX can't happen */
+		PBM_SET(i, os->argb);
+	    }
+	    /*@innerbreak@*/ break;
+	    /*@=sizeoftype@*/
+	}
+	if (os > con->optionStack) os--;
+    } while (arg == NULL);
+    return arg;
+}
+
+/*@-boundswrite@*/
+static /*@only@*/ /*@null@*/ const char *
+expandNextArg(/*@special@*/ poptContext con, const char * s)
+	/*@uses con->optionStack, con->os,
+		con->os->next, con->os->argb, con->os->argc, con->os->argv @*/
+	/*@modifies con @*/
+{
+    const char * a = NULL;
+    size_t alen;
+    char *t, *te;
+    size_t tn = strlen(s) + 1;
+    char c;
+
+    te = t = malloc(tn);;
+    if (t == NULL) return NULL;		/* XXX can't happen */
+    while ((c = *s++) != '\0') {
+	switch (c) {
+#if 0	/* XXX can't do this */
+	case '\\':	/* escape */
+	    c = *s++;
+	    /*@switchbreak@*/ break;
+#endif
+	case '!':
+	    if (!(s[0] == '#' && s[1] == ':' && s[2] == '+'))
+		/*@switchbreak@*/ break;
+	    /* XXX Make sure that findNextArg deletes only next arg. */
+	    if (a == NULL) {
+		if ((a = findNextArg(con, 1, 1)) == NULL)
+		    /*@switchbreak@*/ break;
+	    }
+	    s += 3;
+
+	    alen = strlen(a);
+	    tn += alen;
+	    *te = '\0';
+	    t = realloc(t, tn);
+	    te = t + strlen(t);
+	    strncpy(te, a, alen); te += alen;
+	    continue;
+	    /*@notreached@*/ /*@switchbreak@*/ break;
+	default:
+	    /*@switchbreak@*/ break;
+	}
+	*te++ = c;
+    }
+    *te = '\0';
+    t = realloc(t, strlen(t) + 1);	/* XXX memory leak, hard to plug */
+    return t;
+}
+/*@=boundswrite@*/
+
+static void poptStripArg(/*@special@*/ poptContext con, int which)
+	/*@uses con->arg_strip, con->optionStack @*/
+	/*@defines con->arg_strip @*/
+	/*@modifies con @*/
+{
+    /*@-sizeoftype@*/
+    if (con->arg_strip == NULL)
+	con->arg_strip = PBM_ALLOC(con->optionStack[0].argc);
+    if (con->arg_strip != NULL)		/* XXX can't happen */
+    PBM_SET(which, con->arg_strip);
+    /*@=sizeoftype@*/
+    /*@-compdef@*/ /* LCL: con->arg_strip udefined? */
+    return;
+    /*@=compdef@*/
+}
+
+int poptSaveLong(long * arg, int argInfo, long aLong)
+{
+    /* XXX Check alignment, may fail on funky platforms. */
+    if (arg == NULL || (((unsigned long)arg) & (sizeof(*arg)-1)))
+	return POPT_ERROR_NULLARG;
+
+    if (argInfo & POPT_ARGFLAG_NOT)
+	aLong = ~aLong;
+    switch (argInfo & POPT_ARGFLAG_LOGICALOPS) {
+    case 0:
+	*arg = aLong;
+	break;
+    case POPT_ARGFLAG_OR:
+	*arg |= aLong;
+	break;
+    case POPT_ARGFLAG_AND:
+	*arg &= aLong;
+	break;
+    case POPT_ARGFLAG_XOR:
+	*arg ^= aLong;
+	break;
+    default:
+	return POPT_ERROR_BADOPERATION;
+	/*@notreached@*/ break;
+    }
+    return 0;
+}
+
+int poptSaveInt(/*@null@*/ int * arg, int argInfo, long aLong)
+{
+    /* XXX Check alignment, may fail on funky platforms. */
+    if (arg == NULL || (((unsigned long)arg) & (sizeof(*arg)-1)))
+	return POPT_ERROR_NULLARG;
+
+    if (argInfo & POPT_ARGFLAG_NOT)
+	aLong = ~aLong;
+    switch (argInfo & POPT_ARGFLAG_LOGICALOPS) {
+    case 0:
+	*arg = aLong;
+	break;
+    case POPT_ARGFLAG_OR:
+	*arg |= aLong;
+	break;
+    case POPT_ARGFLAG_AND:
+	*arg &= aLong;
+	break;
+    case POPT_ARGFLAG_XOR:
+	*arg ^= aLong;
+	break;
+    default:
+	return POPT_ERROR_BADOPERATION;
+	/*@notreached@*/ break;
+    }
+    return 0;
+}
+
+/*@-boundswrite@*/
+/* returns 'val' element, -1 on last item, POPT_ERROR_* on error */
+int poptGetNextOpt(poptContext con)
+{
+    const struct poptOption * opt = NULL;
+    int done = 0;
+
+    if (con == NULL)
+	return -1;
+    while (!done) {
+	const char * origOptString = NULL;
+	poptCallbackType cb = NULL;
+	const void * cbData = NULL;
+	const char * longArg = NULL;
+	int canstrip = 0;
+	int shorty = 0;
+
+	while (!con->os->nextCharArg && con->os->next == con->os->argc
+		&& con->os > con->optionStack) {
+	    cleanOSE(con->os--);
+	}
+	if (!con->os->nextCharArg && con->os->next == con->os->argc) {
+	    /*@-internalglobs@*/
+	    invokeCallbacksPOST(con, con->options);
+	    /*@=internalglobs@*/
+	    if (con->doExec) return execCommand(con);
+	    return -1;
+	}
+
+	/* Process next long option */
+	if (!con->os->nextCharArg) {
+	    char * localOptString, * optString;
+	    int thisopt;
+
+	    /*@-sizeoftype@*/
+	    if (con->os->argb && PBM_ISSET(con->os->next, con->os->argb)) {
+		con->os->next++;
+		continue;
+	    }
+	    /*@=sizeoftype@*/
+	    thisopt = con->os->next;
+	    if (con->os->argv != NULL)	/* XXX can't happen */
+	    origOptString = con->os->argv[con->os->next++];
+
+	    if (origOptString == NULL)	/* XXX can't happen */
+		return POPT_ERROR_BADOPT;
+
+	    if (con->restLeftover || *origOptString != '-' ||
+		(*origOptString == '-' && origOptString[1] == '\0'))
+	    {
+		if (con->flags & POPT_CONTEXT_POSIXMEHARDER)
+		    con->restLeftover = 1;
+		if (con->flags & POPT_CONTEXT_ARG_OPTS) {
+		    con->os->nextArg = xstrdup(origOptString);
+		    return 0;
+		}
+		if (con->leftovers != NULL)	/* XXX can't happen */
+		    con->leftovers[con->numLeftovers++] = origOptString;
+		continue;
+	    }
+
+	    /* Make a copy we can hack at */
+	    localOptString = optString =
+		strcpy(alloca(strlen(origOptString) + 1), origOptString);
+
+	    if (optString[0] == '\0')
+		return POPT_ERROR_BADOPT;
+
+	    if (optString[1] == '-' && !optString[2]) {
+		con->restLeftover = 1;
+		continue;
+	    } else {
+		char *oe;
+		int singleDash;
+
+		optString++;
+		if (*optString == '-')
+		    singleDash = 0, optString++;
+		else
+		    singleDash = 1;
+
+		/* XXX aliases with arg substitution need "--alias=arg" */
+		if (handleAlias(con, optString, '\0', NULL))
+		    continue;
+
+		if (handleExec(con, optString, '\0'))
+		    continue;
+
+		/* Check for "--long=arg" option. */
+		for (oe = optString; *oe && *oe != '='; oe++)
+		    {};
+		if (*oe == '=') {
+		    *oe++ = '\0';
+		    /* XXX longArg is mapped back to persistent storage. */
+		    longArg = origOptString + (oe - localOptString);
+		}
+
+		opt = findOption(con->options, optString, '\0', &cb, &cbData,
+				 singleDash);
+		if (!opt && !singleDash)
+		    return POPT_ERROR_BADOPT;
+	    }
+
+	    if (!opt) {
+		con->os->nextCharArg = origOptString + 1;
+	    } else {
+		if (con->os == con->optionStack &&
+		   opt->argInfo & POPT_ARGFLAG_STRIP)
+		{
+		    canstrip = 1;
+		    poptStripArg(con, thisopt);
+		}
+		shorty = 0;
+	    }
+	}
+
+	/* Process next short option */
+	/*@-branchstate@*/		/* FIX: W2DO? */
+	if (con->os->nextCharArg) {
+	    origOptString = con->os->nextCharArg;
+
+	    con->os->nextCharArg = NULL;
+
+	    if (handleAlias(con, NULL, *origOptString, origOptString + 1))
+		continue;
+
+	    if (handleExec(con, NULL, *origOptString)) {
+		/* Restore rest of short options for further processing */
+		origOptString++;
+		if (*origOptString != '\0')
+		    con->os->nextCharArg = origOptString;
+		continue;
+	    }
+
+	    opt = findOption(con->options, NULL, *origOptString, &cb,
+			     &cbData, 0);
+	    if (!opt)
+		return POPT_ERROR_BADOPT;
+	    shorty = 1;
+
+	    origOptString++;
+	    if (*origOptString != '\0')
+		con->os->nextCharArg = origOptString;
+	}
+	/*@=branchstate@*/
+
+	if (opt == NULL) return POPT_ERROR_BADOPT;	/* XXX can't happen */
+	if (opt->arg && (opt->argInfo & POPT_ARG_MASK) == POPT_ARG_NONE) {
+	    if (poptSaveInt((int *)opt->arg, opt->argInfo, 1L))
+		return POPT_ERROR_BADOPERATION;
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_VAL) {
+	    if (opt->arg) {
+		if (poptSaveInt((int *)opt->arg, opt->argInfo, (long)opt->val))
+		    return POPT_ERROR_BADOPERATION;
+	    }
+	} else if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_NONE) {
+	    con->os->nextArg = _free(con->os->nextArg);
+	    /*@-usedef@*/	/* FIX: W2DO? */
+	    if (longArg) {
+	    /*@=usedef@*/
+		longArg = expandNextArg(con, longArg);
+		con->os->nextArg = longArg;
+	    } else if (con->os->nextCharArg) {
+		longArg = expandNextArg(con, con->os->nextCharArg);
+		con->os->nextArg = longArg;
+		con->os->nextCharArg = NULL;
+	    } else {
+		while (con->os->next == con->os->argc &&
+		       con->os > con->optionStack) {
+		    cleanOSE(con->os--);
+		}
+		if (con->os->next == con->os->argc) {
+		    if (!(opt->argInfo & POPT_ARGFLAG_OPTIONAL))
+			/*@-compdef@*/	/* FIX: con->os->argv not defined */
+			return POPT_ERROR_NOARG;
+			/*@=compdef@*/
+		    con->os->nextArg = NULL;
+		} else {
+
+		    /*
+		     * Make sure this isn't part of a short arg or the
+		     * result of an alias expansion.
+		     */
+		    if (con->os == con->optionStack &&
+			(opt->argInfo & POPT_ARGFLAG_STRIP) &&
+			canstrip) {
+			poptStripArg(con, con->os->next);
+		    }
+		
+		    if (con->os->argv != NULL) {	/* XXX can't happen */
+			/* XXX watchout: subtle side-effects live here. */
+			longArg = con->os->argv[con->os->next++];
+			longArg = expandNextArg(con, longArg);
+			con->os->nextArg = longArg;
+		    }
+		}
+	    }
+	    longArg = NULL;
+
+	    if (opt->arg) {
+		switch (opt->argInfo & POPT_ARG_MASK) {
+		case POPT_ARG_STRING:
+		    /* XXX memory leak, hard to plug */
+		    *((const char **) opt->arg) = (con->os->nextArg)
+			? xstrdup(con->os->nextArg) : NULL;
+		    /*@switchbreak@*/ break;
+
+		case POPT_ARG_INT:
+		case POPT_ARG_LONG:
+		{   long aLong = 0;
+		    char *end;
+
+		    if (con->os->nextArg) {
+			aLong = strtol(con->os->nextArg, &end, 0);
+			if (!(end && *end == '\0'))
+			    return POPT_ERROR_BADNUMBER;
+		    }
+
+		    if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_LONG) {
+			if (aLong == LONG_MIN || aLong == LONG_MAX)
+			    return POPT_ERROR_OVERFLOW;
+			if (poptSaveLong((long *)opt->arg, opt->argInfo, aLong))
+			    return POPT_ERROR_BADOPERATION;
+		    } else {
+			if (aLong > INT_MAX || aLong < INT_MIN)
+			    return POPT_ERROR_OVERFLOW;
+			if (poptSaveInt((int *)opt->arg, opt->argInfo, aLong))
+			    return POPT_ERROR_BADOPERATION;
+		    }
+		}   /*@switchbreak@*/ break;
+
+		case POPT_ARG_FLOAT:
+		case POPT_ARG_DOUBLE:
+		{   double aDouble = 0.0;
+		    char *end;
+
+		    if (con->os->nextArg) {
+			/*@-mods@*/
+			int saveerrno = errno;
+			errno = 0;
+			aDouble = strtod(con->os->nextArg, &end);
+			if (errno == ERANGE)
+			    return POPT_ERROR_OVERFLOW;
+			errno = saveerrno;
+			/*@=mods@*/
+			if (*end != '\0')
+			    return POPT_ERROR_BADNUMBER;
+		    }
+
+		    if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_DOUBLE) {
+			*((double *) opt->arg) = aDouble;
+		    } else {
+#define _ABS(a)	((((a) - 0.0) < DBL_EPSILON) ? -(a) : (a))
+			if ((_ABS(aDouble) - FLT_MAX) > DBL_EPSILON)
+			    return POPT_ERROR_OVERFLOW;
+			if ((FLT_MIN - _ABS(aDouble)) > DBL_EPSILON)
+			    return POPT_ERROR_OVERFLOW;
+			*((float *) opt->arg) = aDouble;
+		    }
+		}   /*@switchbreak@*/ break;
+		default:
+		    fprintf(stdout,
+			POPT_("option type (%d) not implemented in popt\n"),
+			(opt->argInfo & POPT_ARG_MASK));
+		    exit(EXIT_FAILURE);
+		    /*@notreached@*/ /*@switchbreak@*/ break;
+		}
+	    }
+	}
+
+	if (cb) {
+	    /*@-internalglobs@*/
+	    invokeCallbacksOPTION(con, con->options, opt, cbData, shorty);
+	    /*@=internalglobs@*/
+	} else if (opt->val && ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_VAL))
+	    done = 1;
+
+	if ((con->finalArgvCount + 2) >= (con->finalArgvAlloced)) {
+	    con->finalArgvAlloced += 10;
+	    con->finalArgv = realloc(con->finalArgv,
+			    sizeof(*con->finalArgv) * con->finalArgvAlloced);
+	}
+
+	if (con->finalArgv != NULL)
+	{   char *s = malloc((opt->longName ? strlen(opt->longName) : 0) + 3);
+	    if (s != NULL) {	/* XXX can't happen */
+		if (opt->longName)
+		    sprintf(s, "%s%s",
+			((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
+			opt->longName);
+		else
+		    sprintf(s, "-%c", opt->shortName);
+		con->finalArgv[con->finalArgvCount++] = s;
+	    } else
+		con->finalArgv[con->finalArgvCount++] = NULL;
+	}
+
+	if (opt->arg && (opt->argInfo & POPT_ARG_MASK) == POPT_ARG_NONE)
+	    /*@-ifempty@*/ ; /*@=ifempty@*/
+	else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_VAL)
+	    /*@-ifempty@*/ ; /*@=ifempty@*/
+	else if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_NONE) {
+	    if (con->finalArgv != NULL && con->os->nextArg)
+	        con->finalArgv[con->finalArgvCount++] =
+			/*@-nullpass@*/	/* LCL: con->os->nextArg != NULL */
+			xstrdup(con->os->nextArg);
+			/*@=nullpass@*/
+	}
+    }
+
+    return (opt ? opt->val : -1);	/* XXX can't happen */
+}
+/*@=boundswrite@*/
+
+const char * poptGetOptArg(poptContext con)
+{
+    const char * ret = NULL;
+    /*@-branchstate@*/
+    if (con) {
+	ret = con->os->nextArg;
+	con->os->nextArg = NULL;
+    }
+    /*@=branchstate@*/
+    return ret;
+}
+
+const char * poptGetArg(poptContext con)
+{
+    const char * ret = NULL;
+    if (con && con->leftovers != NULL && con->nextLeftover < con->numLeftovers)
+	ret = con->leftovers[con->nextLeftover++];
+    return ret;
+}
+
+const char * poptPeekArg(poptContext con)
+{
+    const char * ret = NULL;
+    if (con && con->leftovers != NULL && con->nextLeftover < con->numLeftovers)
+	ret = con->leftovers[con->nextLeftover];
+    return ret;
+}
+
+/*@-boundswrite@*/
+const char ** poptGetArgs(poptContext con)
+{
+    if (con == NULL ||
+	con->leftovers == NULL || con->numLeftovers == con->nextLeftover)
+	return NULL;
+
+    /* some apps like [like RPM ;-) ] need this NULL terminated */
+    con->leftovers[con->numLeftovers] = NULL;
+
+    /*@-nullret -nullstate @*/	/* FIX: typedef double indirection. */
+    return (con->leftovers + con->nextLeftover);
+    /*@=nullret =nullstate @*/
+}
+/*@=boundswrite@*/
+
+poptContext poptFreeContext(poptContext con)
+{
+    poptItem item;
+    int i;
+
+    if (con == NULL) return con;
+    poptResetContext(con);
+    con->os->argb = _free(con->os->argb);
+
+    if (con->aliases != NULL)
+    for (i = 0; i < con->numAliases; i++) {
+	item = con->aliases + i;
+	/*@-modobserver -observertrans -dependenttrans@*/
+	item->option.longName = _free(item->option.longName);
+	item->option.descrip = _free(item->option.descrip);
+	item->option.argDescrip = _free(item->option.argDescrip);
+	/*@=modobserver =observertrans =dependenttrans@*/
+	item->argv = _free(item->argv);
+    }
+    con->aliases = _free(con->aliases);
+
+    if (con->execs != NULL)
+    for (i = 0; i < con->numExecs; i++) {
+	item = con->execs + i;
+	/*@-modobserver -observertrans -dependenttrans@*/
+	item->option.longName = _free(item->option.longName);
+	item->option.descrip = _free(item->option.descrip);
+	item->option.argDescrip = _free(item->option.argDescrip);
+	/*@=modobserver =observertrans =dependenttrans@*/
+	item->argv = _free(item->argv);
+    }
+    con->execs = _free(con->execs);
+
+    con->leftovers = _free(con->leftovers);
+    con->finalArgv = _free(con->finalArgv);
+    con->appName = _free(con->appName);
+    con->otherHelp = _free(con->otherHelp);
+    con->execPath = _free(con->execPath);
+    con->arg_strip = PBM_FREE(con->arg_strip);
+    
+    con = _free(con);
+    return con;
+}
+
+int poptAddAlias(poptContext con, struct poptAlias alias,
+		/*@unused@*/ int flags)
+{
+    poptItem item = alloca(sizeof(*item));
+    memset(item, 0, sizeof(*item));
+    item->option.longName = alias.longName;
+    item->option.shortName = alias.shortName;
+    item->option.argInfo = POPT_ARGFLAG_DOC_HIDDEN;
+    item->option.arg = 0;
+    item->option.val = 0;
+    item->option.descrip = NULL;
+    item->option.argDescrip = NULL;
+    item->argc = alias.argc;
+    item->argv = alias.argv;
+    return poptAddItem(con, item, 0);
+}
+
+/*@-boundswrite@*/
+/*@-mustmod@*/ /* LCL: con not modified? */
+int poptAddItem(poptContext con, poptItem newItem, int flags)
+{
+    poptItem * items, item;
+    int * nitems;
+
+    switch (flags) {
+    case 1:
+	items = &con->execs;
+	nitems = &con->numExecs;
+	break;
+    case 0:
+	items = &con->aliases;
+	nitems = &con->numAliases;
+	break;
+    default:
+	return 1;
+	/*@notreached@*/ break;
+    }
+
+    *items = realloc((*items), ((*nitems) + 1) * sizeof(**items));
+    if ((*items) == NULL)
+	return 1;
+
+    item = (*items) + (*nitems);
+
+    item->option.longName =
+	(newItem->option.longName ? xstrdup(newItem->option.longName) : NULL);
+    item->option.shortName = newItem->option.shortName;
+    item->option.argInfo = newItem->option.argInfo;
+    item->option.arg = newItem->option.arg;
+    item->option.val = newItem->option.val;
+    item->option.descrip =
+	(newItem->option.descrip ? xstrdup(newItem->option.descrip) : NULL);
+    item->option.argDescrip =
+       (newItem->option.argDescrip ? xstrdup(newItem->option.argDescrip) : NULL);
+    item->argc = newItem->argc;
+    item->argv = newItem->argv;
+
+    (*nitems)++;
+
+    return 0;
+}
+/*@=mustmod@*/
+/*@=boundswrite@*/
+
+const char * poptBadOption(poptContext con, int flags)
+{
+    struct optionStackEntry * os = NULL;
+
+    if (con != NULL)
+	os = (flags & POPT_BADOPTION_NOALIAS) ? con->optionStack : con->os;
+
+    /*@-nullderef@*/	/* LCL: os->argv != NULL */
+    return (os && os->argv ? os->argv[os->next - 1] : NULL);
+    /*@=nullderef@*/
+}
+
+const char * poptStrerror(const int error)
+{
+    switch (error) {
+      case POPT_ERROR_NOARG:
+	return POPT_("missing argument");
+      case POPT_ERROR_BADOPT:
+	return POPT_("unknown option");
+      case POPT_ERROR_BADOPERATION:
+	return POPT_("mutually exclusive logical operations requested");
+      case POPT_ERROR_NULLARG:
+	return POPT_("opt->arg should not be NULL");
+      case POPT_ERROR_OPTSTOODEEP:
+	return POPT_("aliases nested too deeply");
+      case POPT_ERROR_BADQUOTE:
+	return POPT_("error in parameter quoting");
+      case POPT_ERROR_BADNUMBER:
+	return POPT_("invalid numeric value");
+      case POPT_ERROR_OVERFLOW:
+	return POPT_("number too large or too small");
+      case POPT_ERROR_MALLOC:
+	return POPT_("memory allocation failed");
+      case POPT_ERROR_ERRNO:
+	return strerror(errno);
+      default:
+	return POPT_("unknown error");
+    }
+}
+
+int poptStuffArgs(poptContext con, const char ** argv)
+{
+    int argc;
+    int rc;
+
+    if ((con->os - con->optionStack) == POPT_OPTION_DEPTH)
+	return POPT_ERROR_OPTSTOODEEP;
+
+    for (argc = 0; argv[argc]; argc++)
+	{};
+
+    con->os++;
+    con->os->next = 0;
+    con->os->nextArg = NULL;
+    con->os->nextCharArg = NULL;
+    con->os->currAlias = NULL;
+    rc = poptDupArgv(argc, argv, &con->os->argc, &con->os->argv);
+    con->os->argb = NULL;
+    con->os->stuffed = 1;
+
+    return rc;
+}
+
+const char * poptGetInvocationName(poptContext con)
+{
+    return (con->os->argv ? con->os->argv[0] : "");
+}
+
+/*@-boundswrite@*/
+int poptStrippedArgv(poptContext con, int argc, char ** argv)
+{
+    int numargs = argc;
+    int j = 1;
+    int i;
+    
+    /*@-sizeoftype@*/
+    if (con->arg_strip)
+    for (i = 1; i < argc; i++) {
+	if (PBM_ISSET(i, con->arg_strip))
+	    numargs--;
+    }
+    
+    for (i = 1; i < argc; i++) {
+	if (con->arg_strip && PBM_ISSET(i, con->arg_strip))
+	    continue;
+	argv[j] = (j < numargs) ? argv[i] : NULL;
+	j++;
+    }
+    /*@=sizeoftype@*/
+    
+    return numargs;
+}
+/*@=boundswrite@*/
diff --git a/libpopt/popt.h b/libpopt/popt.h
new file mode 100644
index 0000000..4f85d9e
--- /dev/null
+++ b/libpopt/popt.h
@@ -0,0 +1,564 @@
+/** \file popt/popt.h
+ * \ingroup popt
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_POPT
+#define H_POPT
+
+#include <stdio.h>			/* for FILE * */
+
+#define POPT_OPTION_DEPTH	10
+
+/** \ingroup popt
+ * \name Arg type identifiers
+ */
+/*@{*/
+#define POPT_ARG_NONE		0	/*!< no arg */
+#define POPT_ARG_STRING		1	/*!< arg will be saved as string */
+#define POPT_ARG_INT		2	/*!< arg will be converted to int */
+#define POPT_ARG_LONG		3	/*!< arg will be converted to long */
+#define POPT_ARG_INCLUDE_TABLE	4	/*!< arg points to table */
+#define POPT_ARG_CALLBACK	5	/*!< table-wide callback... must be
+					   set first in table; arg points 
+					   to callback, descrip points to 
+					   callback data to pass */
+#define POPT_ARG_INTL_DOMAIN    6       /*!< set the translation domain
+					   for this table and any
+					   included tables; arg points
+					   to the domain string */
+#define POPT_ARG_VAL		7	/*!< arg should take value val */
+#define	POPT_ARG_FLOAT		8	/*!< arg will be converted to float */
+#define	POPT_ARG_DOUBLE		9	/*!< arg will be converted to double */
+
+#define POPT_ARG_MASK		0x0000FFFF
+/*@}*/
+
+/** \ingroup popt
+ * \name Arg modifiers
+ */
+/*@{*/
+#define POPT_ARGFLAG_ONEDASH	0x80000000  /*!< allow -longoption */
+#define POPT_ARGFLAG_DOC_HIDDEN 0x40000000  /*!< don't show in help/usage */
+#define POPT_ARGFLAG_STRIP	0x20000000  /*!< strip this arg from argv(only applies to long args) */
+#define	POPT_ARGFLAG_OPTIONAL	0x10000000  /*!< arg may be missing */
+
+#define	POPT_ARGFLAG_OR		0x08000000  /*!< arg will be or'ed */
+#define	POPT_ARGFLAG_NOR	0x09000000  /*!< arg will be nor'ed */
+#define	POPT_ARGFLAG_AND	0x04000000  /*!< arg will be and'ed */
+#define	POPT_ARGFLAG_NAND	0x05000000  /*!< arg will be nand'ed */
+#define	POPT_ARGFLAG_XOR	0x02000000  /*!< arg will be xor'ed */
+#define	POPT_ARGFLAG_NOT	0x01000000  /*!< arg will be negated */
+#define POPT_ARGFLAG_LOGICALOPS \
+        (POPT_ARGFLAG_OR|POPT_ARGFLAG_AND|POPT_ARGFLAG_XOR)
+
+#define	POPT_BIT_SET	(POPT_ARG_VAL|POPT_ARGFLAG_OR)
+					/*!< set arg bit(s) */
+#define	POPT_BIT_CLR	(POPT_ARG_VAL|POPT_ARGFLAG_NAND)
+					/*!< clear arg bit(s) */
+
+#define	POPT_ARGFLAG_SHOW_DEFAULT 0x00800000 /*!< show default value in --help */
+
+/*@}*/
+
+/** \ingroup popt
+ * \name Callback modifiers
+ */
+/*@{*/
+#define POPT_CBFLAG_PRE		0x80000000  /*!< call the callback before parse */
+#define POPT_CBFLAG_POST	0x40000000  /*!< call the callback after parse */
+#define POPT_CBFLAG_INC_DATA	0x20000000  /*!< use data from the include line,
+					       not the subtable */
+#define POPT_CBFLAG_SKIPOPTION	0x10000000  /*!< don't callback with option */
+#define POPT_CBFLAG_CONTINUE	0x08000000  /*!< continue callbacks with option */
+/*@}*/
+
+/** \ingroup popt
+ * \name Error return values
+ */
+/*@{*/
+#define POPT_ERROR_NOARG	-10	/*!< missing argument */
+#define POPT_ERROR_BADOPT	-11	/*!< unknown option */
+#define POPT_ERROR_OPTSTOODEEP	-13	/*!< aliases nested too deeply */
+#define POPT_ERROR_BADQUOTE	-15	/*!< error in paramter quoting */
+#define POPT_ERROR_ERRNO	-16	/*!< errno set, use strerror(errno) */
+#define POPT_ERROR_BADNUMBER	-17	/*!< invalid numeric value */
+#define POPT_ERROR_OVERFLOW	-18	/*!< number too large or too small */
+#define	POPT_ERROR_BADOPERATION	-19	/*!< mutually exclusive logical operations requested */
+#define	POPT_ERROR_NULLARG	-20	/*!< opt->arg should not be NULL */
+#define	POPT_ERROR_MALLOC	-21	/*!< memory allocation failed */
+/*@}*/
+
+/** \ingroup popt
+ * \name poptBadOption() flags
+ */
+/*@{*/
+#define POPT_BADOPTION_NOALIAS  (1 << 0)  /*!< don't go into an alias */
+/*@}*/
+
+/** \ingroup popt
+ * \name poptGetContext() flags
+ */
+/*@{*/
+#define POPT_CONTEXT_NO_EXEC	(1 << 0)  /*!< ignore exec expansions */
+#define POPT_CONTEXT_KEEP_FIRST	(1 << 1)  /*!< pay attention to argv[0] */
+#define POPT_CONTEXT_POSIXMEHARDER (1 << 2) /*!< options can't follow args */
+#define POPT_CONTEXT_ARG_OPTS	(1 << 4) /*!< return args as options with value 0 */
+/*@}*/
+
+/** \ingroup popt
+ */
+struct poptOption {
+/*@observer@*/ /*@null@*/
+    const char * longName;	/*!< may be NULL */
+    char shortName;		/*!< may be NUL */
+    int argInfo;
+/*@shared@*/ /*@null@*/
+    void * arg;			/*!< depends on argInfo */
+    int val;			/*!< 0 means don't return, just update flag */
+/*@observer@*/ /*@null@*/
+    const char * descrip;	/*!< description for autohelp -- may be NULL */
+/*@observer@*/ /*@null@*/
+    const char * argDescrip;	/*!< argument description for autohelp */
+};
+
+/** \ingroup popt
+ * A popt alias argument for poptAddAlias().
+ */
+struct poptAlias {
+/*@owned@*/ /*@null@*/
+    const char * longName;	/*!< may be NULL */
+    char shortName;		/*!< may be NUL */
+    int argc;
+/*@owned@*/
+    const char ** argv;		/*!< must be free()able */
+};
+
+/** \ingroup popt
+ * A popt alias or exec argument for poptAddItem().
+ */
+/*@-exporttype@*/
+typedef struct poptItem_s {
+    struct poptOption option;	/*!< alias/exec name(s) and description. */
+    int argc;			/*!< (alias) no. of args. */
+/*@owned@*/
+    const char ** argv;		/*!< (alias) args, must be free()able. */
+} * poptItem;
+/*@=exporttype@*/
+
+/** \ingroup popt
+ * \name Auto-generated help/usage
+ */
+/*@{*/
+
+/**
+ * Empty table marker to enable displaying popt alias/exec options.
+ */
+/*@-exportvar@*/
+/*@unchecked@*/ /*@observer@*/
+extern struct poptOption poptAliasOptions[];
+/*@=exportvar@*/
+#define POPT_AUTOALIAS { NULL, '\0', POPT_ARG_INCLUDE_TABLE, poptAliasOptions, \
+			0, "Options implemented via popt alias/exec:", NULL },
+
+/**
+ * Auto help table options.
+ */
+/*@-exportvar@*/
+/*@unchecked@*/ /*@observer@*/
+extern struct poptOption poptHelpOptions[];
+/*@=exportvar@*/
+
+/*@-exportvar@*/
+/*@unchecked@*/ /*@observer@*/
+extern struct poptOption * poptHelpOptionsI18N;
+/*@=exportvar@*/
+
+#define POPT_AUTOHELP { NULL, '\0', POPT_ARG_INCLUDE_TABLE, poptHelpOptions, \
+			0, "Help options:", NULL },
+
+#define POPT_TABLEEND { NULL, '\0', 0, 0, 0, NULL, NULL }
+/*@}*/
+
+/** \ingroup popt
+ */
+/*@-exporttype@*/
+typedef /*@abstract@*/ struct poptContext_s * poptContext;
+/*@=exporttype@*/
+
+/** \ingroup popt
+ */
+#ifndef __cplusplus
+/*@-exporttype -typeuse@*/
+typedef struct poptOption * poptOption;
+/*@=exporttype =typeuse@*/
+#endif
+
+/*@-exportconst@*/
+enum poptCallbackReason {
+    POPT_CALLBACK_REASON_PRE	= 0, 
+    POPT_CALLBACK_REASON_POST	= 1,
+    POPT_CALLBACK_REASON_OPTION = 2
+};
+/*@=exportconst@*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*@-type@*/
+
+/** \ingroup popt
+ * Table callback prototype.
+ * @param con		context
+ * @param reason	reason for callback
+ * @param opt		option that triggered callback
+ * @param arg		@todo Document.
+ * @param data		@todo Document.
+ */
+typedef void (*poptCallbackType) (poptContext con, 
+		enum poptCallbackReason reason,
+		/*@null@*/ const struct poptOption * opt,
+		/*@null@*/ const char * arg,
+		/*@null@*/ const void * data)
+	/*@globals internalState @*/
+	/*@modifies internalState @*/;
+
+/** \ingroup popt
+ * Initialize popt context.
+ * @param name		context name (usually argv[0] program name)
+ * @param argc		no. of arguments
+ * @param argv		argument array
+ * @param options	address of popt option table
+ * @param flags		or'd POPT_CONTEXT_* bits
+ * @return		initialized popt context
+ */
+/*@only@*/ /*@null@*/
+poptContext poptGetContext(
+		/*@dependent@*/ /*@keep@*/ const char * name,
+		int argc, /*@dependent@*/ /*@keep@*/ const char ** argv,
+		/*@dependent@*/ /*@keep@*/ const struct poptOption * options,
+		int flags)
+	/*@*/;
+
+/** \ingroup popt
+ * Reinitialize popt context.
+ * @param con		context
+ */
+/*@unused@*/
+void poptResetContext(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return value of next option found.
+ * @param con		context
+ * @return		next option val, -1 on last item, POPT_ERROR_* on error
+ */
+int poptGetNextOpt(/*@null@*/poptContext con)
+	/*@globals fileSystem, internalState @*/
+	/*@modifies con, fileSystem, internalState @*/;
+
+/** \ingroup popt
+ * Return next option argument (if any).
+ * @param con		context
+ * @return		option argument, NULL if no argument is available
+ */
+/*@observer@*/ /*@null@*/ /*@unused@*/
+const char * poptGetOptArg(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return next argument.
+ * @param con		context
+ * @return		next argument, NULL if no argument is available
+ */
+/*@observer@*/ /*@null@*/ /*@unused@*/
+const char * poptGetArg(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Peek at current argument.
+ * @param con		context
+ * @return		current argument, NULL if no argument is available
+ */
+/*@observer@*/ /*@null@*/ /*@unused@*/
+const char * poptPeekArg(/*@null@*/poptContext con)
+	/*@*/;
+
+/** \ingroup popt
+ * Return remaining arguments.
+ * @param con		context
+ * @return		argument array, NULL terminated
+ */
+/*@observer@*/ /*@null@*/
+const char ** poptGetArgs(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return the option which caused the most recent error.
+ * @param con		context
+ * @param flags
+ * @return		offending option
+ */
+/*@observer@*/
+const char * poptBadOption(/*@null@*/poptContext con, int flags)
+	/*@*/;
+
+/** \ingroup popt
+ * Destroy context.
+ * @param con		context
+ * @return		NULL always
+ */
+/*@null@*/
+poptContext poptFreeContext( /*@only@*/ /*@null@*/ poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add arguments to context.
+ * @param con		context
+ * @param argv		argument array, NULL terminated
+ * @return		0 on success, POPT_ERROR_OPTSTOODEEP on failure
+ */
+/*@unused@*/
+int poptStuffArgs(poptContext con, /*@keep@*/ const char ** argv)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add alias to context.
+ * @todo Pass alias by reference, not value.
+ * @deprecated Use poptAddItem instead.
+ * @param con		context
+ * @param alias		alias to add
+ * @param flags		(unused)
+ * @return		0 on success
+ */
+/*@unused@*/
+int poptAddAlias(poptContext con, struct poptAlias alias, int flags)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add alias/exec item to context.
+ * @param con		context
+ * @param newItem	alias/exec item to add
+ * @param flags		0 for alias, 1 for exec
+ * @return		0 on success
+ */
+int poptAddItem(poptContext con, poptItem newItem, int flags)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Read configuration file.
+ * @param con		context
+ * @param fn		file name to read
+ * @return		0 on success, POPT_ERROR_ERRNO on failure
+ */
+int poptReadConfigFile(poptContext con, const char * fn)
+	/*@globals errno, fileSystem, internalState @*/
+	/*@modifies con->execs, con->numExecs,
+		errno, fileSystem, internalState @*/;
+
+/** \ingroup popt
+ * Read default configuration from /etc/popt and $HOME/.popt.
+ * @param con		context
+ * @param useEnv	(unused)
+ * @return		0 on success, POPT_ERROR_ERRNO on failure
+ */
+/*@unused@*/
+int poptReadDefaultConfig(poptContext con, /*@unused@*/ int useEnv)
+	/*@globals fileSystem, internalState @*/
+	/*@modifies con->execs, con->numExecs,
+		fileSystem, internalState @*/;
+
+/** \ingroup popt
+ * Duplicate an argument array.
+ * @note: The argument array is malloc'd as a single area, so only argv must
+ * be free'd.
+ *
+ * @param argc		no. of arguments
+ * @param argv		argument array
+ * @retval argcPtr	address of returned no. of arguments
+ * @retval argvPtr	address of returned argument array
+ * @return		0 on success, POPT_ERROR_NOARG on failure
+ */
+int poptDupArgv(int argc, /*@null@*/ const char **argv,
+		/*@null@*/ /*@out@*/ int * argcPtr,
+		/*@null@*/ /*@out@*/ const char *** argvPtr)
+	/*@modifies *argcPtr, *argvPtr @*/;
+
+/** \ingroup popt
+ * Parse a string into an argument array.
+ * The parse allows ', ", and \ quoting, but ' is treated the same as " and
+ * both may include \ quotes.
+ * @note: The argument array is malloc'd as a single area, so only argv must
+ * be free'd.
+ *
+ * @param s		string to parse
+ * @retval argcPtr	address of returned no. of arguments
+ * @retval argvPtr	address of returned argument array
+ */
+int poptParseArgvString(const char * s,
+		/*@out@*/ int * argcPtr, /*@out@*/ const char *** argvPtr)
+	/*@modifies *argcPtr, *argvPtr @*/;
+
+/** \ingroup popt
+ * Parses an input configuration file and returns an string that is a 
+ * command line.  For use with popt.  You must free the return value when done.
+ *
+ * Given the file:
+\verbatim
+# this line is ignored
+    #   this one too
+aaa
+  bbb
+    ccc   
+bla=bla
+
+this_is   =   fdsafdas
+     bad_line=        
+  reall bad line  
+  reall bad line  = again
+5555=   55555   
+  test = with lots of spaces
+\endverbatim
+*
+* The result is:
+\verbatim
+--aaa --bbb --ccc --bla="bla" --this_is="fdsafdas" --5555="55555" --test="with lots of spaces"
+\endverbatim
+*
+* Passing this to poptParseArgvString() yields an argv of:
+\verbatim
+'--aaa'
+'--bbb' 
+'--ccc' 
+'--bla=bla' 
+'--this_is=fdsafdas' 
+'--5555=55555' 
+'--test=with lots of spaces' 
+\endverbatim
+ *
+ * @bug NULL is returned if file line is too long.
+ * @bug Silently ignores invalid lines.
+ *
+ * @param fp		file handle to read
+ * @param *argstrp	return string of options (malloc'd)
+ * @param flags		unused
+ * @return		0 on success
+ * @see			poptParseArgvString
+ */
+/*@-fcnuse@*/
+int poptConfigFileToString(FILE *fp, /*@out@*/ char ** argstrp, int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, *argstrp, fileSystem @*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Return formatted error string for popt failure.
+ * @param error		popt error
+ * @return		error string
+ */
+/*@observer@*/
+const char * poptStrerror(const int error)
+	/*@*/;
+
+/** \ingroup popt
+ * Limit search for executables.
+ * @param con		context
+ * @param path		single path to search for executables
+ * @param allowAbsolute	absolute paths only?
+ */
+/*@unused@*/
+void poptSetExecPath(poptContext con, const char * path, int allowAbsolute)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Print detailed description of options.
+ * @param con		context
+ * @param fp		ouput file handle
+ * @param flags		(unused)
+ */
+void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/;
+
+/** \ingroup popt
+ * Print terse description of options.
+ * @param con		context
+ * @param fp		ouput file handle
+ * @param flags		(unused)
+ */
+void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/;
+
+/** \ingroup popt
+ * Provide text to replace default "[OPTION...]" in help/usage output.
+ * @param con		context
+ * @param text		replacement text
+ */
+/*@-fcnuse@*/
+void poptSetOtherOptionHelp(poptContext con, const char * text)
+	/*@modifies con @*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Return argv[0] from context.
+ * @param con		context
+ * @return		argv[0]
+ */
+/*@-fcnuse@*/
+/*@observer@*/
+const char * poptGetInvocationName(poptContext con)
+	/*@*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Shuffle argv pointers to remove stripped args, returns new argc.
+ * @param con		context
+ * @param argc		no. of args
+ * @param argv		arg vector
+ * @return		new argc
+ */
+/*@-fcnuse@*/
+int poptStrippedArgv(poptContext con, int argc, char ** argv)
+	/*@modifies *argv @*/;
+/*@=fcnuse@*/
+
+/**
+ * Save a long, performing logical operation with value.
+ * @warning Alignment check may be too strict on certain platorms.
+ * @param arg		integer pointer, aligned on int boundary.
+ * @param argInfo	logical operation (see POPT_ARGFLAG_*)
+ * @param aLong		value to use
+ * @return		0 on success, POPT_ERROR_NULLARG/POPT_ERROR_BADOPERATION
+ */
+/*@-incondefs@*/
+/*@unused@*/
+int poptSaveLong(/*@null@*/ long * arg, int argInfo, long aLong)
+	/*@modifies *arg @*/
+	/*@requires maxSet(arg) >= 0 /\ maxRead(arg) == 0 @*/;
+/*@=incondefs@*/
+
+/**
+ * Save an integer, performing logical operation with value.
+ * @warning Alignment check may be too strict on certain platorms.
+ * @param arg		integer pointer, aligned on int boundary.
+ * @param argInfo	logical operation (see POPT_ARGFLAG_*)
+ * @param aLong		value to use
+ * @return		0 on success, POPT_ERROR_NULLARG/POPT_ERROR_BADOPERATION
+ */
+/*@-incondefs@*/
+/*@unused@*/
+int poptSaveInt(/*@null@*/ int * arg, int argInfo, long aLong)
+	/*@modifies *arg @*/
+	/*@requires maxSet(arg) >= 0 /\ maxRead(arg) == 0 @*/;
+/*@=incondefs@*/
+
+/*@=type@*/
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/libpopt/poptconfig.c b/libpopt/poptconfig.c
new file mode 100644
index 0000000..e5cba45
--- /dev/null
+++ b/libpopt/poptconfig.c
@@ -0,0 +1,182 @@
+/** \ingroup popt
+ * \file popt/poptconfig.c
+ */
+
+/* (C) 1998-2002 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+#include "poptint.h"
+/*@access poptContext @*/
+
+/*@-compmempass@*/	/* FIX: item->option.longName kept, not dependent. */
+static void configLine(poptContext con, char * line)
+	/*@modifies con @*/
+{
+    size_t nameLength;
+    const char * entryType;
+    const char * opt;
+    poptItem item = alloca(sizeof(*item));
+    int i, j;
+
+    if (con->appName == NULL)
+	return;
+    nameLength = strlen(con->appName);
+    
+/*@-boundswrite@*/
+    memset(item, 0, sizeof(*item));
+
+    if (strncmp(line, con->appName, nameLength)) return;
+
+    line += nameLength;
+    if (*line == '\0' || !isspace(*line)) return;
+
+    while (*line != '\0' && isspace(*line)) line++;
+    entryType = line;
+    while (*line == '\0' || !isspace(*line)) line++;
+    *line++ = '\0';
+
+    while (*line != '\0' && isspace(*line)) line++;
+    if (*line == '\0') return;
+    opt = line;
+    while (*line == '\0' || !isspace(*line)) line++;
+    *line++ = '\0';
+
+    while (*line != '\0' && isspace(*line)) line++;
+    if (*line == '\0') return;
+
+    /*@-temptrans@*/ /* FIX: line alias is saved */
+    if (opt[0] == '-' && opt[1] == '-')
+	item->option.longName = opt + 2;
+    else if (opt[0] == '-' && opt[2] == '\0')
+	item->option.shortName = opt[1];
+    /*@=temptrans@*/
+
+    if (poptParseArgvString(line, &item->argc, &item->argv)) return;
+
+    /*@-modobserver@*/
+    item->option.argInfo = POPT_ARGFLAG_DOC_HIDDEN;
+    for (i = 0, j = 0; i < item->argc; i++, j++) {
+	const char * f;
+	if (!strncmp(item->argv[i], "--POPTdesc=", sizeof("--POPTdesc=")-1)) {
+	    f = item->argv[i] + sizeof("--POPTdesc=");
+	    if (f[0] == '$' && f[1] == '"') f++;
+	    item->option.descrip = f;
+	    item->option.argInfo &= ~POPT_ARGFLAG_DOC_HIDDEN;
+	    j--;
+	} else
+	if (!strncmp(item->argv[i], "--POPTargs=", sizeof("--POPTargs=")-1)) {
+	    f = item->argv[i] + sizeof("--POPTargs=");
+	    if (f[0] == '$' && f[1] == '"') f++;
+	    item->option.argDescrip = f;
+	    item->option.argInfo &= ~POPT_ARGFLAG_DOC_HIDDEN;
+	    item->option.argInfo |= POPT_ARG_STRING;
+	    j--;
+	} else
+	if (j != i)
+	    item->argv[j] = item->argv[i];
+    }
+    if (j != i) {
+	item->argv[j] = NULL;
+	item->argc = j;
+    }
+    /*@=modobserver@*/
+/*@=boundswrite@*/
+	
+    /*@-nullstate@*/ /* FIX: item->argv[] may be NULL */
+    if (!strcmp(entryType, "alias"))
+	(void) poptAddItem(con, item, 0);
+    else if (!strcmp(entryType, "exec"))
+	(void) poptAddItem(con, item, 1);
+    /*@=nullstate@*/
+}
+/*@=compmempass@*/
+
+int poptReadConfigFile(poptContext con, const char * fn)
+{
+    const char * file, * chptr, * end;
+    char * buf;
+/*@dependent@*/ char * dst;
+    int fd, rc;
+    off_t fileLength;
+
+    fd = open(fn, O_RDONLY);
+    if (fd < 0)
+	return (errno == ENOENT ? 0 : POPT_ERROR_ERRNO);
+
+    fileLength = lseek(fd, 0, SEEK_END);
+    if (fileLength == -1 || lseek(fd, 0, 0) == -1) {
+	rc = errno;
+	(void) close(fd);
+	errno = rc;
+	return POPT_ERROR_ERRNO;
+    }
+
+    file = alloca(fileLength + 1);
+    if (read(fd, (char *)file, fileLength) != fileLength) {
+	rc = errno;
+	(void) close(fd);
+	errno = rc;
+	return POPT_ERROR_ERRNO;
+    }
+    if (close(fd) == -1)
+	return POPT_ERROR_ERRNO;
+
+/*@-boundswrite@*/
+    dst = buf = alloca(fileLength + 1);
+
+    chptr = file;
+    end = (file + fileLength);
+    /*@-infloops@*/	/* LCL: can't detect chptr++ */
+    while (chptr < end) {
+	switch (*chptr) {
+	  case '\n':
+	    *dst = '\0';
+	    dst = buf;
+	    while (*dst && isspace(*dst)) dst++;
+	    if (*dst && *dst != '#')
+		configLine(con, dst);
+	    chptr++;
+	    /*@switchbreak@*/ break;
+	  case '\\':
+	    *dst++ = *chptr++;
+	    if (chptr < end) {
+		if (*chptr == '\n') 
+		    dst--, chptr++;	
+		    /* \ at the end of a line does not insert a \n */
+		else
+		    *dst++ = *chptr++;
+	    }
+	    /*@switchbreak@*/ break;
+	  default:
+	    *dst++ = *chptr++;
+	    /*@switchbreak@*/ break;
+	}
+    }
+    /*@=infloops@*/
+/*@=boundswrite@*/
+
+    return 0;
+}
+
+int poptReadDefaultConfig(poptContext con, /*@unused@*/ int useEnv)
+{
+    char * fn, * home;
+    int rc;
+
+    if (con->appName == NULL) return 0;
+
+    rc = poptReadConfigFile(con, "/etc/popt");
+    if (rc) return rc;
+
+    if ((home = getenv("HOME"))) {
+	fn = alloca(strlen(home) + 20);
+	strcpy(fn, home);
+	strcat(fn, "/.popt");
+	rc = poptReadConfigFile(con, fn);
+	if (rc) return rc;
+    }
+
+    return 0;
+}
diff --git a/libpopt/popthelp.c b/libpopt/popthelp.c
new file mode 100644
index 0000000..9430a2d
--- /dev/null
+++ b/libpopt/popthelp.c
@@ -0,0 +1,819 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/** \ingroup popt
+ * \file popt/popthelp.c
+ */
+
+/* (C) 1998-2002 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+
+//#define	POPT_WCHAR_HACK
+#ifdef 	POPT_WCHAR_HACK
+#include <wchar.h>			/* for mbsrtowcs */
+/*@access mbstate_t @*/
+#endif
+#include "poptint.h"
+
+/*@access poptContext@*/
+
+/**
+ * Display arguments.
+ * @param con		context
+ * @param foo		(unused)
+ * @param key		option(s)
+ * @param arg		(unused)
+ * @param data		(unused)
+ */
+static void displayArgs(poptContext con,
+		/*@unused@*/ enum poptCallbackReason foo,
+		struct poptOption * key, 
+		/*@unused@*/ const char * arg, /*@unused@*/ void * data)
+	/*@globals fileSystem@*/
+	/*@modifies fileSystem@*/
+{
+    if (key->shortName == '?')
+	poptPrintHelp(con, stdout, 0);
+    else
+	poptPrintUsage(con, stdout, 0);
+    exit(0);
+}
+
+#ifdef	NOTYET
+/*@unchecked@*/
+static int show_option_defaults = 0;
+#endif
+
+/**
+ * Empty table marker to enable displaying popt alias/exec options.
+ */
+/*@observer@*/ /*@unchecked@*/
+struct poptOption poptAliasOptions[] = {
+    POPT_TABLEEND
+};
+
+/**
+ * Auto help table options.
+ */
+/*@-castfcnptr@*/
+/*@observer@*/ /*@unchecked@*/
+struct poptOption poptHelpOptions[] = {
+  { NULL, '\0', POPT_ARG_CALLBACK, (void *)&displayArgs, '\0', NULL, NULL },
+  { "help", '?', 0, NULL, '?', N_("Show this help message"), NULL },
+  { "usage", '\0', 0, NULL, 'u', N_("Display brief usage message"), NULL },
+    POPT_TABLEEND
+} ;
+
+/*@observer@*/ /*@unchecked@*/
+static struct poptOption poptHelpOptions2[] = {
+/*@-readonlytrans@*/
+  { NULL, '\0', POPT_ARG_INTL_DOMAIN, PACKAGE, 0, NULL, NULL},
+/*@=readonlytrans@*/
+  { NULL, '\0', POPT_ARG_CALLBACK, (void *)&displayArgs, '\0', NULL, NULL },
+  { "help", '?', 0, NULL, '?', N_("Show this help message"), NULL },
+  { "usage", '\0', 0, NULL, 'u', N_("Display brief usage message"), NULL },
+#ifdef	NOTYET
+  { "defaults", '\0', POPT_ARG_NONE, &show_option_defaults, 0,
+	N_("Display option defaults in message"), NULL },
+#endif
+    POPT_TABLEEND
+} ;
+
+/*@observer@*/ /*@unchecked@*/
+struct poptOption * poptHelpOptionsI18N = poptHelpOptions2;
+/*@=castfcnptr@*/
+
+/**
+ * @param table		option(s)
+ */
+/*@observer@*/ /*@null@*/ static const char *
+getTableTranslationDomain(/*@null@*/ const struct poptOption *table)
+	/*@*/
+{
+    const struct poptOption *opt;
+
+    if (table != NULL)
+    for (opt = table; opt->longName || opt->shortName || opt->arg; opt++) {
+	if (opt->argInfo == POPT_ARG_INTL_DOMAIN)
+	    return opt->arg;
+    }
+    return NULL;
+}
+
+/**
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+/*@observer@*/ /*@null@*/ static const char *
+getArgDescrip(const struct poptOption * opt,
+		/*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
+		/*@null@*/ const char * translation_domain)
+		/*@=paramuse@*/
+	/*@*/
+{
+    if (!(opt->argInfo & POPT_ARG_MASK)) return NULL;
+
+    if (opt == (poptHelpOptions + 1) || opt == (poptHelpOptions + 2))
+	if (opt->argDescrip) return POPT_(opt->argDescrip);
+
+    if (opt->argDescrip) return D_(translation_domain, opt->argDescrip);
+
+    switch (opt->argInfo & POPT_ARG_MASK) {
+    case POPT_ARG_NONE:		return POPT_("NONE");
+#ifdef	DYING
+    case POPT_ARG_VAL:		return POPT_("VAL");
+#else
+    case POPT_ARG_VAL:		return NULL;
+#endif
+    case POPT_ARG_INT:		return POPT_("INT");
+    case POPT_ARG_LONG:		return POPT_("LONG");
+    case POPT_ARG_STRING:	return POPT_("STRING");
+    case POPT_ARG_FLOAT:	return POPT_("FLOAT");
+    case POPT_ARG_DOUBLE:	return POPT_("DOUBLE");
+    default:			return POPT_("ARG");
+    }
+}
+
+/**
+ * Display default value for an option.
+ * @param lineLength	display positions remaining
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ * @return
+ */
+static /*@only@*/ /*@null@*/ char *
+singleOptionDefaultValue(size_t lineLength,
+		const struct poptOption * opt,
+		/*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
+		/*@null@*/ const char * translation_domain)
+		/*@=paramuse@*/
+	/*@*/
+{
+    const char * defstr = D_(translation_domain, "default");
+    char * le = malloc(4*lineLength + 1);
+    char * l = le;
+
+    if (le == NULL) return NULL;	/* XXX can't happen */
+/*@-boundswrite@*/
+    *le = '\0';
+    *le++ = '(';
+    strcpy(le, defstr);	le += strlen(le);
+    *le++ = ':';
+    *le++ = ' ';
+    if (opt->arg)	/* XXX programmer error */
+    switch (opt->argInfo & POPT_ARG_MASK) {
+    case POPT_ARG_VAL:
+    case POPT_ARG_INT:
+    {	long aLong = *((int *)opt->arg);
+	le += sprintf(le, "%ld", aLong);
+    }	break;
+    case POPT_ARG_LONG:
+    {	long aLong = *((long *)opt->arg);
+	le += sprintf(le, "%ld", aLong);
+    }	break;
+    case POPT_ARG_FLOAT:
+    {	double aDouble = *((float *)opt->arg);
+	le += sprintf(le, "%g", aDouble);
+    }	break;
+    case POPT_ARG_DOUBLE:
+    {	double aDouble = *((double *)opt->arg);
+	le += sprintf(le, "%g", aDouble);
+    }	break;
+    case POPT_ARG_STRING:
+    {	const char * s = *(const char **)opt->arg;
+	if (s == NULL) {
+	    strcpy(le, "null");	le += strlen(le);
+	} else {
+	    size_t slen = 4*lineLength - (le - l) - sizeof("\"...\")");
+	    *le++ = '"';
+	    strncpy(le, s, slen); le[slen] = '\0'; le += strlen(le);	
+	    if (slen < strlen(s)) {
+		strcpy(le, "...");	le += strlen(le);
+	    }
+	    *le++ = '"';
+	}
+    }	break;
+    case POPT_ARG_NONE:
+    default:
+	l = _free(l);
+	return NULL;
+	/*@notreached@*/ break;
+    }
+    *le++ = ')';
+    *le = '\0';
+/*@=boundswrite@*/
+
+    return l;
+}
+
+/**
+ * Display help text for an option.
+ * @param fp		output file handle
+ * @param maxLeftCol	largest argument display width
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static void singleOptionHelp(FILE * fp, size_t maxLeftCol, 
+		const struct poptOption * opt,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    size_t indentLength = maxLeftCol + 5;
+    size_t lineLength = 79 - indentLength;
+    const char * help = D_(translation_domain, opt->descrip);
+    const char * argDescrip = getArgDescrip(opt, translation_domain);
+    size_t helpLength;
+    char * defs = NULL;
+    char * left;
+    size_t nb = maxLeftCol + 1;
+    int displaypad = 0;
+
+    /* Make sure there's more than enough room in target buffer. */
+    if (opt->longName)	nb += strlen(opt->longName);
+    if (argDescrip)	nb += strlen(argDescrip);
+
+/*@-boundswrite@*/
+    left = malloc(nb);
+    if (left == NULL) return;	/* XXX can't happen */
+    left[0] = '\0';
+    left[maxLeftCol] = '\0';
+
+    if (opt->longName && opt->shortName)
+	sprintf(left, "-%c, %s%s", opt->shortName,
+		((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
+		opt->longName);
+    else if (opt->shortName != '\0') 
+	sprintf(left, "-%c", opt->shortName);
+    else if (opt->longName)
+	sprintf(left, "%s%s",
+		((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
+		opt->longName);
+    if (!*left) goto out;
+
+    if (argDescrip) {
+	char * le = left + strlen(left);
+
+	if (opt->argInfo & POPT_ARGFLAG_OPTIONAL)
+	    *le++ = '[';
+
+	/* Choose type of output */
+	/*@-branchstate@*/
+	if (opt->argInfo & POPT_ARGFLAG_SHOW_DEFAULT) {
+	    defs = singleOptionDefaultValue(lineLength, opt, translation_domain);
+	    if (defs) {
+		char * t = malloc((help ? strlen(help) : 0) +
+				strlen(defs) + sizeof(" "));
+		if (t) {
+		    char * te = t;
+		    *te = '\0';
+		    if (help) {
+			strcpy(te, help);	te += strlen(te);
+		    }
+		    *te++ = ' ';
+		    strcpy(te, defs);
+		    defs = _free(defs);
+		}
+		defs = t;
+	    }
+	}
+	/*@=branchstate@*/
+
+	if (opt->argDescrip == NULL) {
+	    switch (opt->argInfo & POPT_ARG_MASK) {
+	    case POPT_ARG_NONE:
+		break;
+	    case POPT_ARG_VAL:
+#ifdef	NOTNOW	/* XXX pug ugly nerdy output */
+	    {	long aLong = opt->val;
+		int ops = (opt->argInfo & POPT_ARGFLAG_LOGICALOPS);
+		int negate = (opt->argInfo & POPT_ARGFLAG_NOT);
+
+		/* Don't bother displaying typical values */
+		if (!ops && (aLong == 0L || aLong == 1L || aLong == -1L))
+		    break;
+		*le++ = '[';
+		switch (ops) {
+		case POPT_ARGFLAG_OR:
+		    *le++ = '|';
+		    /*@innerbreak@*/ break;
+		case POPT_ARGFLAG_AND:
+		    *le++ = '&';
+		    /*@innerbreak@*/ break;
+		case POPT_ARGFLAG_XOR:
+		    *le++ = '^';
+		    /*@innerbreak@*/ break;
+		default:
+		    /*@innerbreak@*/ break;
+		}
+		*le++ = (opt->longName != NULL ? '=' : ' ');
+		if (negate) *le++ = '~';
+		/*@-formatconst@*/
+		le += sprintf(le, (ops ? "0x%lx" : "%ld"), aLong);
+		/*@=formatconst@*/
+		*le++ = ']';
+	    }
+#endif
+		break;
+	    case POPT_ARG_INT:
+	    case POPT_ARG_LONG:
+	    case POPT_ARG_FLOAT:
+	    case POPT_ARG_DOUBLE:
+	    case POPT_ARG_STRING:
+		*le++ = (opt->longName != NULL ? '=' : ' ');
+		strcpy(le, argDescrip);		le += strlen(le);
+		break;
+	    default:
+		break;
+	    }
+	} else {
+	    size_t lelen;
+
+	    *le++ = '=';
+	    strcpy(le, argDescrip);
+	    lelen = strlen(le);
+	    le += lelen;
+
+#ifdef	POPT_WCHAR_HACK
+	    {	const char * scopy = argDescrip;
+		mbstate_t t;
+		size_t n;
+
+		memset ((void *)&t, '\0', sizeof (t));	/* In initial state.  */
+		/* Determine number of characters.  */
+		n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t);
+
+		displaypad = (int) (lelen-n);
+	    }
+#endif
+	}
+	if (opt->argInfo & POPT_ARGFLAG_OPTIONAL)
+	    *le++ = ']';
+	*le = '\0';
+    }
+/*@=boundswrite@*/
+
+    if (help)
+	fprintf(fp,"  %-*s   ", maxLeftCol+displaypad, left);
+    else {
+	fprintf(fp,"  %s\n", left); 
+	goto out;
+    }
+
+    left = _free(left);
+/*@-branchstate@*/
+    if (defs) {
+	help = defs;
+	defs = NULL;
+    }
+/*@=branchstate@*/
+
+    helpLength = strlen(help);
+/*@-boundsread@*/
+    while (helpLength > lineLength) {
+	const char * ch;
+	char format[16];
+
+	ch = help + lineLength - 1;
+	while (ch > help && !isspace(*ch)) ch--;
+	if (ch == help) break;		/* give up */
+	while (ch > (help + 1) && isspace(*ch)) ch--;
+	ch++;
+
+	sprintf(format, "%%.%ds\n%%%ds", (int) (ch - help), (int) indentLength);
+	/*@-formatconst@*/
+	fprintf(fp, format, help, " ");
+	/*@=formatconst@*/
+	help = ch;
+	while (isspace(*help) && *help) help++;
+	helpLength = strlen(help);
+    }
+/*@=boundsread@*/
+
+    if (helpLength) fprintf(fp, "%s\n", help);
+
+out:
+    /*@-dependenttrans@*/
+    defs = _free(defs);
+    /*@=dependenttrans@*/
+    left = _free(left);
+}
+
+/**
+ * Find display width for longest argument string.
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ * @return		display width
+ */
+static size_t maxArgWidth(const struct poptOption * opt,
+		       /*@null@*/ const char * translation_domain)
+	/*@*/
+{
+    size_t max = 0;
+    size_t len = 0;
+    const char * s;
+    
+    if (opt != NULL)
+    while (opt->longName || opt->shortName || opt->arg) {
+	if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    if (opt->arg)	/* XXX program error */
+	    len = maxArgWidth(opt->arg, translation_domain);
+	    if (len > max) max = len;
+	} else if (!(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
+	    len = sizeof("  ")-1;
+	    if (opt->shortName != '\0') len += sizeof("-X")-1;
+	    if (opt->shortName != '\0' && opt->longName) len += sizeof(", ")-1;
+	    if (opt->longName) {
+		len += ((opt->argInfo & POPT_ARGFLAG_ONEDASH)
+			? sizeof("-")-1 : sizeof("--")-1);
+		len += strlen(opt->longName);
+	    }
+
+	    s = getArgDescrip(opt, translation_domain);
+
+#ifdef POPT_WCHAR_HACK
+	    /* XXX Calculate no. of display characters. */
+	    if (s) {
+		const char * scopy = s;
+		mbstate_t t;
+		size_t n;
+
+/*@-boundswrite@*/
+		memset ((void *)&t, '\0', sizeof (t));	/* In initial state.  */
+/*@=boundswrite@*/
+		/* Determine number of characters.  */
+		n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t);
+		len += sizeof("=")-1 + n;
+	    }
+#else
+	    if (s)
+		len += sizeof("=")-1 + strlen(s);
+#endif
+
+	    if (opt->argInfo & POPT_ARGFLAG_OPTIONAL) len += sizeof("[]")-1;
+	    if (len > max) max = len;
+	}
+
+	opt++;
+    }
+    
+    return max;
+}
+
+/**
+ * Display popt alias and exec help.
+ * @param fp		output file handle
+ * @param items		alias/exec array
+ * @param nitems	no. of alias/exec entries
+ * @param left		largest argument display width
+ * @param translation_domain	translation domain
+ */
+static void itemHelp(FILE * fp,
+		/*@null@*/ poptItem items, int nitems, size_t left,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    poptItem item;
+    int i;
+
+    if (items != NULL)
+    for (i = 0, item = items; i < nitems; i++, item++) {
+	const struct poptOption * opt;
+	opt = &item->option;
+	if ((opt->longName || opt->shortName) && 
+	    !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN))
+	    singleOptionHelp(fp, left, opt, translation_domain);
+    }
+}
+
+/**
+ * Display help text for a table of options.
+ * @param con		context
+ * @param fp		output file handle
+ * @param table		option(s)
+ * @param left		largest argument display width
+ * @param translation_domain	translation domain
+ */
+static void singleTableHelp(poptContext con, FILE * fp,
+		/*@null@*/ const struct poptOption * table, size_t left,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    const struct poptOption * opt;
+    const char *sub_transdom;
+
+    if (table == poptAliasOptions) {
+	itemHelp(fp, con->aliases, con->numAliases, left, NULL);
+	itemHelp(fp, con->execs, con->numExecs, left, NULL);
+	return;
+    }
+
+    if (table != NULL)
+    for (opt = table; (opt->longName || opt->shortName || opt->arg); opt++) {
+	if ((opt->longName || opt->shortName) && 
+	    !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN))
+	    singleOptionHelp(fp, left, opt, translation_domain);
+    }
+
+    if (table != NULL)
+    for (opt = table; (opt->longName || opt->shortName || opt->arg); opt++) {
+	if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_INCLUDE_TABLE)
+	    continue;
+	sub_transdom = getTableTranslationDomain(opt->arg);
+	if (sub_transdom == NULL)
+	    sub_transdom = translation_domain;
+	    
+	if (opt->descrip)
+	    fprintf(fp, "\n%s\n", D_(sub_transdom, opt->descrip));
+
+	singleTableHelp(con, fp, opt->arg, left, sub_transdom);
+    }
+}
+
+/**
+ * @param con		context
+ * @param fp		output file handle
+ */
+static int showHelpIntro(poptContext con, FILE * fp)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    int len = 6;
+    const char * fn;
+
+    fprintf(fp, POPT_("Usage:"));
+    if (!(con->flags & POPT_CONTEXT_KEEP_FIRST)) {
+/*@-boundsread@*/
+	/*@-nullderef -type@*/	/* LCL: wazzup? */
+	fn = con->optionStack->argv[0];
+	/*@=nullderef =type@*/
+/*@=boundsread@*/
+	if (fn == NULL) return len;
+	if (strchr(fn, '/')) fn = strrchr(fn, '/') + 1;
+	fprintf(fp, " %s", fn);
+	len += strlen(fn) + 1;
+    }
+
+    return len;
+}
+
+void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ int flags)
+{
+    size_t leftColWidth;
+
+    (void) showHelpIntro(con, fp);
+    if (con->otherHelp)
+	fprintf(fp, " %s\n", con->otherHelp);
+    else
+	fprintf(fp, " %s\n", POPT_("[OPTION...]"));
+
+    leftColWidth = maxArgWidth(con->options, NULL);
+    singleTableHelp(con, fp, con->options, leftColWidth, NULL);
+}
+
+/**
+ * Display usage text for an option.
+ * @param fp		output file handle
+ * @param cursor	current display position
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ */
+static size_t singleOptionUsage(FILE * fp, size_t cursor, 
+		const struct poptOption * opt,
+		/*@null@*/ const char *translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    size_t len = 4;
+    char shortStr[2] = { '\0', '\0' };
+    const char * item = shortStr;
+    const char * argDescrip = getArgDescrip(opt, translation_domain);
+
+    if (opt->shortName != '\0' && opt->longName != NULL) {
+	len += 2;
+	if (!(opt->argInfo & POPT_ARGFLAG_ONEDASH)) len++;
+	len += strlen(opt->longName);
+    } else if (opt->shortName != '\0') {
+	len++;
+	shortStr[0] = opt->shortName;
+	shortStr[1] = '\0';
+    } else if (opt->longName) {
+	len += strlen(opt->longName);
+	if (!(opt->argInfo & POPT_ARGFLAG_ONEDASH)) len++;
+	item = opt->longName;
+    }
+
+    if (len == 4) return cursor;
+
+#ifdef POPT_WCHAR_HACK
+    /* XXX Calculate no. of display characters. */
+    if (argDescrip) {
+	const char * scopy = argDescrip;
+	mbstate_t t;
+	size_t n;
+
+/*@-boundswrite@*/
+	memset ((void *)&t, '\0', sizeof (t));	/* In initial state.  */
+/*@=boundswrite@*/
+	/* Determine number of characters.  */
+	n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t);
+	len += sizeof("=")-1 + n;
+    }
+#else
+    if (argDescrip) 
+	len += sizeof("=")-1 + strlen(argDescrip);
+#endif
+
+    if ((cursor + len) > 79) {
+	fprintf(fp, "\n       ");
+	cursor = 7;
+    } 
+
+    if (opt->longName && opt->shortName) {
+	fprintf(fp, " [-%c|-%s%s%s%s]",
+	    opt->shortName, ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "" : "-"),
+	    opt->longName,
+	    (argDescrip ? " " : ""),
+	    (argDescrip ? argDescrip : ""));
+    } else {
+	fprintf(fp, " [-%s%s%s%s]",
+	    ((opt->shortName || (opt->argInfo & POPT_ARGFLAG_ONEDASH)) ? "" : "-"),
+	    item,
+	    (argDescrip ? (opt->shortName != '\0' ? " " : "=") : ""),
+	    (argDescrip ? argDescrip : ""));
+    }
+
+    return cursor + len + 1;
+}
+
+/**
+ * Display popt alias and exec usage.
+ * @param fp		output file handle
+ * @param cursor	current display position
+ * @param item		alias/exec array
+ * @param nitems	no. of ara/exec entries
+ * @param translation_domain	translation domain
+ */
+static size_t itemUsage(FILE * fp, size_t cursor,
+		/*@null@*/ poptItem item, int nitems,
+		/*@null@*/ const char * translation_domain)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/
+{
+    int i;
+
+    /*@-branchstate@*/		/* FIX: W2DO? */
+    if (item != NULL)
+    for (i = 0; i < nitems; i++, item++) {
+	const struct poptOption * opt;
+	opt = &item->option;
+        if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INTL_DOMAIN) {
+	    translation_domain = (const char *)opt->arg;
+	} else if ((opt->longName || opt->shortName) &&
+		 !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
+	    cursor = singleOptionUsage(fp, cursor, opt, translation_domain);
+	}
+    }
+    /*@=branchstate@*/
+
+    return cursor;
+}
+
+/**
+ * Keep track of option tables already processed.
+ */
+typedef struct poptDone_s {
+    int nopts;
+    int maxopts;
+    const void ** opts;
+} * poptDone;
+
+/**
+ * Display usage text for a table of options.
+ * @param con		context
+ * @param fp		output file handle
+ * @param cursor	current display position
+ * @param opt		option(s)
+ * @param translation_domain	translation domain
+ * @param done		tables already processed
+ * @return
+ */
+static size_t singleTableUsage(poptContext con, FILE * fp, size_t cursor,
+		/*@null@*/ const struct poptOption * opt,
+		/*@null@*/ const char * translation_domain,
+		/*@null@*/ poptDone done)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, done, fileSystem @*/
+{
+    /*@-branchstate@*/		/* FIX: W2DO? */
+    if (opt != NULL)
+    for (; (opt->longName || opt->shortName || opt->arg) ; opt++) {
+        if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INTL_DOMAIN) {
+	    translation_domain = (const char *)opt->arg;
+	} else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
+	    if (done) {
+		int i = 0;
+		for (i = 0; i < done->nopts; i++) {
+/*@-boundsread@*/
+		    const void * that = done->opts[i];
+/*@=boundsread@*/
+		    if (that == NULL || that != opt->arg)
+			/*@innercontinue@*/ continue;
+		    /*@innerbreak@*/ break;
+		}
+		/* Skip if this table has already been processed. */
+		if (opt->arg == NULL || i < done->nopts)
+		    continue;
+/*@-boundswrite@*/
+		if (done->nopts < done->maxopts)
+		    done->opts[done->nopts++] = (const void *) opt->arg;
+/*@=boundswrite@*/
+	    }
+	    cursor = singleTableUsage(con, fp, cursor, opt->arg,
+			translation_domain, done);
+	} else if ((opt->longName || opt->shortName) &&
+		 !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
+	    cursor = singleOptionUsage(fp, cursor, opt, translation_domain);
+	}
+    }
+    /*@=branchstate@*/
+
+    return cursor;
+}
+
+/**
+ * Return concatenated short options for display.
+ * @todo Sub-tables should be recursed.
+ * @param opt		option(s)
+ * @param fp		output file handle
+ * @retval str		concatenation of short options
+ * @return		length of display string
+ */
+static int showShortOptions(const struct poptOption * opt, FILE * fp,
+		/*@null@*/ char * str)
+	/*@globals fileSystem @*/
+	/*@modifies *str, *fp, fileSystem @*/
+	/*@requires maxRead(str) >= 0 @*/
+{
+    /* bufsize larger then the ascii set, lazy alloca on top level call. */
+    char * s = (str != NULL ? str : memset(alloca(300), 0, 300));
+    int len = 0;
+
+/*@-boundswrite@*/
+    if (opt != NULL)
+    for (; (opt->longName || opt->shortName || opt->arg); opt++) {
+	if (opt->shortName && !(opt->argInfo & POPT_ARG_MASK))
+	    s[strlen(s)] = opt->shortName;
+	else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE)
+	    if (opt->arg)	/* XXX program error */
+		len = showShortOptions(opt->arg, fp, s);
+    } 
+/*@=boundswrite@*/
+
+    /* On return to top level, print the short options, return print length. */
+    if (s == str && *s != '\0') {
+	fprintf(fp, " [-%s]", s);
+	len = strlen(s) + sizeof(" [-]")-1;
+    }
+    return len;
+}
+
+void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ int flags)
+{
+    poptDone done = memset(alloca(sizeof(*done)), 0, sizeof(*done));
+    size_t cursor;
+
+    done->nopts = 0;
+    done->maxopts = 64;
+    cursor = done->maxopts * sizeof(*done->opts);
+/*@-boundswrite@*/
+    done->opts = memset(alloca(cursor), 0, cursor);
+    /*@-keeptrans@*/
+    done->opts[done->nopts++] = (const void *) con->options;
+    /*@=keeptrans@*/
+/*@=boundswrite@*/
+
+    cursor = showHelpIntro(con, fp);
+    cursor += showShortOptions(con->options, fp, NULL);
+    cursor = singleTableUsage(con, fp, cursor, con->options, NULL, done);
+    cursor = itemUsage(fp, cursor, con->aliases, con->numAliases, NULL);
+    cursor = itemUsage(fp, cursor, con->execs, con->numExecs, NULL);
+
+    if (con->otherHelp) {
+	cursor += strlen(con->otherHelp) + 1;
+	if (cursor > 79) fprintf(fp, "\n       ");
+	fprintf(fp, " %s", con->otherHelp);
+    }
+
+    fprintf(fp, "\n");
+}
+
+void poptSetOtherOptionHelp(poptContext con, const char * text)
+{
+    con->otherHelp = _free(con->otherHelp);
+    con->otherHelp = xstrdup(text);
+}
diff --git a/libpopt/poptint.h b/libpopt/poptint.h
new file mode 100644
index 0000000..5e75712
--- /dev/null
+++ b/libpopt/poptint.h
@@ -0,0 +1,116 @@
+/** \ingroup popt
+ * \file popt/poptint.h
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_POPTINT
+#define H_POPTINT
+
+/**
+ * Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
+ * @param p		memory to free
+ * @retval		NULL always
+ */
+/*@unused@*/ static inline /*@null@*/ void *
+_free(/*@only@*/ /*@null@*/ const void * p)
+	/*@modifies p @*/
+{
+    if (p != NULL)	free((void *)p);
+    return NULL;
+}
+
+/* Bit mask macros. */
+/*@-exporttype -redef @*/
+typedef	unsigned int __pbm_bits;
+/*@=exporttype =redef @*/
+#define	__PBM_NBITS		(8 * sizeof (__pbm_bits))
+#define	__PBM_IX(d)		((d) / __PBM_NBITS)
+#define __PBM_MASK(d)		((__pbm_bits) 1 << (((unsigned)(d)) % __PBM_NBITS))
+/*@-exporttype -redef @*/
+typedef struct {
+    __pbm_bits bits[1];
+} pbm_set;
+/*@=exporttype =redef @*/
+#define	__PBM_BITS(set)	((set)->bits)
+
+#define	PBM_ALLOC(d)	calloc(__PBM_IX (d) + 1, sizeof(__pbm_bits))
+#define	PBM_FREE(s)	_free(s);
+#define PBM_SET(d, s)   (__PBM_BITS (s)[__PBM_IX (d)] |= __PBM_MASK (d))
+#define PBM_CLR(d, s)   (__PBM_BITS (s)[__PBM_IX (d)] &= ~__PBM_MASK (d))
+#define PBM_ISSET(d, s) ((__PBM_BITS (s)[__PBM_IX (d)] & __PBM_MASK (d)) != 0)
+
+struct optionStackEntry {
+    int argc;
+/*@only@*/ /*@null@*/
+    const char ** argv;
+/*@only@*/ /*@null@*/
+    pbm_set * argb;
+    int next;
+/*@only@*/ /*@null@*/
+    const char * nextArg;
+/*@observer@*/ /*@null@*/
+    const char * nextCharArg;
+/*@dependent@*/ /*@null@*/
+    poptItem currAlias;
+    int stuffed;
+};
+
+struct poptContext_s {
+    struct optionStackEntry optionStack[POPT_OPTION_DEPTH];
+/*@dependent@*/
+    struct optionStackEntry * os;
+/*@owned@*/ /*@null@*/
+    const char ** leftovers;
+    int numLeftovers;
+    int nextLeftover;
+/*@keep@*/
+    const struct poptOption * options;
+    int restLeftover;
+/*@only@*/ /*@null@*/
+    const char * appName;
+/*@only@*/ /*@null@*/
+    poptItem aliases;
+    int numAliases;
+    int flags;
+/*@owned@*/ /*@null@*/
+    poptItem execs;
+    int numExecs;
+/*@only@*/ /*@null@*/
+    const char ** finalArgv;
+    int finalArgvCount;
+    int finalArgvAlloced;
+/*@dependent@*/ /*@null@*/
+    poptItem doExec;
+/*@only@*/
+    const char * execPath;
+    int execAbsolute;
+/*@only@*/ /*@relnull@*/
+    const char * otherHelp;
+/*@null@*/
+    pbm_set * arg_strip;
+};
+
+#ifdef HAVE_LIBINTL_H
+#include <libintl.h>
+#endif
+
+#if defined(HAVE_GETTEXT) && !defined(__LCLINT__)
+#define _(foo) gettext(foo)
+#else
+#define _(foo) foo
+#endif
+
+#if defined(HAVE_DCGETTEXT) && !defined(__LCLINT__)
+#define D_(dom, str) dgettext(dom, str)
+#define POPT_(foo) D_("popt", foo)
+#else
+#define D_(dom, str) str
+#define POPT_(foo) foo
+#endif
+
+#define N_(foo) foo
+
+#endif
diff --git a/libpopt/poptparse.c b/libpopt/poptparse.c
new file mode 100644
index 0000000..a0dea80
--- /dev/null
+++ b/libpopt/poptparse.c
@@ -0,0 +1,227 @@
+/** \ingroup popt
+ * \file popt/poptparse.c
+ */
+
+/* (C) 1998-2002 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#include "system.h"
+
+#define POPT_ARGV_ARRAY_GROW_DELTA 5
+
+/*@-boundswrite@*/
+int poptDupArgv(int argc, const char **argv,
+		int * argcPtr, const char *** argvPtr)
+{
+    size_t nb = (argc + 1) * sizeof(*argv);
+    const char ** argv2;
+    char * dst;
+    int i;
+
+    if (argc <= 0 || argv == NULL)	/* XXX can't happen */
+	return POPT_ERROR_NOARG;
+    for (i = 0; i < argc; i++) {
+	if (argv[i] == NULL)
+	    return POPT_ERROR_NOARG;
+	nb += strlen(argv[i]) + 1;
+    }
+	
+    dst = malloc(nb);
+    if (dst == NULL)			/* XXX can't happen */
+	return POPT_ERROR_MALLOC;
+    argv2 = (void *) dst;
+    dst += (argc + 1) * sizeof(*argv);
+
+    /*@-branchstate@*/
+    for (i = 0; i < argc; i++) {
+	argv2[i] = dst;
+	dst += strlen(strcpy(dst, argv[i])) + 1;
+    }
+    /*@=branchstate@*/
+    argv2[argc] = NULL;
+
+    if (argvPtr) {
+	*argvPtr = argv2;
+    } else {
+	free(argv2);
+	argv2 = NULL;
+    }
+    if (argcPtr)
+	*argcPtr = argc;
+    return 0;
+}
+/*@=boundswrite@*/
+
+/*@-bounds@*/
+int poptParseArgvString(const char * s, int * argcPtr, const char *** argvPtr)
+{
+    const char * src;
+    char quote = '\0';
+    int argvAlloced = POPT_ARGV_ARRAY_GROW_DELTA;
+    const char ** argv = malloc(sizeof(*argv) * argvAlloced);
+    int argc = 0;
+    int buflen = strlen(s) + 1;
+    char * buf = memset(alloca(buflen), 0, buflen);
+    int rc = POPT_ERROR_MALLOC;
+
+    if (argv == NULL) return rc;
+    argv[argc] = buf;
+
+    for (src = s; *src != '\0'; src++) {
+	if (quote == *src) {
+	    quote = '\0';
+	} else if (quote != '\0') {
+	    if (*src == '\\') {
+		src++;
+		if (!*src) {
+		    rc = POPT_ERROR_BADQUOTE;
+		    goto exit;
+		}
+		if (*src != quote) *buf++ = '\\';
+	    }
+	    *buf++ = *src;
+	} else if (isspace(*src)) {
+	    if (*argv[argc] != '\0') {
+		buf++, argc++;
+		if (argc == argvAlloced) {
+		    argvAlloced += POPT_ARGV_ARRAY_GROW_DELTA;
+		    argv = realloc(argv, sizeof(*argv) * argvAlloced);
+		    if (argv == NULL) goto exit;
+		}
+		argv[argc] = buf;
+	    }
+	} else switch (*src) {
+	  case '"':
+	  case '\'':
+	    quote = *src;
+	    /*@switchbreak@*/ break;
+	  case '\\':
+	    src++;
+	    if (!*src) {
+		rc = POPT_ERROR_BADQUOTE;
+		goto exit;
+	    }
+	    /*@fallthrough@*/
+	  default:
+	    *buf++ = *src;
+	    /*@switchbreak@*/ break;
+	}
+    }
+
+    if (strlen(argv[argc])) {
+	argc++, buf++;
+    }
+
+    rc = poptDupArgv(argc, argv, argcPtr, argvPtr);
+
+exit:
+    if (argv) free(argv);
+    return rc;
+}
+/*@=bounds@*/
+
+/* still in the dev stage.
+ * return values, perhaps 1== file erro
+ * 2== line to long
+ * 3== umm.... more?
+ */
+int poptConfigFileToString(FILE *fp, char ** argstrp, /*@unused@*/ int flags)
+{
+    char line[999];
+    char * argstr;
+    char * p;
+    char * q;
+    char * x;
+    int t;
+    int argvlen = 0;
+    size_t maxlinelen = sizeof(line);
+    size_t linelen;
+    int maxargvlen = 480;
+    int linenum = 0;
+
+    *argstrp = NULL;
+
+    /*   |   this_is   =   our_line
+     *	     p             q      x
+     */
+
+    if (fp == NULL)
+	return POPT_ERROR_NULLARG;
+
+    argstr = calloc(maxargvlen, sizeof(*argstr));
+    if (argstr == NULL) return POPT_ERROR_MALLOC;
+
+    while (fgets(line, (int)maxlinelen, fp) != NULL) {
+	linenum++;
+	p = line;
+
+	/* loop until first non-space char or EOL */
+	while( *p != '\0' && isspace(*p) )
+	    p++;
+
+	linelen = strlen(p);
+	if (linelen >= maxlinelen-1)
+	    return POPT_ERROR_OVERFLOW;	/* XXX line too long */
+
+	if (*p == '\0' || *p == '\n') continue;	/* line is empty */
+	if (*p == '#') continue;		/* comment line */
+
+	q = p;
+
+	while (*q != '\0' && (!isspace(*q)) && *q != '=')
+	    q++;
+
+	if (isspace(*q)) {
+	    /* a space after the name, find next non space */
+	    *q++='\0';
+	    while( *q != '\0' && isspace((int)*q) ) q++;
+	}
+	if (*q == '\0') {
+	    /* single command line option (ie, no name=val, just name) */
+	    q[-1] = '\0';		/* kill off newline from fgets() call */
+	    argvlen += (t = q - p) + (sizeof(" --")-1);
+	    if (argvlen >= maxargvlen) {
+		maxargvlen = (t > maxargvlen) ? t*2 : maxargvlen*2;
+		argstr = realloc(argstr, maxargvlen);
+		if (argstr == NULL) return POPT_ERROR_MALLOC;
+	    }
+	    strcat(argstr, " --");
+	    strcat(argstr, p);
+	    continue;
+	}
+	if (*q != '=')
+	    continue;	/* XXX for now, silently ignore bogus line */
+		
+	/* *q is an equal sign. */
+	*q++ = '\0';
+
+	/* find next non-space letter of value */
+	while (*q != '\0' && isspace(*q))
+	    q++;
+	if (*q == '\0')
+	    continue;	/* XXX silently ignore missing value */
+
+	/* now, loop and strip all ending whitespace */
+	x = p + linelen;
+	while (isspace(*--x))
+	    *x = 0;	/* null out last char if space (including fgets() NL) */
+
+	/* rest of line accept */
+	t = x - p;
+	argvlen += t + (sizeof("' --='")-1);
+	if (argvlen >= maxargvlen) {
+	    maxargvlen = (t > maxargvlen) ? t*2 : maxargvlen*2;
+	    argstr = realloc(argstr, maxargvlen);
+	    if (argstr == NULL) return POPT_ERROR_MALLOC;
+	}
+	strcat(argstr, " --");
+	strcat(argstr, p);
+	strcat(argstr, "=\"");
+	strcat(argstr, q);
+	strcat(argstr, "\"");
+    }
+
+    *argstrp = argstr;
+    return 0;
+}
diff --git a/libpopt/system.h b/libpopt/system.h
new file mode 100644
index 0000000..c3d46cb
--- /dev/null
+++ b/libpopt/system.h
@@ -0,0 +1,81 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if defined (__GLIBC__) && defined(__LCLINT__)
+/*@-declundef@*/
+/*@unchecked@*/
+extern __const __int32_t *__ctype_tolower;
+/*@unchecked@*/
+extern __const __int32_t *__ctype_toupper;
+/*@=declundef@*/
+#endif
+
+#include <ctype.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#if HAVE_MCHECK_H 
+#include <mcheck.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef __NeXT
+/* access macros are not declared in non posix mode in unistd.h -
+ don't try to use posix on NeXTstep 3.3 ! */
+#include <libc.h>
+#endif
+
+#if defined(__LCLINT__)
+/*@-declundef -incondefs @*/ /* LCL: missing annotation */
+/*@only@*/ /*@out@*/
+void * alloca (size_t __size)
+	/*@ensures MaxSet(result) == (__size - 1) @*/
+	/*@*/;
+/*@=declundef =incondefs @*/
+#endif
+
+/* AIX requires this to be the first thing in the file.  */ 
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+#pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+char *alloca ();
+#   endif
+#  endif
+# endif
+#elif defined(__GNUC__) && defined(__STRICT_ANSI__)
+#define alloca __builtin_alloca
+#endif
+
+/*@-redecl -redef@*/
+/*@mayexit@*/ /*@only@*/ /*@unused@*/
+char * xstrdup (const char *str)
+	/*@*/;
+/*@=redecl =redef@*/
+
+#if HAVE_MCHECK_H && defined(__GNUC__)
+#define	vmefail()	(fprintf(stderr, "virtual memory exhausted.\n"), exit(EXIT_FAILURE), NULL)
+#define xstrdup(_str)   (strcpy((malloc(strlen(_str)+1) ? : vmefail()), (_str)))
+#else
+#define	xstrdup(_str)	strdup(_str)
+#endif  /* HAVE_MCHECK_H && defined(__GNUC__) */
+
+#if HAVE___SECURE_GETENV && !defined(__LCLINT__)
+#define	getenv(_s)	__secure_getenv(_s)
+#endif
+
+#include "popt.h"
diff --git a/libutil/Android.mk b/libutil/Android.mk
new file mode 100644
index 0000000..29f3bfb
--- /dev/null
+++ b/libutil/Android.mk
@@ -0,0 +1,21 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	op_cpufreq.c \
+	op_deviceio.c \
+	op_file.c \
+	op_fileio.c \
+	op_get_time.c \
+	op_libiberty.c \
+	op_lockfile.c \
+	op_popt.c \
+	op_string.c \
+	op_version.c
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/..
+
+LOCAL_MODULE := libutil
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/libutil/fscanf.c b/libutil/fscanf.c
new file mode 100644
index 0000000..d567324
--- /dev/null
+++ b/libutil/fscanf.c
@@ -0,0 +1,22 @@
+#include <stdio.h> 
+
+// ugly hack because we don't have fscanf
+
+int fscanf(FILE* stream, const char* format, int* value)
+{
+    int c;
+    int r = 0;
+    do {
+        c = fgetc(stream);
+        if (c>='0' && c<='9') {
+            r = r*10 + (c-'0');
+            continue;
+        }
+        break;
+    } while (1);
+
+    *value = r;
+
+    // gahhhh
+    return 1;
+}
diff --git a/libutil/op_cpufreq.c b/libutil/op_cpufreq.c
new file mode 100644
index 0000000..78a6333
--- /dev/null
+++ b/libutil/op_cpufreq.c
@@ -0,0 +1,64 @@
+/**
+ * @file op_cpufreq.c
+ * get cpu frequency definition
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "op_fileio.h"
+
+double op_cpu_frequency(void)
+{
+	double fval = 0.0;
+	unsigned long uval;
+	char * line = NULL;
+
+	FILE * fp = op_try_open_file("/proc/cpuinfo", "r");
+	if (!fp)
+		return 0.0;
+
+	while (1) {
+		line = op_get_line(fp);
+
+		if (!line)
+			break;
+
+		if (line[0] == '\0') {
+			free(line);
+			continue;
+		}
+
+		/* x86/parisc/ia64/x86_64 */
+		if (sscanf(line, "cpu MHz : %lf", &fval) == 1)
+			break;
+		/* ppc/ppc64 */
+		if (sscanf(line, "clock : %lfMHz", &fval) == 1)
+			break;
+		/* alpha */
+		if (sscanf(line, "cycle frequency [Hz] : %lu", &uval) == 1) {
+			fval = uval / 1E6;
+			break;
+		}
+		/* sparc64 if CONFIG_SMP only */
+		if (sscanf(line, "Cpu0ClkTck : %lx", &uval) == 1) {
+			fval = uval / 1E6;
+			break;
+		}
+		/* s390 doesn't provide cpu freq, checked up to 2.6-test4 */
+
+		free(line);
+	}
+
+	if (line)
+		free(line);
+	op_close_file(fp);
+
+	return fval;
+}
diff --git a/libutil/op_cpufreq.h b/libutil/op_cpufreq.h
new file mode 100644
index 0000000..0a71172
--- /dev/null
+++ b/libutil/op_cpufreq.h
@@ -0,0 +1,30 @@
+/**
+ * @file op_cpufreq.h
+ * get cpu frequency declaration
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_CPUFREQ_H
+#define OP_CPUFREQ_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/*
+ * return the estimated cpu frequency in Mhz through
+ * parsing /proc/cpuinfo, return 0 if this information
+ * is not avalaible e.g. sparc64 with a non SMP kernel
+ */
+double op_cpu_frequency(void);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* !OP_CPUFREQ_H */
diff --git a/libutil/op_deviceio.c b/libutil/op_deviceio.c
new file mode 100644
index 0000000..8210304
--- /dev/null
+++ b/libutil/op_deviceio.c
@@ -0,0 +1,42 @@
+/**
+ * @file op_deviceio.c
+ * Reading from a special device
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "op_deviceio.h"
+
+#include <sys/types.h>
+#include <fcntl.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+fd_t op_open_device(char const * name)
+{
+	return open(name, O_RDONLY);
+}
+
+
+ssize_t op_read_device(fd_t devfd, void * buf, size_t size)
+{
+	ssize_t count;
+
+	lseek(devfd, 0, SEEK_SET);
+
+	count = read(devfd, buf, size);
+
+	if (count < 0 && errno != EINTR && errno != EAGAIN) {
+		perror("oprofiled:op_read_device: ");
+		exit(EXIT_FAILURE);
+	}
+
+	return count;
+}
diff --git a/libutil/op_deviceio.h b/libutil/op_deviceio.h
new file mode 100644
index 0000000..f3bd4c2
--- /dev/null
+++ b/libutil/op_deviceio.h
@@ -0,0 +1,57 @@
+/**
+ * @file op_deviceio.h
+ * Reading from a special device
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_DEVICEIO_H
+#define OP_DEVICEIO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "op_types.h"
+
+#include <unistd.h>
+
+/**
+ * op_open_device - open a special char device for reading
+ * @param name  file name of device file
+ *
+ * Open the special file name. Returns the file descriptor
+ * for the file or -1 on error.
+ */
+fd_t op_open_device(char const * name);
+
+/**
+ * op_read_device - read from a special char device
+ * @param devfd  file descriptor of device
+ * @param buf  buffer
+ * @param size  size of buffer
+ *
+ * Read size bytes from a device into buffer buf.
+ * A seek to the start of the device file is done first
+ * then a read is requested in one go of size bytes.
+ *
+ * It is the caller's responsibility to do further op_read_device()
+ * calls if the number of bytes read is not what is requested
+ * (where this is applicable).
+ *
+ * The number of bytes read is returned, or a negative number
+ * on failure (in which case errno will be set). If the call is
+ * interrupted, then errno will be EINTR, and the client should
+ * arrange for re-starting the read if necessary.
+ */
+ssize_t op_read_device(fd_t devfd, void * buf, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_DEVICEIO_H */
diff --git a/libutil/op_file.c b/libutil/op_file.c
new file mode 100644
index 0000000..e3e6cb6
--- /dev/null
+++ b/libutil/op_file.c
@@ -0,0 +1,185 @@
+/**
+ * @file op_file.c
+ * Useful file management helpers
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <fnmatch.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+
+#include "op_file.h"
+#include "op_libiberty.h"
+
+int op_file_readable(char const * file)
+{
+	struct stat st;
+	return !stat(file, &st) && S_ISREG(st.st_mode) && !access(file, R_OK);
+}
+
+
+time_t op_get_mtime(char const * file)
+{
+	struct stat st;
+
+	if (stat(file, &st))
+		return 0;
+
+	return st.st_mtime;
+}
+
+
+int create_dir(char const * dir)
+{
+	if (mkdir(dir, 0755)) {
+		/* FIXME: Does not verify existing is a dir */
+		if (errno == EEXIST)
+			return 0;
+		return errno;
+	}
+
+	return 0;
+}
+
+
+int create_path(char const * path)
+{
+	int ret = 0;
+
+	char * str = xstrdup(path);
+
+	char * pos = str[0] == '/' ? str + 1 : str;
+
+	for ( ; (pos = strchr(pos, '/')) != NULL; ++pos) {
+		*pos = '\0';
+		ret = create_dir(str);
+		*pos = '/';
+		if (ret)
+			break;
+	}
+
+	free(str);
+	return ret;
+}
+
+
+inline static int is_dot_or_dotdot(char const * name)
+{
+	return name[0] == '.' &&
+		(name[1] == '\0' ||
+		 (name[1] == '.' && name[2] == '\0'));
+}
+
+
+/* If non-null is returned, the caller is responsible for freeing
+ * the memory allocated for the return value. */
+static char * make_pathname_from_dirent(char const * basedir,
+				      struct dirent * ent,
+				      struct stat * st_buf)
+{
+	int name_len;
+	char * name;
+	name_len = strlen(basedir) + strlen("/") + strlen(ent->d_name) + 1;
+	name = xmalloc(name_len);
+	sprintf(name, "%s/%s", basedir,	ent->d_name);
+	if (stat(name, st_buf) != 0) {
+		free(name);
+		name = NULL;
+	}
+	return name;
+}
+
+
+int get_matching_pathnames(void * name_list, get_pathname_callback getpathname,
+			   char const * base_dir, char const * filter,
+			   enum recursion_type recursion)
+{
+/* The algorithm below depends on recursion type (of which there are 3)
+ * and whether the current dirent matches the filter.  There are 6 possible
+ * different behaviors, which is why we define 6 case below in the switch
+ * statement of the algorithm.  Actually, when the recursion type is
+ * MATCH_DIR_ONLY_RECURSION, the behavior is the same, whether or not the dir
+ * entry matches the filter.  However, the behavior of the recursion types
+ * NO_RECURSION and MATCH_ANY_ENTRY_RECURSION do depend on the dir entry
+ * filter match, so for simplicity, we perform this match for all recursion
+ * types and logically OR the match result with the  value of the passed
+ * recursion_type.
+ */
+#define NO_MATCH 0
+#define MATCH 1
+
+	DIR * dir;
+	struct dirent * ent;
+	struct stat stat_buffer;
+	int match;
+	char * name = NULL;
+
+	if (!(dir = opendir(base_dir)))
+		return -1;
+	while ((ent = readdir(dir)) != 0) {
+		if (is_dot_or_dotdot(ent->d_name))
+			continue;
+		if (fnmatch(filter, ent->d_name, 0) == 0)
+			match = 1;
+		else
+			match = 0;
+
+		switch (recursion | match) {
+		case NO_RECURSION + NO_MATCH:
+		case MATCH_ANY_ENTRY_RECURSION + NO_MATCH:
+			// nothing to do but continue the loop
+			break;
+		case NO_RECURSION + MATCH:
+			getpathname(ent->d_name, name_list);
+			break;
+		case MATCH_ANY_ENTRY_RECURSION + MATCH:
+			name = make_pathname_from_dirent(base_dir, ent,
+						       &stat_buffer);
+			if (name && S_ISDIR(stat_buffer.st_mode) &&
+			    !S_ISLNK(stat_buffer.st_mode)) {
+				get_matching_pathnames(
+					name_list, getpathname,
+					name, filter, recursion);
+			} else {
+				getpathname(name, name_list);
+			}
+			free(name);
+			break;
+		case MATCH_DIR_ONLY_RECURSION + NO_MATCH:
+		case MATCH_DIR_ONLY_RECURSION + MATCH:
+			name = make_pathname_from_dirent(base_dir, ent,
+						       &stat_buffer);
+			if (name && S_ISDIR(stat_buffer.st_mode) &&
+			    !S_ISLNK(stat_buffer.st_mode)) {
+				/* Check if full directory name contains
+				 * match to the filter; if so, add it to
+				 * name_list and quit; else, recurse.
+				 */
+				if (!fnmatch(filter, name, 0)) {
+					getpathname(name, name_list);
+				} else {
+					get_matching_pathnames(
+						name_list, getpathname,
+						name, filter, recursion);
+				}
+			}
+			free(name);
+			break;
+		}
+	}
+	closedir(dir);
+
+	return 0;
+}
diff --git a/libutil/op_file.h b/libutil/op_file.h
new file mode 100644
index 0000000..d22862c
--- /dev/null
+++ b/libutil/op_file.h
@@ -0,0 +1,109 @@
+/**
+ * @file op_file.h
+ * Useful file management helpers
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_FILE_H
+#define OP_FILE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+
+/**
+ * op_file_readable - is a file readable
+ * @param file file name
+ *
+ * Return true if the given file is readable and regular.
+ *
+ * Beware of race conditions !
+ */
+int op_file_readable(char const * file);
+
+/**
+ * op_get_mtime - get mtime of file
+ * @param file  file name
+ *
+ * Returns the mtime of the given file or 0 on failure
+ */
+time_t op_get_mtime(char const * file);
+
+/**
+ * create_dir - create a directory
+ * @param dir  the directory name to create
+ *
+ * Returns 0 on success.
+ */
+int create_dir(char const * dir);
+
+
+/**
+ * create_path - create a path
+ * @param path  the path to create
+ *
+ * create directory for each dir components in path
+ * the last path component is not considered as a directory
+ * but as a filename
+ *
+ * Returns 0 on success.
+ */
+int create_path(char const * path);
+
+/**
+ * Clients of get_matching_pathnames must provide their own implementation
+ * of get_pathname_callback.
+ */
+typedef void (*get_pathname_callback)(char const * pathname, void * name_list);
+
+/* This enum is intended solely for the use of get_matching_pathnames(),
+ * bit 0 is reserved for internal use..*/
+enum recursion_type {
+	NO_RECURSION = 2,
+	MATCH_ANY_ENTRY_RECURSION = 4,
+	MATCH_DIR_ONLY_RECURSION = 8,
+};
+/**
+ * @param name_list where to store result
+ * @param get_pathname_callback client-provided callback function
+ * @param base_dir directory from where lookup starts
+ * @param filter a pathname filter
+ * @param recursion recursion_type -- see above enum and following description:
+ *	NO_RECURSION:  Find matching files from passed base_dir and call
+ *          get_pathname_callback to add entry to name_list to be returned.
+ *	MATCH_ANY_ENTRY_RECURSION: Starting at base_dir, for each entry in the
+ *	   dir that matches the filter: if entry is of type 'dir', recurse;
+ *         else call get_pathname_callback to add entry to name_list to be
+ *         returned.
+ *	MATCH_DIR_ONLY_RECURSION: Starting at base_dir, if an entry in the
+ *         dir is of type 'dir' and its complete pathname contains a match to
+ *         the filter, call get_pathname_callback to add entry to name_list to
+ *         be returned; else recurse.
+ *
+ * Returns 0 on success.
+ *
+ * Return a list of pathnames under base_dir, filtered by filter and optionally
+ * looking in sub-directory. See description above of the recursion_type 
+ * parameter for more details.
+ *    NOTE: For C clients: Your implementation of the get_pathname_callback
+ *          function will probably dynamically allocate storage for elements
+ *          added to name_list.  If so, remember to free that memory when it's
+ *          no longer needed.
+ */
+int get_matching_pathnames(void * name_list, get_pathname_callback,
+			   char const * base_dir, char const * filter,
+			   enum recursion_type recursion);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_FILE_H */
diff --git a/libutil/op_fileio.c b/libutil/op_fileio.c
new file mode 100644
index 0000000..9b3e21d
--- /dev/null
+++ b/libutil/op_fileio.c
@@ -0,0 +1,228 @@
+/**
+ * @file op_fileio.c
+ * Reading from / writing to files
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <unistd.h>
+
+#include "op_fileio.h"
+
+#include "op_libiberty.h"
+
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+static FILE * op_do_open_file(char const * name, char const * mode, int fatal)
+{
+	FILE * fp;
+
+	fp = fopen(name, mode);
+
+	if (!fp) {
+		if (fatal) {
+			fprintf(stderr,"oprofiled:op_do_open_file: %s: %s",
+				name, strerror(errno));
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	return fp;
+}
+
+
+FILE * op_try_open_file(char const * name, char const * mode)
+{
+	return op_do_open_file(name, mode, 0);
+}
+
+
+FILE * op_open_file(char const * name, char const * mode)
+{
+	return op_do_open_file(name, mode, 1);
+}
+
+
+void op_close_file(FILE * fp)
+{
+	if (fclose(fp))
+		perror("oprofiled:op_close_file: ");
+}
+
+
+void op_write_file(FILE * fp, void const * buf, size_t size)
+{
+	size_t written;
+
+	if (size == 0)
+		return;
+
+	written = fwrite(buf, size, 1, fp);
+
+	if (written != 1) {
+		fprintf(stderr,
+			"oprofiled:op_write_file: wrote less than expected: %lu bytes.\n",
+			(unsigned long)size);
+		exit(EXIT_FAILURE);
+	}
+}
+
+
+void op_write_u8(FILE * fp, u8 val)
+{
+	op_write_file(fp, &val, sizeof(val));
+}
+
+
+void op_write_u32(FILE * fp, u32 val)
+{
+	op_write_file(fp, &val, sizeof(val));
+}
+
+
+void op_write_u64(FILE * fp, u64 val)
+{
+	op_write_file(fp, &val, sizeof(val));
+}
+
+
+u32 op_read_int_from_file(char const * filename, int fatal)
+{
+	FILE * fp;
+	u32 value;
+
+	fp = fopen(filename, "r");
+	if (fp == NULL) {
+		if (!fatal)
+			return (u32)-1;
+		fprintf(stderr,
+			"op_read_int_from_file: Failed to open %s, reason %s\n",
+			filename, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	if (fscanf(fp, "%u", &value) != 1) {
+		fclose(fp);
+		if (!fatal)
+			return (u32)-1;
+		fprintf(stderr,
+			"op_read_int_from_file: Failed to convert contents of file %s to integer\n",
+			filename);
+		exit(EXIT_FAILURE);
+	}
+
+	fclose(fp);
+
+	return value;
+}
+
+
+char * op_get_line(FILE * fp)
+{
+	char * buf;
+	char * cp;
+	int c;
+	size_t max = 512;
+
+	buf = xmalloc(max);
+	cp = buf;
+
+	while (1) {
+		switch (c = getc(fp)) {
+			case EOF:
+				free(buf);
+				return NULL;
+				break;
+
+			case '\n':
+			case '\0':
+				*cp = '\0';
+				return buf;
+				break;
+
+			default:
+				*cp = (char)c;
+				cp++;
+				if (((size_t)(cp - buf)) == max) {
+					buf = xrealloc(buf, max + 128);
+					cp = buf + max;
+					max += 128;
+				}
+				break;
+		}
+	}
+}
+
+
+/* FIXME the debug info stuff should be handled by binutils */
+unsigned long
+calc_crc32(unsigned long crc, unsigned char * buf, size_t len)
+{
+	static const unsigned long crc32_table[256] =
+	{
+		0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+		0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+		0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+		0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+		0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+		0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+		0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+		0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+		0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+		0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+		0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+		0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+		0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+ 		0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+		0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+		0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+		0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+		0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+		0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+		0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+		0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+		0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+		0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+		0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+		0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+		0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+		0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+		0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+		0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+		0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+		0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+		0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+		0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+		0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+		0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+		0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+		0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+		0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+		0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+		0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+		0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+		0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+		0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+		0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+		0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+		0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+		0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+		0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+		0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+		0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+		0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+		0x2d02ef8d
+	};
+	unsigned char * end;
+
+	crc = ~crc & 0xffffffff;
+	for (end = buf + len; buf < end; ++buf)
+		crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
+	return ~crc & 0xffffffff;
+}
diff --git a/libutil/op_fileio.h b/libutil/op_fileio.h
new file mode 100644
index 0000000..49b126d
--- /dev/null
+++ b/libutil/op_fileio.h
@@ -0,0 +1,140 @@
+/**
+ * @file op_fileio.h
+ * Reading from / writing to files
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_FILEIO_H
+#define OP_FILEIO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "op_types.h"
+
+#include <stdio.h>
+
+/**
+ * op_try_open_file - open a file
+ * @param name  file name
+ * @param mode  mode string
+ *
+ * Open a file name.
+ * Returns file handle or %NULL on failure.
+ */
+FILE * op_try_open_file(char const * name, char const * mode);
+
+/**
+ * op_open_file - open a file
+ * @param name  file name
+ * @param mode  mode string
+ *
+ * Open a file name.
+ * Failure to open is fatal.
+ */
+FILE * op_open_file(char const * name, char const * mode);
+
+/**
+ * op_read_int_from_file - parse an ASCII value from a file into an integer
+ * @param filename  name of file to parse integer value from
+ * @param fatal  non-zero if any error must be fatal
+ *
+ * Reads an ASCII integer from the given file. If an error occur and fatal is
+ * zero (u32)-1 is returned else the value read in is returned.
+ */
+u32 op_read_int_from_file(char const * filename, int fatal);
+
+/**
+ * op_close_file - close a file
+ * @param fp  file pointer
+ *
+ * Closes a file pointer. A non-fatal
+ * error message is produced if the
+ * close fails.
+ */
+void op_close_file(FILE * fp);
+
+/**
+ * op_write_file - write to a file
+ * @param fp  file pointer
+ * @param buf  buffer
+ * @param size  nr. of bytes to write
+ *
+ * Write size bytes of buffer buf to a file.
+ * Failure is fatal.
+ */
+void op_write_file(FILE * fp, void const * buf, size_t size);
+
+/**
+ * op_write_u32 - write four bytes to a file
+ * @param fp  file pointer
+ * @param val  value to write
+ *
+ * Write an unsigned four-byte value val to a file.
+ * Failure is fatal.
+ *
+ * No byte-swapping is done.
+ */
+void op_write_u32(FILE * fp, u32 val);
+
+/**
+ * op_write_u64 - write eight bytes to a file
+ * @param fp  file pointer
+ * @param val  value to write
+ *
+ * Write an unsigned eight-byte value val to a file.
+ * Failure is fatal.
+ *
+ * No byte-swapping is done.
+ */
+void op_write_u64(FILE * fp, u64 val);
+
+/**
+ * op_write_u8 - write a byte to a file
+ * @param fp  file pointer
+ * @param val  value to write
+ *
+ * Write an unsigned byte value val to a file.
+ * Failure is fatal.
+ */
+void op_write_u8(FILE * fp, u8 val);
+
+/**
+ * op_get_line - read an ASCII line from a file
+ * @param fp  file pointer
+ *
+ * Get a line of ASCII text from a file. The file is read
+ * up to the first '\0' or '\n'. A trailing '\n' is deleted.
+ *
+ * Returns the dynamically-allocated string containing
+ * that line. At the end of a file NULL will be returned.
+ * be returned.
+ *
+ * The string returned must be free()d by the caller.
+ *
+ * getline() is not a proper solution to replace this function
+ */
+char * op_get_line(FILE * fp);
+
+/**
+ * calc_crc32
+ * @param crc current value
+ * @param buf pointer to buffer
+ * @param len
+ *
+ * Returns current crc computed from the crc argument and the
+ * characters in len characters in buf.
+ */
+unsigned long calc_crc32(unsigned long crc, unsigned char * buf, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_FILEIO_H */
diff --git a/libutil/op_get_time.c b/libutil/op_get_time.c
new file mode 100644
index 0000000..c094c63
--- /dev/null
+++ b/libutil/op_get_time.c
@@ -0,0 +1,24 @@
+/**
+ * @file op_get_time.c
+ * Get current time as a string
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "op_get_time.h"
+
+#include <time.h>
+
+char * op_get_time(void)
+{
+	time_t t = time(NULL);
+
+	if (t == -1)
+		return "";
+
+	return ctime(&t);
+}
diff --git a/libutil/op_get_time.h b/libutil/op_get_time.h
new file mode 100644
index 0000000..8f96273
--- /dev/null
+++ b/libutil/op_get_time.h
@@ -0,0 +1,33 @@
+/**
+ * @file op_get_time.h
+ * Get current time as a string
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_GET_TIME_H
+#define OP_GET_TIME_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * op_get_time - get current date and time
+ *
+ * Returns a string representing the current date
+ * and time, or an empty string on error.
+ *
+ * The string is statically allocated and should not be freed.
+ */
+char * op_get_time(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_GET_TIME_H */
diff --git a/libutil/op_growable_buffer.c b/libutil/op_growable_buffer.c
new file mode 100644
index 0000000..d138f36
--- /dev/null
+++ b/libutil/op_growable_buffer.c
@@ -0,0 +1,46 @@
+/**
+ * @file op_growable_buffer.c
+ * a growable buffer implementation
+ *
+ * @remark Copyright 2007 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#include "op_growable_buffer.h"
+#include "op_libiberty.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+void init_buffer(struct growable_buffer * b)
+{
+	b->max_size = 0;
+	b->size = 0;
+	b->p = NULL;
+}
+
+
+void free_buffer(struct growable_buffer * b)
+{
+	free(b->p);
+}
+
+
+static void grow_buffer(struct growable_buffer * b)
+{
+	size_t new_size = (b->max_size + b->size) * 2;
+	b->p = xrealloc(b->p, new_size);
+	b->max_size = new_size;
+}
+
+
+void add_data(struct growable_buffer * b, void const * data, size_t len)
+{
+	size_t old_size = b->size;
+	b->size += len;
+	if (b->size > b->max_size)
+		grow_buffer(b);
+	memcpy(b->p + old_size, data, len);
+}
diff --git a/libutil/op_growable_buffer.h b/libutil/op_growable_buffer.h
new file mode 100644
index 0000000..491969a
--- /dev/null
+++ b/libutil/op_growable_buffer.h
@@ -0,0 +1,45 @@
+/**
+ * @file op_growable_buffer.h
+ * a growable buffer interface
+ *
+ * @remark Copyright 2007 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Philippe Elie
+ */
+
+#ifndef OP_GROWABLE_BUFFER_H
+#define OP_GROWABLE_BUFFER_H
+
+#include <stddef.h>
+
+struct growable_buffer {
+	void * p;
+	size_t size;
+	size_t max_size;
+};
+
+/**
+ * init_buffer - initialize an empty buffer
+ * @param buffer the buffer to initialize
+ *
+ * init_buffer do not do any allocation, the first allocation will occur
+ * when add_data() with a non zero len param will be called.
+ */
+void init_buffer(struct growable_buffer * buffer);
+
+/**
+ * free_buffer - free the memory allocated for this buffer
+ * @param buffer the buffer to free
+ */
+void free_buffer(struct growable_buffer * buffer);
+
+/**
+ * add_data - add data to this buffer
+ * @param b the buffer where to add data
+ * @param data a pointer to the data to add
+ * @param len number of byte to add to the buffer
+ */
+void add_data(struct growable_buffer * b, void const * data, size_t len);
+
+#endif /* !OP_GROWABLE_BUFFER_H */
diff --git a/libutil/op_libiberty.c b/libutil/op_libiberty.c
new file mode 100644
index 0000000..0cf45d3
--- /dev/null
+++ b/libutil/op_libiberty.c
@@ -0,0 +1,38 @@
+/**
+ * @file op_libiberty.c
+ * Wrapper for libiberty - always use this instead of
+ * libiberty.h
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <string.h>
+
+#include "op_libiberty.h"
+
+#ifndef HAVE_XCALLOC
+/* some system have a valid libiberty without xcalloc */
+void * xcalloc(size_t n_elem, size_t sz)
+{
+	void * ptr = xmalloc(n_elem * sz);
+
+	memset(ptr, '\0', n_elem * sz);
+
+	return ptr;
+}
+#endif
+
+#ifndef HAVE_XMEMDUP
+void * xmemdup (void const * input, size_t copy_size, size_t alloc_size)
+{
+	void * output = xcalloc(1, alloc_size);
+
+	memcpy(output, input, copy_size);
+
+	return output;
+}
+#endif
diff --git a/libutil/op_libiberty.h b/libutil/op_libiberty.h
new file mode 100644
index 0000000..ea02a50
--- /dev/null
+++ b/libutil/op_libiberty.h
@@ -0,0 +1,81 @@
+/**
+ * @file op_libiberty.h
+ * Wrapper for libiberty - always use this instead of
+ * libiberty.h
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_LIBIBERTY_H
+#define OP_LIBIBERTY_H
+
+#include <stddef.h>
+
+#include "config.h"
+
+#ifdef MALLOC_ATTRIBUTE_OK
+#define OP_ATTRIB_MALLOC	__attribute__((malloc))
+#else
+#define OP_ATTRIB_MALLOC
+#endif
+
+#ifdef HAVE_LIBIBERTY_H
+#include <libiberty.h>
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* some system have a libiberty.a but no libiberty.h so we must provide
+ * ourself the missing proto */
+#ifndef HAVE_LIBIBERTY_H
+
+/* Set the program name used by xmalloc.  */
+void xmalloc_set_program_name(char const *);
+
+/* Allocate memory without fail.  If malloc fails, this will print a
+   message to stderr (using the name set by xmalloc_set_program_name,
+   if any) and then call xexit.  */
+void * xmalloc(size_t) OP_ATTRIB_MALLOC;
+
+/* Reallocate memory without fail.  This works like xmalloc.  Note,
+   realloc type functions are not suitable for attribute malloc since
+   they may return the same address across multiple calls. */
+void * xrealloc(void *, size_t);
+
+/* Allocate memory without fail and set it to zero.  This works like xmalloc */
+void * xcalloc(size_t, size_t) OP_ATTRIB_MALLOC;
+
+/* Copy a string into a memory buffer without fail.  */
+char * xstrdup(char const *) OP_ATTRIB_MALLOC;
+
+/**
+ * Duplicates a region of memory without fail.  First, alloc_size bytes
+ * are allocated, then copy_size bytes from input are copied into
+ * it, and the new memory is returned.  If fewer bytes are copied than were
+ * allocated, the remaining memory is zeroed.
+ */
+void * xmemdup(void const *, size_t, size_t) OP_ATTRIB_MALLOC;
+
+#endif	/* !HAVE_LIBIBERTY_H */
+
+#ifdef ANDROID
+#define xmalloc(s)      malloc(s)
+#define xrealloc(p,s)   realloc(p,s)
+#define xstrdup(str)    strdup(str)
+#define xmalloc_set_program_name(n)
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !HAVE_LIBIBERTY_H */
+
+#endif /* OP_LIBIBERTY_H */
diff --git a/libutil/op_list.h b/libutil/op_list.h
new file mode 100644
index 0000000..ed0cd8a
--- /dev/null
+++ b/libutil/op_list.h
@@ -0,0 +1,177 @@
+/**
+ * @file op_list.h
+ * Kernel-style lists
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author Linux kernel authors
+ */
+
+#ifndef OP_LIST_H
+#define OP_LIST_H
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+struct list_head {
+	struct list_head * next, * prev;
+};
+
+/**
+ * list_init - init a new entry
+ * @param ptr  the list to init
+ *
+ * Init a list head to create an empty list from it
+ */
+static __inline__ void list_init(struct list_head * ptr)
+{
+	ptr->next = ptr;
+	ptr->prev = ptr;
+}
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static __inline__ void __list_add(struct list_head * new_entry,
+	struct list_head * prev,
+	struct list_head * next)
+{
+	next->prev = new_entry;
+	new_entry->next = next;
+	new_entry->prev = prev;
+	prev->next = new_entry;
+}
+
+/**
+ * list_add - add a new entry
+ * @param new  new entry to be added
+ * @param head  list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static __inline__ void list_add(struct list_head * new_entry, struct list_head * head)
+{
+	__list_add(new_entry, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @param new  new entry to be added
+ * @param head  list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static __inline__ void list_add_tail(struct list_head * new_entry, struct list_head * head)
+{
+	__list_add(new_entry, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static __inline__ void __list_del(struct list_head * prev,
+				  struct list_head * next)
+{
+	next->prev = prev;
+	prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @param entry  the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
+ */
+static __inline__ void list_del(struct list_head * entry)
+{
+	__list_del(entry->prev, entry->next);
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @param entry  the element to delete from the list.
+ */
+static __inline__ void list_del_init(struct list_head * entry)
+{
+	__list_del(entry->prev, entry->next);
+	list_init(entry);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @param head  the list to test.
+ */
+static __inline__ int list_empty(struct list_head const * head)
+{
+	return head->next == head;
+}
+
+/**
+ * list_splice - join two lists
+ * @param list  the new list to add.
+ * @param head  the place to add it in the first list.
+ */
+static __inline__ void list_splice(struct list_head * list, struct list_head * head)
+{
+	struct list_head * first = list->next;
+
+	if (first != list) {
+		struct list_head * last = list->prev;
+		struct list_head * at = head->next;
+
+		first->prev = head;
+		head->next = first;
+
+		last->next = at;
+		at->prev = last;
+	}
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @param ptr 	the &struct list_head pointer.
+ * @param type 	the type of the struct this is embedded in.
+ * @param member 	the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+	((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
+
+/**
+ * list_for_each - iterate over a list
+ * @param pos 	the &struct list_head to use as a loop counter.
+ * @param head 	the head for your list.
+ */
+#define list_for_each(pos, head) \
+	for (pos = (head)->next; pos != (head); pos = pos->next)
+
+/**
+ * list_for_each_safe - iterate over a list safe against removal of list entry
+ * @param pos 	the &struct list_head to use as a loop counter.
+ * @param n 		another &struct list_head to use as temporary storage
+ * @param head 	the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+	for (pos = (head)->next, n = pos->next; pos != (head); \
+		pos = n, n = pos->next)
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)
+
+#endif /* OP_LIST_H */
diff --git a/libutil/op_lockfile.c b/libutil/op_lockfile.c
new file mode 100644
index 0000000..26e3249
--- /dev/null
+++ b/libutil/op_lockfile.c
@@ -0,0 +1,69 @@
+/**
+ * @file op_lockfile.c
+ * PID-based lockfile management
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include "op_lockfile.h"
+#include "op_file.h"
+
+#include <errno.h>
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+
+static pid_t op_read_lock_file(char const * file)
+{
+	FILE * fp;
+	pid_t value;
+
+	fp = fopen(file, "r");
+	if (fp == NULL)
+		return 0;
+
+	if (fscanf(fp, "%d", &value) != 1) {
+		fclose(fp);
+		return 0;
+	}
+
+	fclose(fp);
+
+	return value;
+}
+
+
+int op_write_lock_file(char const * file)
+{
+	FILE * fp;
+
+	if (op_file_readable(file)) {
+		pid_t pid = op_read_lock_file(file);
+
+		/* FIXME: ESRCH vs. EPERM */
+		if (kill(pid, 0)) {
+			int err = unlink(file);
+			fprintf(stderr, "Removing stale lock file %s\n",
+				file);
+			if (err)
+				return err;
+		} else {
+			return EEXIST;
+		}
+	}
+
+	fp = fopen(file, "w");
+	if (!fp)
+		return errno;
+
+	fprintf(fp, "%d", getpid());
+	fclose(fp);
+
+	return 0;
+}
diff --git a/libutil/op_lockfile.h b/libutil/op_lockfile.h
new file mode 100644
index 0000000..fcc269c
--- /dev/null
+++ b/libutil/op_lockfile.h
@@ -0,0 +1,34 @@
+/**
+ * @file op_lockfile.h
+ * PID-based lockfile management
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_LOCKFILE_H
+#define OP_LOCKFILE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+
+/**
+ * op_write_lock_file - write a lock file
+ * \return errno on failure, or 0 on success
+ *
+ * Write the pid into the given lock file. Stale
+ * lock files are detected and reset.
+ */
+int op_write_lock_file(char const * file);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_LOCKFILE_H */
diff --git a/libutil/op_popt.c b/libutil/op_popt.c
new file mode 100644
index 0000000..de96364
--- /dev/null
+++ b/libutil/op_popt.c
@@ -0,0 +1,43 @@
+/**
+ * @file op_popt.c
+ * Wrapper for libpopt - always use this rather
+ * than popt.h
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <stdlib.h>
+#include "op_libiberty.h"
+#include "op_popt.h"
+
+poptContext op_poptGetContext(char const * name,
+		int argc, char const ** argv,
+		struct poptOption const * options, int flags)
+{
+	poptContext optcon;
+	int c;
+
+	xmalloc_set_program_name(argv[0]);
+
+#ifdef CONST_POPT
+	optcon = poptGetContext(name, argc, argv, options, flags);
+#else
+	optcon = poptGetContext((char *)name, argc, (char **)argv, options, flags);
+#endif
+
+	c = poptGetNextOpt(optcon);
+
+	if (c < -1) {
+		fprintf(stderr, "%s: %s: %s\n", argv[0],
+			poptBadOption(optcon, POPT_BADOPTION_NOALIAS),
+			poptStrerror(c));
+		poptPrintHelp(optcon, stderr, 0);
+		exit(EXIT_FAILURE);
+	}
+
+	return optcon;
+}
diff --git a/libutil/op_popt.h b/libutil/op_popt.h
new file mode 100644
index 0000000..c3dfa6c
--- /dev/null
+++ b/libutil/op_popt.h
@@ -0,0 +1,42 @@
+/**
+ * @file op_popt.h
+ * Wrapper for libpopt - always use this rather
+ * than popt.h
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_POPT_H
+#define OP_POPT_H
+
+#include <popt.h>
+
+// not in some versions of popt.h
+#ifndef POPT_TABLEEND
+#define POPT_TABLEEND { NULL, '\0', 0, 0, 0, NULL, NULL }
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * op_poptGetContext - wrapper for popt
+ *
+ * Use this instead of poptGetContext to cope with
+ * different popt versions. This also handle unrecognized
+ * options. All error are fatal.
+ */
+poptContext op_poptGetContext(char const * name,
+                int argc, char const ** argv,
+                struct poptOption const * options, int flags);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OP_POPT_H */
diff --git a/libutil/op_string.c b/libutil/op_string.c
new file mode 100644
index 0000000..d440299
--- /dev/null
+++ b/libutil/op_string.c
@@ -0,0 +1,62 @@
+/**
+ * @file op_string.c
+ * general purpose C string handling implementation.
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <string.h>
+#include "op_libiberty.h"
+
+
+char * op_xstrndup(char const * s, size_t len)
+{
+	return xmemdup(s, len, len + 1);
+}
+
+
+size_t op_hash_string(char const * str)
+{
+	size_t hash = 0;
+	for (; *str; ++str)
+		hash ^= (hash << 16) ^ (hash >> 8) ^ *str;
+	return hash;
+}
+
+
+int strisprefix(char const * str, char const * prefix)
+{
+	return strstr(str, prefix) == str;
+}
+
+
+char const * skip_ws(char const * c)
+{
+	while (*c == ' ' || *c == '\t' || *c == '\n')
+		++c;
+	return c;
+}
+
+
+char const * skip_nonws(char const * c)
+{
+	while (*c && *c != ' ' && *c != '\t' && *c != '\n')
+		++c;
+	return c;
+}
+
+
+int empty_line(char const * c)
+{
+	return !*skip_ws(c);
+}
+
+
+int comment_line(char const * c)
+{
+	return *skip_ws(c) == '#';
+}
diff --git a/libutil/op_string.h b/libutil/op_string.h
new file mode 100644
index 0000000..993fa6f
--- /dev/null
+++ b/libutil/op_string.h
@@ -0,0 +1,81 @@
+/**
+ * @file op_string.h
+ * general purpose C string handling declarations.
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_STRING_H
+#define OP_STRING_H
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @param  s: input string
+ * @param len: len char to copy
+ *
+ * Allocate and copy len character from s to a newly allocated buffer then
+ * append a '\0' terminator. Return the newly allocated string
+ */
+char * op_xstrndup(char const * s, size_t len);
+
+/**
+ * @param  s: string to hash
+ *
+ * Generate a hash code from a string
+ */
+size_t op_hash_string(char const * s);
+
+/**
+ * @param str: string to test
+ * @param prefix: prefix string
+ *
+ * return non zero if prefix parameters is a prefix of str
+ */
+int strisprefix(char const * str, char const * prefix);
+
+/**
+ * @param c: input string
+ *
+ * return a pointer to the first location in c which is not a blank space
+ * where blank space are in " \t\n"
+ */
+char const * skip_ws(char const * c);
+
+/**
+ * @param c: input string
+ *
+ * return a pointer to the first location in c which is a blank space
+ * where blank space are in " \t\n"
+ */
+char const * skip_nonws(char const * c);
+
+/**
+ * @param c: input string
+ *
+ * return non zero if c string contains only blank space
+ * where blank space are in " \t\n"
+ */
+int empty_line(char const * c);
+
+/**
+ * @param c: input string
+ *
+ * return non zero if c string is a comment. Comment are lines with optional
+ * blank space at left then a '#' character. Blank space are in " \t\n"
+ */
+int comment_line(char const * c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !OP_STRING_H */
diff --git a/libutil/op_types.h b/libutil/op_types.h
new file mode 100644
index 0000000..c025b23
--- /dev/null
+++ b/libutil/op_types.h
@@ -0,0 +1,37 @@
+/**
+ * @file op_types.h
+ * General-utility types
+ *
+ * @remark Copyright 2002 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_TYPES_H
+#define OP_TYPES_H
+
+#ifndef __KERNEL__
+
+#include <sys/types.h>
+
+/*@{\name miscellaneous types */
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long long u64;
+typedef int fd_t;
+/*@}*/
+
+/** generic type for holding addresses */
+typedef unsigned long long vma_t;
+
+/** generic type to hold a sample count in pp tools */
+typedef u64 count_type;
+
+#else
+#include <linux/types.h>
+#endif
+
+#endif /* OP_TYPES_H */
diff --git a/libutil/op_version.c b/libutil/op_version.c
new file mode 100644
index 0000000..99a844e
--- /dev/null
+++ b/libutil/op_version.c
@@ -0,0 +1,24 @@
+/**
+ * @file op_version.c
+ * output version string
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "op_version.h"
+#include "config.h"
+
+void show_version(char const * app_name)
+{
+	/* Do not change the version format: it is documented in html doc */
+	printf("%s: " PACKAGE " " VERSION " compiled on "
+	       __DATE__ " " __TIME__ "\n", app_name);
+	exit(EXIT_SUCCESS);
+}
diff --git a/libutil/op_version.h b/libutil/op_version.h
new file mode 100644
index 0000000..43a8365
--- /dev/null
+++ b/libutil/op_version.h
@@ -0,0 +1,26 @@
+/**
+ * @file op_version.h
+ * output version string
+ *
+ * @remark Copyright 2003 OProfile authors
+ * @remark Read the file COPYING
+ *
+ * @author John Levon
+ * @author Philippe Elie
+ */
+
+#ifndef OP_VERSION_H
+#define OP_VERSION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** output the version string */
+void show_version(char const * app_name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !OP_VERSION_H */
diff --git a/opcontrol/Android.mk b/opcontrol/Android.mk
new file mode 100644
index 0000000..56211ad
--- /dev/null
+++ b/opcontrol/Android.mk
@@ -0,0 +1,18 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+	opcontrol.cpp
+
+LOCAL_STATIC_LIBRARIES := \
+	libpopt libutil libdb libabi libop
+
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/.. \
+	$(LOCAL_PATH)/../libop
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE:= opcontrol
+
+include $(BUILD_EXECUTABLE)
diff --git a/opcontrol/opcontrol.cpp b/opcontrol/opcontrol.cpp
new file mode 100644
index 0000000..2d9cb2f
--- /dev/null
+++ b/opcontrol/opcontrol.cpp
@@ -0,0 +1,542 @@
+/*
+ * Copyright 2008, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Binary implementation of the original opcontrol script due to missing tools
+ * like awk, test, etc.
+ */
+
+#include <unistd.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/stat.h>
+
+#include "op_config.h"
+
+#if 0
+#define verbose(fmt...) printf(fmt)
+#else
+#define verbose(fmt...)
+#endif
+
+/* Experiments found that using a small interval may hang the device, and the
+ * more events tracked simultaneously, the longer the interval has to be.
+ */
+int min_count[3] = {150000, 200000, 250000};
+int list_events; 
+int show_usage;
+int setup;
+int quick;
+int num_events;
+int start;
+int stop;
+int reset;
+
+int selected_events[3];
+int selected_counts[3];
+
+char kernel_range[512];
+char vmlinux[512];
+
+struct option long_options[] = {
+    {"help", 0, &show_usage, 1},
+    {"list-events", 0, &list_events, 1},
+    {"reset", 0, &reset, 1},
+    {"setup", 0, &setup, 1},
+    {"quick", 0, &quick, 1},
+    {"event", 1, 0, 'e'},
+    {"vmlinux", 1, 0, 'v'},
+    {"kernel-range", 1, 0, 'r'},
+    {"start", 0, &start, 1},
+    {"stop", 0, &stop, 1},
+    {"shutdown", 0, 0, 'h'},
+    {"status", 0, 0, 't'},
+    {0, 0, 0, 0},
+};
+
+struct event_info {
+    int id;
+    const char *name;
+    const char *explanation;
+} event_info[] = {
+    {0x00, "IFU_IFETCH_MISS", 
+     "number of instruction fetch misses"},
+    {0x01, "CYCLES_IFU_MEM_STALL", 
+     "cycles instruction fetch pipe is stalled"},
+    {0x02, "CYCLES_DATA_STALL", 
+     "cycles stall occurs for due to data dependency"},
+    {0x03, "ITLB_MISS", 
+     "number of Instruction MicroTLB misses"},
+    {0x04, "DTLB_MISS", 
+     "number of Data MicroTLB misses"},
+    {0x05, "BR_INST_EXECUTED", 
+     "branch instruction executed w/ or w/o program flow change"},
+    {0x06, "BR_INST_MISS_PRED", 
+     "branch mispredicted"},
+    {0x07, "INSN_EXECUTED", 
+     "instructions executed"},
+    {0x09, "DCACHE_ACCESS", 
+     "data cache access, cacheable locations"},
+    {0x0a, "DCACHE_ACCESS_ALL", 
+     "data cache access, all locations"},
+    {0x0b, "DCACHE_MISS", 
+     "data cache miss"},
+    {0x0c, "DCACHE_WB", 
+     "data cache writeback, 1 event for every half cacheline"},
+    {0x0d, "PC_CHANGE", 
+     "number of times the program counter was changed without a mode switch"},
+    {0x0f, "TLB_MISS", 
+     "Main TLB miss"},
+    {0x10, "EXP_EXTERNAL", 
+     "Explicit external data access"},
+    {0x11, "LSU_STALL", 
+     "cycles stalled because Load Store request queue is full"},
+    {0x12, "WRITE_DRAIN", 
+     "Times write buffer was drained"},
+    {0xff, "CPU_CYCLES", 
+     "clock cycles counter"}, 
+};
+
+void usage() {
+    printf("\nopcontrol: usage:\n"
+           "   --list-events    list event types\n"
+           "   --help           this message\n"
+           "   --setup          setup directories\n"
+           "   --quick          setup and select CPU_CYCLES:150000\n"
+           "   --status         show configuration\n"
+           "   --start          start data collection\n"
+           "   --stop           stop data collection\n"
+           "   --reset          clears out data from current session\n"
+           "   --shutdown       kill the oprofile daeman\n"
+           "   --event=eventspec\n"
+           "      Choose an event. May be specified multiple times.\n"
+           "      eventspec is in the form of name[:count], where :\n"
+           "        name:  event name, see \"opcontrol --list-events\"\n"
+           "        count: reset counter value\n" 
+           "   --vmlinux=file   vmlinux kernel image\n"
+           "   --kernel-range=start,end\n"
+           "                    kernel range vma address in hexadecimal\n"
+          );
+}
+
+void setup_session_dir() {
+    int fd;
+
+    fd = open(OP_DATA_DIR, O_RDONLY);
+    if (fd != -1) {
+        system("rm -r "OP_DATA_DIR);
+        close(fd);
+    }
+
+    if (mkdir(OP_DATA_DIR, 755)) {
+        fprintf(stderr, "Cannot create directory \"%s\": %s\n",
+                OP_DATA_DIR, strerror(errno));
+    }
+    if (mkdir(OP_DATA_DIR"/samples", 644)) {
+        fprintf(stderr, "Cannot create directory \"%s\": %s\n",
+                OP_DATA_DIR"/samples", strerror(errno));
+    }
+}
+
+int do_setup() {
+    char dir[1024];
+
+    setup_session_dir();
+
+    if (mkdir(OP_DRIVER_BASE, 644)) {
+        fprintf(stderr, "Cannot create directory "OP_DRIVER_BASE": %s\n",
+                strerror(errno));
+        return -1;
+    }
+    if (system("mount -t oprofilefs nodev "OP_DRIVER_BASE)) {
+        return -1;
+    }
+    return 0;
+}
+
+void do_list_events()
+{
+    unsigned int i;
+
+    printf("%-20s: %s\n", "name", "meaning");
+    printf("----------------------------------------"
+           "--------------------------------------\n");
+    for (i = 0; i < sizeof(event_info)/sizeof(struct event_info); i++) {
+        printf("%-20s: %s\n", event_info[i].name, event_info[i].explanation);
+    }
+}
+
+int find_event_id_from_name(const char *name) {
+    unsigned int i;
+
+    for (i = 0; i < sizeof(event_info)/sizeof(struct event_info); i++) {
+        if (!strcmp(name, event_info[i].name)) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+const char * find_event_name_from_id(int id) {
+    unsigned int i;
+
+    for (i = 0; i < sizeof(event_info)/sizeof(struct event_info); i++) {
+        if (event_info[i].id == id) {
+            return event_info[i].name;
+        }
+    }
+    return NULL;
+}
+
+int process_event(const char *event_spec) {
+    char event_name[512];
+    char count_name[512];
+    unsigned int i;
+    int event_id;
+    int count_val;
+
+    strncpy(event_name, event_spec, 512);
+    count_name[0] = 0;
+
+    /* First, check if the name is followed by ":" */
+    for (i = 0; i < strlen(event_name); i++) {
+        if (event_name[i] == 0) {
+            break;
+        }
+        if (event_name[i] == ':') {
+            strncpy(count_name, event_name+i+1, 512);
+            event_name[i] = 0;
+            break;
+        }
+    }
+    event_id = find_event_id_from_name(event_name);
+    if (event_id == -1) {
+        fprintf(stderr, "Unknown event name: %s\n", event_name);
+        return -1;
+    }
+
+    /* Use defualt count */
+    if (count_name[0] == 0) {
+        count_val = min_count[0];
+    } else {
+        count_val = atoi(count_name);
+    }
+
+    selected_events[num_events] = event_id;
+    selected_counts[num_events++] = count_val;
+    verbose("event_id is %d\n", event_id);
+    verbose("count_val is %d\n", count_val);
+    return 0;
+}
+
+int echo_dev(const char* str, int val, const char* file, int counter)
+{
+    char fullname[512];
+    char content[128];
+    int fd;
+    
+    if (counter >= 0) {
+        snprintf(fullname, 512, OP_DRIVER_BASE"/%d/%s", counter, file);
+    }
+    else {
+        snprintf(fullname, 512, OP_DRIVER_BASE"/%s", file);
+    }
+    fd = open(fullname, O_WRONLY);
+    if (fd<0) {
+        fprintf(stderr, "Cannot open %s: %s\n", fullname, strerror(errno));
+        return fd;
+    }
+    if (str == 0) {
+        sprintf(content, "%d", val);
+    }
+    else {
+        strncpy(content, str, 128);
+    }
+    verbose("Configure %s (%s)\n", fullname, content);
+    write(fd, content, strlen(content));
+    close(fd);
+    return 0;
+}
+
+int read_num(const char* file)
+{
+    char buffer[256];
+    int fd = open(file, O_RDONLY);
+    if (fd<0) return -1;
+    int rd = read(fd, buffer, sizeof(buffer)-1);
+    buffer[rd] = 0;
+    return atoi(buffer);
+}
+
+void do_status()
+{
+    int num;
+    char fullname[512];
+    int i;
+
+    printf("Driver directory: %s\n", OP_DRIVER_BASE);
+    printf("Session directory: %s\n", OP_DATA_DIR);
+    for (i = 0; i < 3; i++) {
+        sprintf(fullname, OP_DRIVER_BASE"/%d/enabled", i);
+        num = read_num(fullname);
+        if (num > 0) {
+            printf("Counter %d:\n", i);
+
+            /* event name */
+            sprintf(fullname, OP_DRIVER_BASE"/%d/event", i);
+            num = read_num(fullname);
+            printf("    name: %s\n", find_event_name_from_id(num));
+
+            /* profile interval */
+            sprintf(fullname, OP_DRIVER_BASE"/%d/count", i);
+            num = read_num(fullname);
+            printf("    count: %d\n", num);
+        }
+        else {
+            printf("Counter %d disabled\n", i);
+        }
+    }
+
+    num = read_num(OP_DATA_DIR"/lock");
+    if (num >= 0) {
+        int fd;
+        /* Still needs to check if this lock is left-over */
+        sprintf(fullname, "/proc/%d", num);
+        fd = open(fullname, O_RDONLY);
+        if (fd == -1) {
+            printf("Session directory is not clean - do \"opcontrol --setup\""
+                   " before you continue\n");
+            return;
+        }
+        else {
+            close(fd);
+            printf("oprofiled pid: %d\n", num);
+            num = read_num(OP_DRIVER_BASE"/enable");
+            printf("profiler is%s running\n", num == 0 ? " not" : "");
+            num = read_num(OP_DRIVER_BASE"/stats/cpu0/sample_received");
+            printf("  %9u samples received\n", num);
+            num = read_num(OP_DRIVER_BASE"/stats/cpu0/sample_lost_overflow");
+            printf("  %9u samples lost overflow\n", num);
+#if 0
+            /* FIXME - backtrace seems broken */
+            num = read_num(OP_DRIVER_BASE"/stats/cpu0/backtrace_aborted");
+            printf("  %9u backtrace aborted\n", num);
+            num = read_num(OP_DRIVER_BASE"/backtrace_depth");
+            printf("  %9u backtrace_depth\n", num);
+#endif
+        }
+    }
+    else {
+        printf("oprofiled is not running\n");
+    }
+}
+
+void do_reset() 
+{
+    int fd;
+
+    fd = open(OP_DATA_DIR"/samples/current", O_RDONLY);
+    if (fd == -1) {
+        return;
+    }
+    close(fd);
+    system("rm -r "OP_DATA_DIR"/samples/current");
+}
+
+int main(int argc, char * const argv[])
+{
+    int option_index;
+    char command[1024];
+
+    /* Initialize default strings */
+    strcpy(vmlinux, "--no-vmlinux");
+    strcpy(kernel_range, "");
+
+    while (1) {
+        int c = getopt_long(argc, argv, "", long_options, &option_index);
+        if (c == -1) {
+            break;
+        }
+        switch (c) {
+            case 0:
+                break;
+            /* --event */
+            case 'e':   
+                if (num_events == 3) {
+                    fprintf(stderr, "More than 3 events specified\n");
+                    exit(1);
+                }
+                if (process_event(optarg)) {
+                    exit(1);
+                }
+                break;
+            /* --vmlinux */
+            case 'v':
+                sprintf(vmlinux, "-k %s", optarg);
+                break;
+            /* --kernel-range */
+            case 'r':
+                sprintf(kernel_range, "-r %s", optarg);
+                break;
+            /* --shutdown */
+            case 'h': {
+                int pid = read_num(OP_DATA_DIR"/lock");
+                if (pid >= 0) {
+                    kill(pid, SIGKILL);
+                }   
+                setup_session_dir();
+                break;
+            }
+            /* --status */
+            case 't':
+                do_status();
+                break;
+            default:
+                usage();
+                exit(1);
+        }
+    }
+    verbose("list_events = %d\n", list_events);
+    verbose("setup = %d\n", setup);
+
+    if (list_events) {
+        do_list_events();
+    }
+
+    if (quick) {
+        process_event("CPU_CYCLES");
+        setup = 1;
+    }
+
+    if (reset) {
+        do_reset();
+    }
+
+    if (show_usage) {
+        usage();
+    }
+
+    if (setup) {
+        if (do_setup()) {
+            fprintf(stderr, "do_setup failed");
+            exit(1);
+        }
+    }
+
+    if (num_events != 0) {
+        int i;
+
+        strcpy(command, "oprofiled --session-dir="OP_DATA_DIR);
+
+        /* Since counter #3 can only handle CPU_CYCLES, check and shuffle the 
+         * order a bit so that the maximal number of events can be profiled
+         * simultaneously
+         */
+        if (num_events == 3) {
+            for (i = 0; i < num_events; i++) {
+                int event_idx = selected_events[i];
+
+                if (event_info[event_idx].id == 0xff) {
+                    break;
+                }
+            }
+
+            /* No CPU_CYCLES is found */
+            if (i == 3) {
+                fprintf(stderr, "You can only specify three events if one of "
+                                "them is CPU_CYCLES\n");
+                exit(1);
+            }
+            /* Swap CPU_CYCLES to counter #2 (starting from #0)*/
+            else if (i != 2) {
+                int temp;
+
+                temp = selected_events[2];
+                selected_events[2] = selected_events[i];
+                selected_events[i] = temp;
+
+                temp = selected_counts[2];
+                selected_counts[2] = selected_counts[i];
+                selected_counts[i] = temp;
+            }
+        }
+
+
+        /* Configure the counters and enable them */
+        for (i = 0; i < num_events; i++) {
+            int event_idx = selected_events[i];
+            int setup_result = 0;
+
+            if (i == 0) {
+                snprintf(command+strlen(command), 1024 - strlen(command), 
+                         " --events=");
+            }
+            else {
+                snprintf(command+strlen(command), 1024 - strlen(command), 
+                         ",");
+            }
+            /* Compose name:id:count:unit_mask:kernel:user, something like
+             * --events=CYCLES_DATA_STALL:2:0:200000:0:1:1,....
+             */
+            snprintf(command+strlen(command), 1024 - strlen(command), 
+                     "%s:%d:%d:%d:0:1:1",
+                     event_info[event_idx].name,
+                     event_info[event_idx].id,
+                     i,
+                     selected_counts[i]);
+
+            setup_result |= echo_dev("1", 0, "user", i);
+            setup_result |= echo_dev("1", 0, "kernel", i);
+            setup_result |= echo_dev("0", 0, "unit_mask", i);
+            setup_result |= echo_dev("1", 0, "enabled", i);
+            setup_result |= echo_dev(NULL, selected_counts[i], "count", i);
+            setup_result |= echo_dev(NULL, event_info[event_idx].id, 
+                                     "event", i);
+            if (setup_result) {
+                fprintf(stderr, "Counter configuration failed for %s\n",
+                        event_info[event_idx].name);
+                fprintf(stderr, "Did you do \"opcontrol --setup\" first?\n");
+                exit(1);
+            }
+        }
+
+        /* Disable the unused counters */
+        for (i = num_events; i < 3; i++) {
+            echo_dev("0", 0, "enabled", i);
+        }
+
+        snprintf(command+strlen(command), 1024 - strlen(command), " %s",
+                 vmlinux);
+        if (kernel_range[0]) {
+            snprintf(command+strlen(command), 1024 - strlen(command), " %s",
+                     kernel_range);
+        }
+        verbose("command: %s\n", command);
+        system(command);
+    }
+
+    if (start) {
+        echo_dev("1", 0, "enable", -1);
+    }
+
+    if (stop) {
+        echo_dev("0", 0, "enable", -1);
+    }
+}
diff --git a/opimport_pull b/opimport_pull
new file mode 100755
index 0000000..7dbac4a
--- /dev/null
+++ b/opimport_pull
@@ -0,0 +1,70 @@
+#!/usr/bin/python2.4 -E
+
+import os
+import re
+import sys
+
+def PrintUsage():
+    print "Usage:" + sys.argv[0] + " dir"
+    print "    dir: directory on the host to store profile results"
+
+if (len(sys.argv) != 2):
+    PrintUsage()
+    sys.exit(1)
+
+try:
+    oprofile_event_dir = os.environ['OPROFILE_EVENTS_DIR']
+except:
+    print "OPROFILE_EVENTS_DIR not set. Run \". envsetup.sh\" first"
+    sys.exit(1)
+
+output_dir = sys.argv[1];
+
+try:
+    os.makedirs(output_dir)
+except:
+    if os.path.exists(output_dir):
+        print "Directory already exists:", output_dir
+    else:
+        print "Cannot create", output_dir
+    sys.exit(1)
+
+# get the samples off the phone
+result = os.system("adb pull /data/oprofile/samples " + output_dir + \
+                   "/raw_samples > /dev/null 2>&1")
+if result != 0:
+    print "adb pull failure, exiting"
+    sys.exit(1)
+
+# enter the destination directory
+os.chdir(output_dir)
+stream = os.popen("find raw_samples -type f -name \*all")
+
+# now all the sample files are on the host, we need to invoke opimport one at a
+# time to convert the content from the ARM abi to x86 ABI
+
+# break the full filename into:
+# 1: leading dir: "raw_samples"
+# 2: intermediate dirs: "/blah/blah/blah"
+# 3: filename: e.g. "CPU_CYCLES.150000.0.all.all.all"
+pattern = re.compile("(^raw_samples)(.*)/(.*)$")
+for line in stream:
+    match = pattern.search(line)
+    leading_dir = match.group(1)
+    middle_part = match.group(2)
+    file_name = match.group(3)
+
+    dir = "samples" + middle_part
+
+    # if multiple events are collected the directory could have been setup
+    if not os.path.exists(dir):
+        os.makedirs(dir)
+
+    cmd = oprofile_event_dir + "/bin/opimport -a " + oprofile_event_dir + \
+          "/abi/arm_abi -o samples" + middle_part + "/" + file_name + " " + line
+    os.system(cmd)
+
+stream.close()
+
+# short summary of profiling results
+os.system(oprofile_event_dir + "/bin/opreport --session-dir=.")
diff --git a/popt.h b/popt.h
new file mode 100644
index 0000000..4f85d9e
--- /dev/null
+++ b/popt.h
@@ -0,0 +1,564 @@
+/** \file popt/popt.h
+ * \ingroup popt
+ */
+
+/* (C) 1998-2000 Red Hat, Inc. -- Licensing details are in the COPYING
+   file accompanying popt source distributions, available from 
+   ftp://ftp.rpm.org/pub/rpm/dist. */
+
+#ifndef H_POPT
+#define H_POPT
+
+#include <stdio.h>			/* for FILE * */
+
+#define POPT_OPTION_DEPTH	10
+
+/** \ingroup popt
+ * \name Arg type identifiers
+ */
+/*@{*/
+#define POPT_ARG_NONE		0	/*!< no arg */
+#define POPT_ARG_STRING		1	/*!< arg will be saved as string */
+#define POPT_ARG_INT		2	/*!< arg will be converted to int */
+#define POPT_ARG_LONG		3	/*!< arg will be converted to long */
+#define POPT_ARG_INCLUDE_TABLE	4	/*!< arg points to table */
+#define POPT_ARG_CALLBACK	5	/*!< table-wide callback... must be
+					   set first in table; arg points 
+					   to callback, descrip points to 
+					   callback data to pass */
+#define POPT_ARG_INTL_DOMAIN    6       /*!< set the translation domain
+					   for this table and any
+					   included tables; arg points
+					   to the domain string */
+#define POPT_ARG_VAL		7	/*!< arg should take value val */
+#define	POPT_ARG_FLOAT		8	/*!< arg will be converted to float */
+#define	POPT_ARG_DOUBLE		9	/*!< arg will be converted to double */
+
+#define POPT_ARG_MASK		0x0000FFFF
+/*@}*/
+
+/** \ingroup popt
+ * \name Arg modifiers
+ */
+/*@{*/
+#define POPT_ARGFLAG_ONEDASH	0x80000000  /*!< allow -longoption */
+#define POPT_ARGFLAG_DOC_HIDDEN 0x40000000  /*!< don't show in help/usage */
+#define POPT_ARGFLAG_STRIP	0x20000000  /*!< strip this arg from argv(only applies to long args) */
+#define	POPT_ARGFLAG_OPTIONAL	0x10000000  /*!< arg may be missing */
+
+#define	POPT_ARGFLAG_OR		0x08000000  /*!< arg will be or'ed */
+#define	POPT_ARGFLAG_NOR	0x09000000  /*!< arg will be nor'ed */
+#define	POPT_ARGFLAG_AND	0x04000000  /*!< arg will be and'ed */
+#define	POPT_ARGFLAG_NAND	0x05000000  /*!< arg will be nand'ed */
+#define	POPT_ARGFLAG_XOR	0x02000000  /*!< arg will be xor'ed */
+#define	POPT_ARGFLAG_NOT	0x01000000  /*!< arg will be negated */
+#define POPT_ARGFLAG_LOGICALOPS \
+        (POPT_ARGFLAG_OR|POPT_ARGFLAG_AND|POPT_ARGFLAG_XOR)
+
+#define	POPT_BIT_SET	(POPT_ARG_VAL|POPT_ARGFLAG_OR)
+					/*!< set arg bit(s) */
+#define	POPT_BIT_CLR	(POPT_ARG_VAL|POPT_ARGFLAG_NAND)
+					/*!< clear arg bit(s) */
+
+#define	POPT_ARGFLAG_SHOW_DEFAULT 0x00800000 /*!< show default value in --help */
+
+/*@}*/
+
+/** \ingroup popt
+ * \name Callback modifiers
+ */
+/*@{*/
+#define POPT_CBFLAG_PRE		0x80000000  /*!< call the callback before parse */
+#define POPT_CBFLAG_POST	0x40000000  /*!< call the callback after parse */
+#define POPT_CBFLAG_INC_DATA	0x20000000  /*!< use data from the include line,
+					       not the subtable */
+#define POPT_CBFLAG_SKIPOPTION	0x10000000  /*!< don't callback with option */
+#define POPT_CBFLAG_CONTINUE	0x08000000  /*!< continue callbacks with option */
+/*@}*/
+
+/** \ingroup popt
+ * \name Error return values
+ */
+/*@{*/
+#define POPT_ERROR_NOARG	-10	/*!< missing argument */
+#define POPT_ERROR_BADOPT	-11	/*!< unknown option */
+#define POPT_ERROR_OPTSTOODEEP	-13	/*!< aliases nested too deeply */
+#define POPT_ERROR_BADQUOTE	-15	/*!< error in paramter quoting */
+#define POPT_ERROR_ERRNO	-16	/*!< errno set, use strerror(errno) */
+#define POPT_ERROR_BADNUMBER	-17	/*!< invalid numeric value */
+#define POPT_ERROR_OVERFLOW	-18	/*!< number too large or too small */
+#define	POPT_ERROR_BADOPERATION	-19	/*!< mutually exclusive logical operations requested */
+#define	POPT_ERROR_NULLARG	-20	/*!< opt->arg should not be NULL */
+#define	POPT_ERROR_MALLOC	-21	/*!< memory allocation failed */
+/*@}*/
+
+/** \ingroup popt
+ * \name poptBadOption() flags
+ */
+/*@{*/
+#define POPT_BADOPTION_NOALIAS  (1 << 0)  /*!< don't go into an alias */
+/*@}*/
+
+/** \ingroup popt
+ * \name poptGetContext() flags
+ */
+/*@{*/
+#define POPT_CONTEXT_NO_EXEC	(1 << 0)  /*!< ignore exec expansions */
+#define POPT_CONTEXT_KEEP_FIRST	(1 << 1)  /*!< pay attention to argv[0] */
+#define POPT_CONTEXT_POSIXMEHARDER (1 << 2) /*!< options can't follow args */
+#define POPT_CONTEXT_ARG_OPTS	(1 << 4) /*!< return args as options with value 0 */
+/*@}*/
+
+/** \ingroup popt
+ */
+struct poptOption {
+/*@observer@*/ /*@null@*/
+    const char * longName;	/*!< may be NULL */
+    char shortName;		/*!< may be NUL */
+    int argInfo;
+/*@shared@*/ /*@null@*/
+    void * arg;			/*!< depends on argInfo */
+    int val;			/*!< 0 means don't return, just update flag */
+/*@observer@*/ /*@null@*/
+    const char * descrip;	/*!< description for autohelp -- may be NULL */
+/*@observer@*/ /*@null@*/
+    const char * argDescrip;	/*!< argument description for autohelp */
+};
+
+/** \ingroup popt
+ * A popt alias argument for poptAddAlias().
+ */
+struct poptAlias {
+/*@owned@*/ /*@null@*/
+    const char * longName;	/*!< may be NULL */
+    char shortName;		/*!< may be NUL */
+    int argc;
+/*@owned@*/
+    const char ** argv;		/*!< must be free()able */
+};
+
+/** \ingroup popt
+ * A popt alias or exec argument for poptAddItem().
+ */
+/*@-exporttype@*/
+typedef struct poptItem_s {
+    struct poptOption option;	/*!< alias/exec name(s) and description. */
+    int argc;			/*!< (alias) no. of args. */
+/*@owned@*/
+    const char ** argv;		/*!< (alias) args, must be free()able. */
+} * poptItem;
+/*@=exporttype@*/
+
+/** \ingroup popt
+ * \name Auto-generated help/usage
+ */
+/*@{*/
+
+/**
+ * Empty table marker to enable displaying popt alias/exec options.
+ */
+/*@-exportvar@*/
+/*@unchecked@*/ /*@observer@*/
+extern struct poptOption poptAliasOptions[];
+/*@=exportvar@*/
+#define POPT_AUTOALIAS { NULL, '\0', POPT_ARG_INCLUDE_TABLE, poptAliasOptions, \
+			0, "Options implemented via popt alias/exec:", NULL },
+
+/**
+ * Auto help table options.
+ */
+/*@-exportvar@*/
+/*@unchecked@*/ /*@observer@*/
+extern struct poptOption poptHelpOptions[];
+/*@=exportvar@*/
+
+/*@-exportvar@*/
+/*@unchecked@*/ /*@observer@*/
+extern struct poptOption * poptHelpOptionsI18N;
+/*@=exportvar@*/
+
+#define POPT_AUTOHELP { NULL, '\0', POPT_ARG_INCLUDE_TABLE, poptHelpOptions, \
+			0, "Help options:", NULL },
+
+#define POPT_TABLEEND { NULL, '\0', 0, 0, 0, NULL, NULL }
+/*@}*/
+
+/** \ingroup popt
+ */
+/*@-exporttype@*/
+typedef /*@abstract@*/ struct poptContext_s * poptContext;
+/*@=exporttype@*/
+
+/** \ingroup popt
+ */
+#ifndef __cplusplus
+/*@-exporttype -typeuse@*/
+typedef struct poptOption * poptOption;
+/*@=exporttype =typeuse@*/
+#endif
+
+/*@-exportconst@*/
+enum poptCallbackReason {
+    POPT_CALLBACK_REASON_PRE	= 0, 
+    POPT_CALLBACK_REASON_POST	= 1,
+    POPT_CALLBACK_REASON_OPTION = 2
+};
+/*@=exportconst@*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*@-type@*/
+
+/** \ingroup popt
+ * Table callback prototype.
+ * @param con		context
+ * @param reason	reason for callback
+ * @param opt		option that triggered callback
+ * @param arg		@todo Document.
+ * @param data		@todo Document.
+ */
+typedef void (*poptCallbackType) (poptContext con, 
+		enum poptCallbackReason reason,
+		/*@null@*/ const struct poptOption * opt,
+		/*@null@*/ const char * arg,
+		/*@null@*/ const void * data)
+	/*@globals internalState @*/
+	/*@modifies internalState @*/;
+
+/** \ingroup popt
+ * Initialize popt context.
+ * @param name		context name (usually argv[0] program name)
+ * @param argc		no. of arguments
+ * @param argv		argument array
+ * @param options	address of popt option table
+ * @param flags		or'd POPT_CONTEXT_* bits
+ * @return		initialized popt context
+ */
+/*@only@*/ /*@null@*/
+poptContext poptGetContext(
+		/*@dependent@*/ /*@keep@*/ const char * name,
+		int argc, /*@dependent@*/ /*@keep@*/ const char ** argv,
+		/*@dependent@*/ /*@keep@*/ const struct poptOption * options,
+		int flags)
+	/*@*/;
+
+/** \ingroup popt
+ * Reinitialize popt context.
+ * @param con		context
+ */
+/*@unused@*/
+void poptResetContext(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return value of next option found.
+ * @param con		context
+ * @return		next option val, -1 on last item, POPT_ERROR_* on error
+ */
+int poptGetNextOpt(/*@null@*/poptContext con)
+	/*@globals fileSystem, internalState @*/
+	/*@modifies con, fileSystem, internalState @*/;
+
+/** \ingroup popt
+ * Return next option argument (if any).
+ * @param con		context
+ * @return		option argument, NULL if no argument is available
+ */
+/*@observer@*/ /*@null@*/ /*@unused@*/
+const char * poptGetOptArg(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return next argument.
+ * @param con		context
+ * @return		next argument, NULL if no argument is available
+ */
+/*@observer@*/ /*@null@*/ /*@unused@*/
+const char * poptGetArg(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Peek at current argument.
+ * @param con		context
+ * @return		current argument, NULL if no argument is available
+ */
+/*@observer@*/ /*@null@*/ /*@unused@*/
+const char * poptPeekArg(/*@null@*/poptContext con)
+	/*@*/;
+
+/** \ingroup popt
+ * Return remaining arguments.
+ * @param con		context
+ * @return		argument array, NULL terminated
+ */
+/*@observer@*/ /*@null@*/
+const char ** poptGetArgs(/*@null@*/poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Return the option which caused the most recent error.
+ * @param con		context
+ * @param flags
+ * @return		offending option
+ */
+/*@observer@*/
+const char * poptBadOption(/*@null@*/poptContext con, int flags)
+	/*@*/;
+
+/** \ingroup popt
+ * Destroy context.
+ * @param con		context
+ * @return		NULL always
+ */
+/*@null@*/
+poptContext poptFreeContext( /*@only@*/ /*@null@*/ poptContext con)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add arguments to context.
+ * @param con		context
+ * @param argv		argument array, NULL terminated
+ * @return		0 on success, POPT_ERROR_OPTSTOODEEP on failure
+ */
+/*@unused@*/
+int poptStuffArgs(poptContext con, /*@keep@*/ const char ** argv)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add alias to context.
+ * @todo Pass alias by reference, not value.
+ * @deprecated Use poptAddItem instead.
+ * @param con		context
+ * @param alias		alias to add
+ * @param flags		(unused)
+ * @return		0 on success
+ */
+/*@unused@*/
+int poptAddAlias(poptContext con, struct poptAlias alias, int flags)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Add alias/exec item to context.
+ * @param con		context
+ * @param newItem	alias/exec item to add
+ * @param flags		0 for alias, 1 for exec
+ * @return		0 on success
+ */
+int poptAddItem(poptContext con, poptItem newItem, int flags)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Read configuration file.
+ * @param con		context
+ * @param fn		file name to read
+ * @return		0 on success, POPT_ERROR_ERRNO on failure
+ */
+int poptReadConfigFile(poptContext con, const char * fn)
+	/*@globals errno, fileSystem, internalState @*/
+	/*@modifies con->execs, con->numExecs,
+		errno, fileSystem, internalState @*/;
+
+/** \ingroup popt
+ * Read default configuration from /etc/popt and $HOME/.popt.
+ * @param con		context
+ * @param useEnv	(unused)
+ * @return		0 on success, POPT_ERROR_ERRNO on failure
+ */
+/*@unused@*/
+int poptReadDefaultConfig(poptContext con, /*@unused@*/ int useEnv)
+	/*@globals fileSystem, internalState @*/
+	/*@modifies con->execs, con->numExecs,
+		fileSystem, internalState @*/;
+
+/** \ingroup popt
+ * Duplicate an argument array.
+ * @note: The argument array is malloc'd as a single area, so only argv must
+ * be free'd.
+ *
+ * @param argc		no. of arguments
+ * @param argv		argument array
+ * @retval argcPtr	address of returned no. of arguments
+ * @retval argvPtr	address of returned argument array
+ * @return		0 on success, POPT_ERROR_NOARG on failure
+ */
+int poptDupArgv(int argc, /*@null@*/ const char **argv,
+		/*@null@*/ /*@out@*/ int * argcPtr,
+		/*@null@*/ /*@out@*/ const char *** argvPtr)
+	/*@modifies *argcPtr, *argvPtr @*/;
+
+/** \ingroup popt
+ * Parse a string into an argument array.
+ * The parse allows ', ", and \ quoting, but ' is treated the same as " and
+ * both may include \ quotes.
+ * @note: The argument array is malloc'd as a single area, so only argv must
+ * be free'd.
+ *
+ * @param s		string to parse
+ * @retval argcPtr	address of returned no. of arguments
+ * @retval argvPtr	address of returned argument array
+ */
+int poptParseArgvString(const char * s,
+		/*@out@*/ int * argcPtr, /*@out@*/ const char *** argvPtr)
+	/*@modifies *argcPtr, *argvPtr @*/;
+
+/** \ingroup popt
+ * Parses an input configuration file and returns an string that is a 
+ * command line.  For use with popt.  You must free the return value when done.
+ *
+ * Given the file:
+\verbatim
+# this line is ignored
+    #   this one too
+aaa
+  bbb
+    ccc   
+bla=bla
+
+this_is   =   fdsafdas
+     bad_line=        
+  reall bad line  
+  reall bad line  = again
+5555=   55555   
+  test = with lots of spaces
+\endverbatim
+*
+* The result is:
+\verbatim
+--aaa --bbb --ccc --bla="bla" --this_is="fdsafdas" --5555="55555" --test="with lots of spaces"
+\endverbatim
+*
+* Passing this to poptParseArgvString() yields an argv of:
+\verbatim
+'--aaa'
+'--bbb' 
+'--ccc' 
+'--bla=bla' 
+'--this_is=fdsafdas' 
+'--5555=55555' 
+'--test=with lots of spaces' 
+\endverbatim
+ *
+ * @bug NULL is returned if file line is too long.
+ * @bug Silently ignores invalid lines.
+ *
+ * @param fp		file handle to read
+ * @param *argstrp	return string of options (malloc'd)
+ * @param flags		unused
+ * @return		0 on success
+ * @see			poptParseArgvString
+ */
+/*@-fcnuse@*/
+int poptConfigFileToString(FILE *fp, /*@out@*/ char ** argstrp, int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, *argstrp, fileSystem @*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Return formatted error string for popt failure.
+ * @param error		popt error
+ * @return		error string
+ */
+/*@observer@*/
+const char * poptStrerror(const int error)
+	/*@*/;
+
+/** \ingroup popt
+ * Limit search for executables.
+ * @param con		context
+ * @param path		single path to search for executables
+ * @param allowAbsolute	absolute paths only?
+ */
+/*@unused@*/
+void poptSetExecPath(poptContext con, const char * path, int allowAbsolute)
+	/*@modifies con @*/;
+
+/** \ingroup popt
+ * Print detailed description of options.
+ * @param con		context
+ * @param fp		ouput file handle
+ * @param flags		(unused)
+ */
+void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/;
+
+/** \ingroup popt
+ * Print terse description of options.
+ * @param con		context
+ * @param fp		ouput file handle
+ * @param flags		(unused)
+ */
+void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ int flags)
+	/*@globals fileSystem @*/
+	/*@modifies *fp, fileSystem @*/;
+
+/** \ingroup popt
+ * Provide text to replace default "[OPTION...]" in help/usage output.
+ * @param con		context
+ * @param text		replacement text
+ */
+/*@-fcnuse@*/
+void poptSetOtherOptionHelp(poptContext con, const char * text)
+	/*@modifies con @*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Return argv[0] from context.
+ * @param con		context
+ * @return		argv[0]
+ */
+/*@-fcnuse@*/
+/*@observer@*/
+const char * poptGetInvocationName(poptContext con)
+	/*@*/;
+/*@=fcnuse@*/
+
+/** \ingroup popt
+ * Shuffle argv pointers to remove stripped args, returns new argc.
+ * @param con		context
+ * @param argc		no. of args
+ * @param argv		arg vector
+ * @return		new argc
+ */
+/*@-fcnuse@*/
+int poptStrippedArgv(poptContext con, int argc, char ** argv)
+	/*@modifies *argv @*/;
+/*@=fcnuse@*/
+
+/**
+ * Save a long, performing logical operation with value.
+ * @warning Alignment check may be too strict on certain platorms.
+ * @param arg		integer pointer, aligned on int boundary.
+ * @param argInfo	logical operation (see POPT_ARGFLAG_*)
+ * @param aLong		value to use
+ * @return		0 on success, POPT_ERROR_NULLARG/POPT_ERROR_BADOPERATION
+ */
+/*@-incondefs@*/
+/*@unused@*/
+int poptSaveLong(/*@null@*/ long * arg, int argInfo, long aLong)
+	/*@modifies *arg @*/
+	/*@requires maxSet(arg) >= 0 /\ maxRead(arg) == 0 @*/;
+/*@=incondefs@*/
+
+/**
+ * Save an integer, performing logical operation with value.
+ * @warning Alignment check may be too strict on certain platorms.
+ * @param arg		integer pointer, aligned on int boundary.
+ * @param argInfo	logical operation (see POPT_ARGFLAG_*)
+ * @param aLong		value to use
+ * @return		0 on success, POPT_ERROR_NULLARG/POPT_ERROR_BADOPERATION
+ */
+/*@-incondefs@*/
+/*@unused@*/
+int poptSaveInt(/*@null@*/ int * arg, int argInfo, long aLong)
+	/*@modifies *arg @*/
+	/*@requires maxSet(arg) >= 0 /\ maxRead(arg) == 0 @*/;
+/*@=incondefs@*/
+
+/*@=type@*/
+#ifdef  __cplusplus
+}
+#endif
+
+#endif