Imported Upstream version 0.7.2upstream/0.7.2

1 files changed, 226 insertions, 0 deletions

diff --git a/library.h b/library.h
new file mode 100644
index 0000000..555fa80
--- /dev/null
+++ b/library.h
@@ -0,0 +1,226 @@
+/*
+ * This file is part of ltrace.
+ * Copyright (C) 2012 Petr Machata, Red Hat Inc.
+ * Copyright (C) 2006 Paul Gilliam, IBM Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef _LIBRARY_H_
+#define _LIBRARY_H_
+
+#include <stdint.h>
+#include "callback.h"
+#include "sysdep.h"
+
+struct Process;
+struct library;
+
+enum toplt {
+	LS_TOPLT_NONE = 0,	/* PLT not used for this symbol. */
+	LS_TOPLT_EXEC,		/* PLT for this symbol is executable. */
+};
+
+/* Dict interface.  */
+unsigned int target_address_hash(const void *key);
+int target_address_cmp(const void *key1, const void *key2);
+
+/* For handling -l.  */
+struct library_exported_name {
+	struct library_exported_name *next;
+	const char *name;
+	int own_name : 1;
+};
+
+struct library_symbol {
+	struct library_symbol *next;
+	struct library *lib;
+	const char *name;
+	arch_addr_t enter_addr;
+	enum toplt plt_type;
+	int own_name : 1;
+
+	/* This is relevant for PLT symbols.  Latent PLT symbols are
+	 * those that don't match any of the -e rules, but that might
+	 * potentially become active if a library implementing them
+	 * appears that matches a -l rule.  Ltrace core is responsible
+	 * for clearing latent flag.  */
+	int latent : 1;
+
+	/* Delayed symbols are those for which a breakpoint shouldn't
+	 * be enabled yet.  They are similar to latent symbols, but
+	 * backend is responsible for clearing the delayed flag.  See
+	 * proc_activate_delayed_symbol.  */
+	int delayed : 1;
+
+	struct arch_library_symbol_data arch;
+};
+
+/* Init LIBSYM.  NAME will be freed when LIBSYM is destroyed if
+ * OWN_NAME.  ARCH has to be initialized by a separate call.  */
+int library_symbol_init(struct library_symbol *libsym,
+			arch_addr_t addr, const char *name, int own_name,
+			enum toplt type_of_plt);
+
+/* Copy library symbol SYM into the area pointed-to by RETP.  Return 0
+ * on success or a negative value on failure.  */
+int library_symbol_clone(struct library_symbol *retp,
+			 struct library_symbol *sym);
+
+/* Destroy library symbol.  This essentially just frees name if it's
+ * owned.  It doesn't free the memory associated with SYM pointer
+ * itself.  Returns 0 on success or a negative value in case of an
+ * error (which would be an out of memory condition).  */
+void library_symbol_destroy(struct library_symbol *sym);
+
+/* Compare two library symbols.  Returns a negative value, 0, or a
+ * positive value, much like strcmp.  The function compares symbol
+ * addresses, and if those are equal, it compares symbol names.  If
+ * those are equal, too, the symbols are considered equal.  */
+int library_symbol_cmp(struct library_symbol *a, struct library_symbol *b);
+
+/* Set a name for library symbol.  This frees the old name, if
+ * that is owned.  */
+void library_symbol_set_name(struct library_symbol *libsym,
+			     const char *name, int own_name);
+
+/* A function that can be used as library_each_symbol callback.  Looks
+ * for a symbol SYM for which library_symbol_cmp(SYM, STANDARD)
+ * returns 0.  */
+enum callback_status library_symbol_equal_cb(struct library_symbol *libsym,
+					     void *standard);
+
+/* A function that can be used as library_each_symbol callback.  Looks
+ * for a symbol SYM for which strcmp(SYM->name, NAME) == 0.  */
+enum callback_status library_symbol_named_cb(struct library_symbol *libsym,
+					     void *name);
+
+/* A function that can be used as library_each_symbol callback.  Looks
+ * for a delayed symbol.  */
+enum callback_status library_symbol_delayed_cb(struct library_symbol *libsym,
+					       void *unused);
+
+enum library_type {
+	LT_LIBTYPE_MAIN,
+	LT_LIBTYPE_DSO,
+};
+
+/* XXX we might consider sharing libraries across processes.  Things
+ * like libc will be opened by every single process, no point cloning
+ * these everywhere.  But for now, keep the ownership structure
+ * simple.  */
+struct library {
+	struct library *next;
+
+	/* Unique key. Two library objects are considered equal, if
+	 * they have the same key.  */
+	arch_addr_t key;
+
+	/* Address where the library is mapped.  */
+	arch_addr_t base;
+
+	/* Absolute address of the entry point.  Useful for main
+	 * binary, though I suppose the value might be useful for the
+	 * dynamic linker, too (in case we ever want to do early
+	 * process tracing).  */
+	arch_addr_t entry;
+
+	/* Address of PT_DYNAMIC segment.  */
+	arch_addr_t dyn_addr;
+
+	/* Symbols associated with the library.  This includes a
+	 * symbols that don't have a breakpoint attached (yet).  */
+	struct library_symbol *symbols;
+
+	/* List of names that this library implements, and that match
+	 * -l filter.  Each time a new library is mapped, its list of
+	 * exports is examined, and corresponding PLT slots are
+	 * enabled.  */
+	struct library_exported_name *exported_names;
+
+	const char *soname;
+	const char *pathname;
+
+	enum library_type type;
+
+	char own_soname : 1;
+	char own_pathname : 1;
+
+	struct arch_library_data arch;
+};
+
+/* Init LIB.  */
+void library_init(struct library *lib, enum library_type type);
+
+/* Initialize RETP to a library identical to LIB.  Symbols are not
+ * shared, but copied over.  Returns 0 on success and a negative value
+ * in case of failure.  */
+int library_clone(struct library *retp, struct library *lib);
+
+/* Destroy library.  Doesn't free LIB itself.  Symbols are destroyed
+ * and freed.  */
+void library_destroy(struct library *lib);
+
+/* Set library soname.  Frees the old name if necessary.  */
+void library_set_soname(struct library *lib,
+			const char *new_name, int own_name);
+
+/* Set library pathname.  Frees the old name if necessary.  */
+void library_set_pathname(struct library *lib,
+			  const char *new_name, int own_name);
+
+/* Iterate through list of symbols of library LIB.  See callback.h for
+ * notes on this interface.  */
+struct library_symbol *library_each_symbol
+	(struct library *lib, struct library_symbol *start_after,
+	 enum callback_status (*cb)(struct library_symbol *, void *),
+	 void *data);
+
+/* Add a new symbol SYM to LIB.  SYM is assumed owned, we need to
+ * overwrite SYM->next.  */
+void library_add_symbol(struct library *lib, struct library_symbol *sym);
+
+/* A function that can be used as proc_each_library callback.  Looks
+ * for a library with the name passed in DATA.  PROC is ignored.  */
+enum callback_status library_named_cb(struct Process *proc,
+				      struct library *lib, void *name);
+
+/* A function that can be used as proc_each_library callback.  Looks
+ * for a library with given base.
+ *
+ * NOTE: The key is passed as a POINTER to arch_addr_t (that
+ * because in general, arch_addr_t doesn't fit in void*).  */
+enum callback_status library_with_key_cb(struct Process *proc,
+					 struct library *lib, void *keyp);
+
+/* XXX this should really be in backend.h (as on pmachata/revamp
+ * branch), or, on this branch, in common.h.  But we need
+ * arch_addr_t (which should also be in backend.h, I reckon), so
+ * stuff it here for the time being.  */
+/* This function is implemented in the back end.  It is called for all
+ * raw addresses as read from symbol tables etc.  If necessary on
+ * given architecture, this function should translate the address
+ * according to .opd or other indirection mechanism.  Returns 0 on
+ * success and a negative value on failure.  */
+struct ltelf;
+int arch_translate_address(struct ltelf *lte,
+			   arch_addr_t addr, arch_addr_t *ret);
+/* This is the same function as arch_translate_address, except it's
+ * used at the point that we don't have ELF available anymore.  */
+int arch_translate_address_dyn(struct Process *proc,
+			       arch_addr_t addr, arch_addr_t *ret);
+
+#endif /* _LIBRARY_H_ */