/*
* This file is part of ltrace.
- * Copyright (C) 2012 Petr Machata, Red Hat Inc.
+ * Copyright (C) 2012,2013 Petr Machata, Red Hat Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
#include <gelf.h>
enum process_status {
- ps_invalid, /* Failure. */
- ps_stop, /* Job-control stop. */
- ps_tracing_stop,
- ps_sleeping,
- ps_zombie,
- ps_other, /* Necessary other states can be added as needed. */
+ PS_INVALID, /* Failure. */
+ PS_STOP, /* Job-control stop. */
+ PS_TRACING_STOP,
+ PS_SLEEPING,
+ PS_ZOMBIE,
+ PS_OTHER, /* Necessary other states can be added as needed. */
};
/*
int task_kill(pid_t pid, int sig);
/* Called after PID is attached, but before it is continued. */
-void trace_set_options(struct Process *proc);
+void trace_set_options(struct process *proc);
/* Called after ltrace forks. Should attach the newly created child,
* in whose context this function is called. */
/* The back end may need to store arbitrary data to a process. This
* is a place where it can initialize PROC->arch_dep. XXX this should
* be dropped in favor of arhc_process_init on pmachata/libs. */
-void get_arch_dep(struct Process *proc);
+void get_arch_dep(struct process *proc);
/* Return current instruction pointer of PROC.
*
* that would otherwise support this. Above we have a definition of
* arch_addr_t. This should be converted to an integral type and
* used for target addresses throughout. */
-void *get_instruction_pointer(struct Process *proc);
+void *get_instruction_pointer(struct process *proc);
/* Set instruction pointer of PROC to ADDR. XXX see above. */
-void set_instruction_pointer(struct Process *proc, void *addr);
+void set_instruction_pointer(struct process *proc, void *addr);
/* Return current stack pointer of PROC. XXX see above. */
-void *get_stack_pointer(struct Process *proc);
+void *get_stack_pointer(struct process *proc);
/* Find and return caller address, i.e. the address where the current
* function returns. */
-void *get_return_addr(struct Process *proc, void *stack_pointer);
-
-/* Adjust PROC so that when the current function returns, it returns
- * to ADDR. */
-void set_return_addr(struct Process *proc, void *addr);
+void *get_return_addr(struct process *proc, void *stack_pointer);
/* Enable breakpoint SBP in process PROC. */
-void enable_breakpoint(struct Process *proc, struct breakpoint *sbp);
+void enable_breakpoint(struct process *proc, struct breakpoint *sbp);
/* Disable breakpoint SBP in process PROC. */
-void disable_breakpoint(struct Process *proc, struct breakpoint *sbp);
+void disable_breakpoint(struct process *proc, struct breakpoint *sbp);
/* Determine whether the event that we have just seen (and that is
* recorded in STATUS) was a syscall. If it was, return 1. If it was
* a return from syscall, return 2. In both cases, set *SYSNUM to the
* number of said syscall. If it wasn't a syscall, return 0. If
* there was an error, return -1. */
-int syscall_p(struct Process *proc, int status, int *sysnum);
+int syscall_p(struct process *proc, int status, int *sysnum);
/* Continue execution of the process with given PID. */
void continue_process(pid_t pid);
* is system call, otherwise it's return from a system call. The
* callback should do whatever book-keeping is necessary and continue
* the process if necessary. */
-void continue_after_syscall(struct Process *proc, int sysnum, int ret_p);
+void continue_after_syscall(struct process *proc, int sysnum, int ret_p);
/* Called after we hit a breakpoint SBP. Should do whatever
* book-keeping is necessary and then continue the process. */
-void continue_after_breakpoint(struct Process *proc, struct breakpoint *sbp);
+void continue_after_breakpoint(struct process *proc, struct breakpoint *sbp);
/* Called after we received a vfork. Should do whatever book-keeping
* is necessary and continue the process if necessary. N.B. right
* now, with Linux/GNU the only back end, this is not necessary. I
* imagine other systems may be different. */
-void continue_after_vfork(struct Process *proc);
+void continue_after_vfork(struct process *proc);
+
+/* Called after the process exec's. Should do whatever book-keeping
+ * is necessary and then continue the process. */
+void continue_after_exec(struct process *proc);
/* Called when trace_me or primary trace_pid fail. This may plug in
* any platform-specific knowledge of why it could be so. */
/* Should copy COUNT bytes from address ADDR of process PROC to local
* buffer BUF. */
-size_t umovebytes (struct Process *proc, void *addr, void *buf, size_t count);
+size_t umovebytes(struct process *proc, arch_addr_t addr,
+ void *buf, size_t count);
/* Find out an address of symbol SYM in process PROC, and return.
* Returning NULL delays breakpoint insertion and enables heaps of
* arch-specific black magic that we should clean up some day.
*
* XXX the same points as for get_instruction_pointer apply. */
-void *sym2addr(struct Process *proc, struct library_symbol *sym);
+void *sym2addr(struct process *proc, struct library_symbol *sym);
/* Obtain address of PLT entry corresponding to relocation RELA in
* file LTE. This is NDX-th PLT entry in the file.
/* Called at some point after we have attached to PROC. This callback
* should insert an introspection breakpoint for handling dynamic
* linker library loads. */
-int linkmap_init(struct Process *proc, arch_addr_t dyn_addr);
+int linkmap_init(struct process *proc, arch_addr_t dyn_addr);
/* This should produce and return the next event of one of the traced
* processes. The returned pointer will not be freed by the core and
struct Event *next_event(void);
/* Called when process PROC was removed. */
-void process_removed(struct Process *proc);
+void process_removed(struct process *proc);
/* This should extract entry point address and interpreter (dynamic
* linker) bias if possible. Returns 0 if there were no errors, -1
* otherwise. Sets *ENTRYP and *INTERP_BIASP to non-zero values if
* the corresponding value is known, or zero otherwise; this is not
* done for pointers that are NULL. */
-int process_get_entry(struct Process *proc,
+int process_get_entry(struct process *proc,
arch_addr_t *entryp,
arch_addr_t *interp_biasp);
int arch_elf_init(struct ltelf *lte, struct library *lib);
void arch_elf_destroy(struct ltelf *lte);
+/* The following callbacks have to be implemented in OS backend if
+ * os.h defines OS_HAVE_BREAKPOINT_DATA. Those are used to init,
+ * destroy, and clone SBP->os. os_breakpoint_init and
+ * os_breakpoint_clone return 0 on success or a negative value on
+ * failure. */
+int os_breakpoint_init(struct process *proc, struct breakpoint *sbp);
+void os_breakpoint_destroy(struct breakpoint *sbp);
+int os_breakpoint_clone(struct breakpoint *retp, struct breakpoint *sbp);
+
/* The following callbacks have to be implemented in backend if arch.h
* defines ARCH_HAVE_BREAKPOINT_DATA. Those are used to init,
* destroy, and clone SBP->arch. arch_breakpoint_init and
* arch_breakpoint_clone return 0 on success or a negative value on
* failure. */
-int arch_breakpoint_init(struct Process *proc, struct breakpoint *sbp);
+int arch_breakpoint_init(struct process *proc, struct breakpoint *sbp);
void arch_breakpoint_destroy(struct breakpoint *sbp);
int arch_breakpoint_clone(struct breakpoint *retp, struct breakpoint *sbp);
+/* The following callbacks have to be implemented in OS backend if
+ * os.h defines OS_HAVE_LIBRARY_DATA. Those are used to init, destroy
+ * and clone LIB->os. os_library_init and os_library_clone return 0
+ * on success or a negative value on failure. */
+int os_library_init(struct library *lib);
+void os_library_destroy(struct library *lib);
+int os_library_clone(struct library *retp, struct library *lib);
+
/* The following callbacks have to be implemented in backend if arch.h
* defines ARCH_HAVE_LIBRARY_DATA. Those are used to init, destroy
- * and clone LIB->arch. */
-void arch_library_init(struct library *lib);
+ * and clone LIB->arch. arch_library_init and arch_library_clone
+ * return 0 on success or a negative value on failure. */
+int arch_library_init(struct library *lib);
void arch_library_destroy(struct library *lib);
-void arch_library_clone(struct library *retp, struct library *lib);
+int arch_library_clone(struct library *retp, struct library *lib);
+
+/* The following callbacks have to be implemented in OS backend if
+ * os.h defines OS_HAVE_LIBRARY_SYMBOL_DATA. Those are used to init,
+ * destroy and clone LIBSYM->os. os_library_symbol_init and
+ * os_library_symbol_clone return 0 on success or a negative value on
+ * failure. */
+int os_library_symbol_init(struct library_symbol *libsym);
+void os_library_symbol_destroy(struct library_symbol *libsym);
+int os_library_symbol_clone(struct library_symbol *retp,
+ struct library_symbol *libsym);
/* The following callbacks have to be implemented in backend if arch.h
* defines ARCH_HAVE_LIBRARY_SYMBOL_DATA. Those are used to init,
int arch_library_symbol_clone(struct library_symbol *retp,
struct library_symbol *libsym);
+/* The following callbacks have to be implemented in OS backend if
+ * os.h defines OS_HAVE_PROCESS_DATA. The protocol is same as for,
+ * respectively, arch_process_init, arch_process_destroy,
+ * arch_process_clone and arch_process_exec. */
+int os_process_init(struct process *proc);
+void os_process_destroy(struct process *proc);
+int os_process_clone(struct process *retp, struct process *proc);
+int os_process_exec(struct process *proc);
+
/* The following callbacks have to be implemented in backend if arch.h
* defines ARCH_HAVE_PROCESS_DATA. Those are used to init, destroy
* and clone PROC->arch. arch_process_exec is called to update
* PROC->arch in case that PROC underwent an exec. See notes at
* process_init, process_destroy, process_clone and process_exec in
* proc.h. */
-int arch_process_init(struct Process *proc);
-void arch_process_destroy(struct Process *proc);
-int arch_process_clone(struct Process *retp, struct Process *proc);
-int arch_process_exec(struct Process *proc);
-
-/* The following callbacks have to be implemented in OS backend if
- * os.h defines OS_HAVE_PROCESS_DATA. The protocol is same as for,
- * respectively, arch_process_init, arch_process_destroy,
- * arch_process_clone and arch_process_exec. */
-int os_process_init(struct Process *proc);
-void os_process_destroy(struct Process *proc);
-int os_process_clone(struct Process *retp, struct Process *proc);
-int os_process_exec(struct Process *proc);
+int arch_process_init(struct process *proc);
+void arch_process_destroy(struct process *proc);
+int arch_process_clone(struct process *retp, struct process *proc);
+int arch_process_exec(struct process *proc);
/* The following callback has to be implemented in backend if arch.h
* defines ARCH_HAVE_GET_SYM_INFO.
*
- * This is called for every PLT relocation R in ELF file LTE, that
- * ltrace is about to add to it's internal representation of the
- * program under trace.
- * The corresponding PLT entry is for SYM_INDEX-th relocation in the file.
- *
- * The callback is responsible for initializing RELA and SYM.
- *
- * Return 0 if OK.
- * Return a negative value if this symbol (SYM_INDEX) should be ignored. */
-int arch_get_sym_info(struct ltelf *lte, const char *filename,
- size_t sym_index, GElf_Rela *rela, GElf_Sym *sym);
+ * This is called for every PLT relocation RELA in ELF file LTE (which
+ * is named FILENAME), that ltrace is about to add. The corresponding
+ * PLT entry is for SYM_INDEX-th relocation in the file. This call is
+ * supposed to initialize SYM and RELA. It returns 0 if there were no
+ * errors and given symbol should be used, 1 if the symbol should not
+ * be used, or a negative value if there were errors. */
+int arch_get_sym_info(struct ltelf *lte, const char *filename, size_t sym_index,
+ GElf_Rela *rela, GElf_Sym *sym);
enum plt_status {
- plt_fail,
- plt_ok,
- plt_default,
+ PLT_FAIL,
+ PLT_OK,
+ PLT_DEFAULT,
};
-/* The following callback has to be implemented in backend if arch.h
- * defines ARCH_HAVE_ADD_PLT_ENTRY.
+/* The following callback has to be implemented in OS backend if os.h
+ * defines OS_HAVE_ADD_PLT_ENTRY.
*
* This is called for every PLT relocation R in ELF file LTE, that
* ltrace is about to add to a library constructed in process PROC.
* The corresponding PLT entry is for symbol called NAME, and it's
* I-th relocation in the file.
*
- * If this function returns plt_default, PLT address is obtained by
- * calling arch_plt_sym_val, and symbol is allocated. If plt_ok or
- * plt_default are returned, the chain of symbols passed back in RET
+ * If this function returns PLT_DEFAULT, PLT address is obtained by
+ * calling arch_plt_sym_val, and symbol is allocated. If PLT_OK or
+ * PLT_DEFAULT are returned, the chain of symbols passed back in RET
* is added to library under construction. */
-enum plt_status arch_elf_add_plt_entry(struct Process *proc, struct ltelf *lte,
+enum plt_status os_elf_add_plt_entry(struct process *proc, struct ltelf *lte,
+ const char *name, GElf_Rela *rela,
+ size_t i, struct library_symbol **ret);
+
+/* Like os_elf_add_plt_entry, but tied to ARCH_HAVE_ADD_PLT_ENTRY in
+ * arch.h. The arch callback is called first. If it returns
+ * PLT_DEFAULT, the os callback is called next. */
+enum plt_status arch_elf_add_plt_entry(struct process *proc, struct ltelf *lte,
const char *name, GElf_Rela *rela,
size_t i, struct library_symbol **ret);
+/* The following callback has to be implemented in OS backend if os.h
+ * defines OS_HAVE_ADD_FUNC_ENTRY.
+ *
+ * This is called for every symbol in ltrace is about to add to the
+ * library constructed for LTE in process PROC.
+ *
+ * If this function returns PLT_DEFAULT, then if there is a
+ * pre-existing symbol, its name may be updated if the newly-found
+ * name is shorter. Otherwise a new symbol is created.
+ *
+ * If PLT_OK or PLT_DEFAULT are returned, the chain of symbols passed
+ * back in RET is added to library under construction. */
+enum plt_status os_elf_add_func_entry(struct process *proc, struct ltelf *lte,
+ const GElf_Sym *sym,
+ arch_addr_t addr, const char *name,
+ struct library_symbol **ret);
+
+/* Like os_elf_add_func_entry, but tied to ARCH_HAVE_ADD_FUNC_ENTRY in
+ * arch.h. The arch callback is called first. If it returns
+ * PLT_DEFAULT, the os callback is called next. */
+enum plt_status arch_elf_add_func_entry(struct process *proc, struct ltelf *lte,
+ const GElf_Sym *sym,
+ arch_addr_t addr, const char *name,
+ struct library_symbol **ret);
+
/* This callback needs to be implemented if arch.h defines
* ARCH_HAVE_DYNLINK_DONE. It is called after the dynamic linker is
- * done with the process startup. */
-void arch_dynlink_done(struct Process *proc);
+ * done with the process start-up. */
+void arch_dynlink_done(struct process *proc);
/* This callback needs to be implemented if arch.h defines
* ARCH_HAVE_SYMBOL_RET. It is called after a traced call returns. */
-void arch_symbol_ret(struct Process *proc, struct library_symbol *libsym);
+void arch_symbol_ret(struct process *proc, struct library_symbol *libsym);
/* This callback needs to be implemented if arch.h defines
* DYN_ADDR holds the address of the dynamic section.
* If the debug area is found, return 0 and fill in the address in *RET.
* If the debug area is not found, return a negative value. */
-int arch_find_dl_debug(struct Process *proc, arch_addr_t dyn_addr,
+int arch_find_dl_debug(struct process *proc, arch_addr_t dyn_addr,
arch_addr_t *ret);
+/* This is called to obtain a list of directories to search when
+ * loading config files. The callback sets *RETP to a pointer to the
+ * first element of a NULL-terminated array of directory names. It's
+ * legitimate to set *RETP to NULL to indicate there are no
+ * directories. The function returns 0 on success or a negative value
+ * on a failure.
+ *
+ * If PRIVATE is set, the list in *RETP should contain only user's own
+ * directories (presumably under HOME if there's any such thing on the
+ * given OS). Otherwise only system directories should be reported.
+ *
+ * The directories don't have to exist. Directories passed in -F are
+ * handled separately by the caller and this callback shouldn't
+ * concern itself with it. */
+int os_get_config_dirs(int private, const char ***retp);
+
+/* This is called to obtain list of legacy config files to import, if
+ * any. A reference to initialized vector of char* is passed in.
+ *
+ * This returns 0 on success, in which case strings from *RETP (if
+ * any) are interpreted as files names. These files belong to the
+ * caller and will eventually be freed.
+ *
+ * Returns a negative value for failure, in which case *RETP contents
+ * are not consulted in any way. */
+int os_get_ltrace_conf_filenames(struct vect *retp);
+
/* If arch.h defines ARCH_HAVE_FETCH_ARG, the following callbacks have
* to be implemented: arch_fetch_arg_init, arch_fetch_arg_clone,
* arch_fetch_arg_done, arch_fetch_arg_next and arch_fetch_retval.
* implemented: arch_fetch_param_pack_start,
* arch_fetch_param_pack_end. See fetch.h for details. */
+enum sw_singlestep_status {
+ SWS_FAIL,
+ SWS_OK,
+ SWS_HW,
+};
+struct sw_singlestep_data;
+
+/* The following callback has to be implemented in backend if arch.h
+ * defines ARCH_HAVE_SW_SINGLESTEP.
+ *
+ * This is called before the OS backend requests hardware singlestep.
+ * arch_sw_singlestep should consider whether a singlestep needs to be
+ * done in software. If not, it returns SWS_HW. Otherwise it needs
+ * to add one or several breakpoints by calling ADD_CB. When it is
+ * done, it continues the process as appropriate, and answers either
+ * SWS_OK, or SWS_FAIL, depending on how it went.
+ *
+ * PROC is the process that should perform the singlestep, BP the
+ * breakpoint that we are singlestepping over. ADD_CB is a callback
+ * to request adding breakpoints that should trap the process after
+ * it's continued. The arguments to ADD_CB are the address where the
+ * breakpoint should be added, and DATA. ADD_CB returns 0 on success
+ * or a negative value on failure. It is expected that
+ * arch_sw_singlestep returns SWS_FAIL if ADD_CB returns error. */
+enum sw_singlestep_status arch_sw_singlestep(struct process *proc,
+ struct breakpoint *bp,
+ int (*add_cb)(arch_addr_t addr,
+ struct sw_singlestep_data *),
+ struct sw_singlestep_data *data);
+
#endif /* BACKEND_H */
projects / platform / upstream / ltrace.git / blobdiff