commit 35824dbd124038f2d6ced86a7876ef0ef9191574 Author: Thomas Preud'homme Date: Thu Aug 18 17:18:01 2011 +0200 Initial commit (pstack v1.2) diff --git a/.cvsignore b/.cvsignore new file mode 100644 index 0000000..156790b --- /dev/null +++ b/.cvsignore @@ -0,0 +1 @@ +pstack diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..60549be --- /dev/null +++ b/COPYING @@ -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. + + + Copyright (C) 19yy + + 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) 19yy 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. + + , 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/Makefile b/Makefile new file mode 100644 index 0000000..fbc565b --- /dev/null +++ b/Makefile @@ -0,0 +1,49 @@ +# +# This file 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. +# + +VERSION = $(shell awk '/Version:/ { print $$2 }' pstack.spec) +CVSTAG = r$(subst .,-,$(VERSION)) + +CFLAGS = -Wall -DVERSION=\"$(VERSION)\" $(RPM_OPT_FLAGS) + +ifeq ($(RPM_OPT_FLAGS),) +CFLAGS += -g +LDFLAGS += -g +endif + +pstack : pstack.c + $(CC) $(CFLAGS) -o pstack pstack.c + +clean: + rm pstack + +install : pstack + mkdir -p $(BINDIR) + install -m 755 pstack $(BINDIR) + mkdir -p $(MANDIR)/man1 + install -m 644 man1/pstack.1 $(MANDIR)/man1 + +cvstag: + cvs tag -F $(CVSTAG) . + +archive: cvstag + @rm -rf /tmp/pstack-$(VERSION) /tmp/pstack + @cd /tmp; cvs export -r$(CVSTAG) pstack; mv pstack pstack-$(VERSION) + @cd /tmp; tar czSpf pstack-$(VERSION).tar.gz pstack-$(VERSION) + @rm -rf /tmp/pstack-$(VERSION) + @cp /tmp/pstack-$(VERSION).tar.gz . + @echo " " + @echo "The final archive is ./pstack-$(VERSION).tar.gz." diff --git a/README b/README new file mode 100644 index 0000000..d9023ff --- /dev/null +++ b/README @@ -0,0 +1,38 @@ +pstack - print stack trace of running processes + +pstack dumps a stack trace for a process, given the pid of that +process. If the process named is part of a thread group, then all the threads +inthe group are traced. See the man page for more information. + +This program was inspired by the 'pstack' program available on Solaris. + +SUPPORTED PLATFORMS: + This program runs on 32 bit x86 machines, using ELF binaries +generated from GNU compilers. If threads are being used, it depends +on a debuggable version of the pthreads library to find the threads in +the thread group. If anyone wants to port this to other +architectures, please let me know about questions you may have, or +achievements you have made. I'd like to incorporate such changes into +my version of the code. + +FEATURES: + symbolic address dumping + thread group support + +BUILD: + make + +INSTALL: + make install + +UNINSTALL: + make uninstall + +NOTE: you must be root to [un]install. pstack will run fine from any +directory, install just puts the binary and man page in 'normal' +places (/usr/local/...) + +USAGE: + pstack pid [...] + +See the man page for more details. diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..e418fa6 --- /dev/null +++ b/VERSION @@ -0,0 +1,3 @@ +1.0 12/Oct/1999 07:20:09 PDT +1.1 25/Feb/2002 +1.2 12/Nov/2003 diff --git a/man1/pstack.1 b/man1/pstack.1 new file mode 100644 index 0000000..fddde40 --- /dev/null +++ b/man1/pstack.1 @@ -0,0 +1,61 @@ +.\" +.\" pstack manual page. +.\" Copyright (c) 1999 Ross Thompson +.\" Copyright (c) 2001, 2002 Red Hat, Inc. +.\" +.\" Original author: Ross Thompson +.\" +.\" 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, 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; see the file COPYING. If not, write to +.\" the Free Software Foundation, 59 Temple Place - Suite 330, +.\" Boston, MA 02111-1307, USA. +.\" +.TH PSTACK 1 "Feb 25 2002" "Red Hat Linux" "Linux Programmer's Manual" + +.SH NAME +pstack \- print a stack trace of running processes + +.SH SYNOPSIS +.B pstack +pid [...] + +.SH DESCRIPTION + +\f3pstack\f1 attaches to the active processes named by the \f3pid\f1s +on the command line, and prints out an execution stack trace, +including a hint at what the function arguments are. If symbols exist +in the binary (usually the case unless you have run strip(1)), then +symbolic addresses are printed as well. + +If the process is part of a thread group, then \f3pstack\f1 will print +out a stack trace for each of the threads in the group. + +.SH RESTRICTIONS + +\f3pstack\f1 currently works only on Linux, only on an x86 machine +running 32 bit ELF binaries (64 bit not supported). Also, for +symbolic information, you need to use a GNU compiler to generate your +program, and you can't strip symbols from the binaries. For thread +information to be dumped, you have to use the debug-aware version of +the LinuxThreads libpthread.so library. +(To check, run nm(1) on your pthreads library, and make sure that the +symbol "__pthread_threads_debug" is defined.) +Threads are not supported with the newer NPTL libpthread.so library. + +.SH SEE ALSO +nm(1), ptrace(2) + +.SH AUTHORS +Ross Thompson + +Red Hat, Inc. diff --git a/pstack.c b/pstack.c new file mode 100644 index 0000000..aff2034 --- /dev/null +++ b/pstack.c @@ -0,0 +1,645 @@ +/* + pstack.c -- asynchronous stack trace of a running process + Copyright (c) 1999 Ross Thompson + Copyright (c) 2001, 2003 Red Hat, Inc. + + Original Author: Ross Thompson + Critical bug fix: Tim Waugh + +*/ + +/* + This file 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. +*/ + +/* RESTRICTIONS: + + pstack currently works only on Linux, only on an x86 machine running + 32 bit ELF binaries (64 bit not supported). Also, for symbolic + information, you need to use a GNU compiler to generate your + program, and you can't strip symbols from the binaries. For thread + information to be dumped, you have to use the debug-aware version + of libpthread.so. (To check, run 'nm' on your libpthread.so, and + make sure that the symbol "__pthread_threads_debug" is defined.) +*/ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +static int thePid; /* pid requested by caller. */ +static struct { + int found; + int *pids; /* pid[0] is dad, pid[1] is manager */ + int *attached; /* pid[i] is attached? 1 = yes, 0 = no */ + int npids; +} threads; + +/* ------------------------------ */ + +static int attach(int pid) +{ + int status; + + errno = 0; + ptrace(PTRACE_ATTACH, pid, 0, 0); + + if (errno) + return errno; + + waitpid (pid, &status, WUNTRACED); + + /* If we failed due to an ECHILD, then retry with the __WCLONE + flag. Note we loop as the the PID we get back may not be + one we care about. */ + if (errno == ECHILD) { + int x; + + errno = 0; + while (1) { + x = waitpid (-1, &status, (__WCLONE)); + + if (x == pid || x < 0 || errno != 0) break; + } + } + + return errno; +} + +static int detachall(void) +{ + int i; + + /* First detach from all the threads, except the one we initially + attached to. Note that the PTRACE_DETACH will continue the + thread, so there is no need to issue a separate PTRACE_CONTINUE + call. */ + if (threads.found) { + for (i = 0; i < threads.npids; i++) { + if (threads.pids[i] != thePid && threads.attached[i]) { + errno = 0; + ptrace(PTRACE_DETACH, threads.pids[i], 0, 0); + if (errno) perror("detach"); + } + } + } + + /* Now attach from the thread we initially attached to. Note that + the PTRACE_DETACH will continue the thread, so there is no need + is issue a separate PTRACE_CONTINUE call. */ + ptrace(PTRACE_DETACH, thePid, 0, 0); + + return errno; +} + +static void handle_signal (int signum) +{ + signal (signum, SIG_DFL); + psignal (signum, "pstack signal received"); + if (thePid) detachall(); + exit (1); +} + +static void quit(char *msg) +{ + fputs(msg, stderr); + fputc('\n', stderr); + if (thePid) detachall(); + exit(1); +} + +/* ------------------------------ */ + +static Elf32_Addr DebugInfo; + +typedef struct _t_Symbols { + struct _t_Symbols *next; + char *name; + Elf32_Sym *symbols; + int nsyms; + char *strings; + int strslen, noffsets; + Elf32_Addr baseAddr; + Elf32_Dyn *dynamic; + int ndyns; +} *Symbols; + +static Symbols allSyms; + +static Symbols newSyms(const char *name) +{ + Symbols syms = (Symbols) calloc(sizeof(struct _t_Symbols), 1); + + if (!syms) quit("Out of memory"); + syms->next = allSyms; + allSyms = syms; + syms->name = strdup(name); + + return syms; +} + +static void deleteSyms(Symbols syms) +{ + Symbols s2; + + if (syms == allSyms) allSyms = syms->next; + else { + for (s2 = allSyms; s2 && s2->next != syms; s2 = s2->next); + if (s2) s2->next = syms->next; + } + if (syms->symbols) free(syms->symbols); + if (syms->strings) free(syms->strings); + if (syms->dynamic) free(syms->dynamic); + if (syms->name) free(syms->name); + free(syms); +} + +static const Elf32_Sym *lookupSymInTable(const char *name, Symbols syms) +{ + Elf32_Sym *sym; + int i; + + for (i = 0, sym = syms->symbols; i < syms->nsyms; i++, sym++) { + if (!strcmp(name, &syms->strings[sym->st_name])) + return sym; + } + + return 0; +} + +static void findCodeAddress(Elf32_Addr addr, Elf32_Sym **ans, + Symbols *symtab) +{ + Elf32_Sym *sym; + Symbols tab; + int i; + + for (tab = allSyms, *ans = 0, *symtab = 0; tab; tab = tab->next) { + if (addr < tab->baseAddr) continue; + for (sym = tab->symbols, i = 0; i < tab->nsyms; i++, sym++) { + if (sym->st_value <= addr && sym->st_shndx != SHN_UNDEF && + sym->st_shndx < tab->noffsets && + ELF32_ST_TYPE(sym->st_info) == STT_FUNC && + (!*ans || (*ans)->st_value < sym->st_value)) + *ans = sym, *symtab = tab; + } + } +} + +/* ------------------------------ */ + +static void resetData(void) +{ + Symbols syms, ns; + + if (threads.pids) free(threads.pids); + if (threads.attached) free(threads.attached); + threads.pids = 0; + threads.attached = 0; + threads.found = 0; + + for (syms = allSyms; syms; syms = ns) { + ns = syms->next; + deleteSyms(syms); + } +} + +/* ------------------------------ */ + +static const Elf32_Sym *findLocalSym(const char *name, Symbols syms) +{ + const Elf32_Sym *sym = lookupSymInTable(name, syms); + + return (!sym || sym->st_shndx == SHN_UNDEF || + sym->st_shndx >= syms->noffsets) ? 0 : sym; +} + +static int readSym(Symbols syms, int pid, const char *name, int *val) +{ + const Elf32_Sym *sym; + + if (!(sym = findLocalSym(name, syms))) return 0; + errno = 0; + *val = ptrace(PTRACE_PEEKDATA, pid, sym->st_value, 0); + if (errno) { + perror("ptrace"); + quit("Could not read thread debug info."); + } + return 1; +} + +static void checkForThreads(Symbols syms, int pid) +{ + const Elf32_Sym *handles; + int i, tpid, hsize, descOff, pidOff, numPids, *pptr; + Elf32_Addr descr; + + if (!findLocalSym("__pthread_threads_debug", syms) || + !(handles = findLocalSym("__pthread_handles", syms)) || + !readSym(syms, pid, "__pthread_sizeof_handle", &hsize) || + !readSym(syms, pid, "__pthread_offsetof_descr", &descOff) || + !readSym(syms, pid, "__pthread_offsetof_pid", &pidOff) || + !readSym(syms, pid, "__pthread_handles_num", &numPids) || + numPids == 1 || + !(threads.pids = (int *) calloc(numPids + 2, sizeof(int))) || + !(threads.attached = (int *) calloc(numPids + 2, sizeof(int)))) { + if (threads.pids) { + free(threads.pids); + threads.pids = 0; + } + if (threads.attached) { + free(threads.attached); + threads.attached = 0; + } + return; + } + errno = 0; + + for (pptr = &threads.pids[0], i = 0; i < numPids && !errno; i++) { + descr = ptrace(PTRACE_PEEKDATA, pid, + handles->st_value + (i * hsize) + descOff, 0); + if (!descr && i == 0) + /* The initial thread's descriptor was not initialized yet. */ + *pptr++ = pid; + else if (descr && !errno) { + tpid = ptrace(PTRACE_PEEKDATA, pid, descr + pidOff, 0); + if (!errno) + *pptr++ = tpid; + } + } + threads.npids = pptr - threads.pids; + + if (errno) { + perror("ptrace"); + quit("Could not read thread debug info."); + } + + threads.found = 1; + + for (i = 0; i < threads.npids; i++) { + if (threads.pids[i] && threads.pids[i] != pid) { + if (attach(threads.pids[i]) != 0) + printf("Could not attach to thread %d.\n", threads.pids[i]); + else threads.attached[i] = 1; + } else if (threads.pids[i] == pid) { + threads.attached[i] = 1; + } + + } +} + +/* ------------------------------ */ + +static void verify_ident(Elf32_Ehdr *hdr) +{ + if (memcmp(&hdr->e_ident[EI_MAG0], ELFMAG, SELFMAG)) + quit("Bad magic number."); + if (hdr->e_ident[EI_CLASS] != ELFCLASS32) + quit("only 32 bit objects supported."); + if (hdr->e_ident[EI_DATA] != ELFDATA2LSB) + quit("big endian object files not supported."); + if (hdr->e_ident[EI_VERSION] != EV_CURRENT || + hdr->e_version != EV_CURRENT) + quit("Unsupported ELF format version."); + if (hdr->e_machine != EM_386) + quit("Not an IA32 executable."); +} + +static int find_stables(Elf32_Ehdr *hdr, int fd, Symbols syms) +{ + int i, idx, spot; + Elf32_Shdr shdr; + + spot = hdr->e_shoff; + if (lseek(fd, spot, SEEK_SET) != spot) quit("seek failed."); + + memset(&shdr, 0, sizeof(shdr)); + + syms->noffsets = hdr->e_shnum; + + for (idx = 0; idx < hdr->e_shnum; idx++) { + if (read(fd, &shdr, hdr->e_shentsize) != hdr->e_shentsize) + quit("premature eof."); + spot += hdr->e_shentsize; + switch (shdr.sh_type) { + case SHT_SYMTAB: + syms->nsyms = shdr.sh_size / sizeof(Elf32_Sym); + + if (!(syms->symbols = (Elf32_Sym *) malloc(shdr.sh_size))) + quit("Could not allocate symbol table."); + + if (lseek(fd, shdr.sh_offset, SEEK_SET) != shdr.sh_offset || + read(fd, syms->symbols, shdr.sh_size) != shdr.sh_size) + quit("Could not read symbol table."); + + i = hdr->e_shoff + shdr.sh_link * hdr->e_shentsize; + if (lseek(fd, i, SEEK_SET) != i) + quit("Could not seek and find."); + if (read(fd, &shdr, hdr->e_shentsize) != hdr->e_shentsize) + quit("Could not read string table section header."); + if (!(syms->strings = malloc(shdr.sh_size))) + quit("Could not allocate string table."); + if (lseek(fd, shdr.sh_offset, SEEK_SET) != shdr.sh_offset || + read(fd, syms->strings, shdr.sh_size) != shdr.sh_size) + quit("Could not read string table."); + lseek(fd, spot, SEEK_SET); + break; + case SHT_DYNAMIC: + syms->ndyns = shdr.sh_size / sizeof(Elf32_Dyn); + if (!(syms->dynamic = (Elf32_Dyn *) malloc(shdr.sh_size))) + quit("Out of memory."); + if (lseek(fd, shdr.sh_offset, SEEK_SET) != shdr.sh_offset || + read(fd, syms->dynamic, shdr.sh_size) != shdr.sh_size) + quit("Could not read dynamic table."); + lseek(fd, spot, SEEK_SET); + break; + } + } + + return (syms->nsyms > 0); +} + +static Symbols loadSyms(const char *fname) +{ + Elf32_Ehdr hdr; + int fd; + Symbols syms; + + syms = newSyms(fname); + if ((fd = open(fname, O_RDONLY)) < 0) + quit("Could not open object file."); + read(fd, &hdr, sizeof(hdr)); + verify_ident(&hdr); + if (!find_stables(&hdr, fd, syms)) { + deleteSyms(syms); + syms = 0; + } + close(fd); + + return syms; +} + +static void readDynoData(Symbols syms, int pid) +{ + int val, done; + Elf32_Addr addr; + const Elf32_Sym *dyn = lookupSymInTable("_DYNAMIC", syms); + + for (errno = done = 0, addr = dyn->st_value; !done && !errno; addr += 8) { + val = ptrace(PTRACE_PEEKDATA, pid, addr, 0); + if (errno) break; + switch (val) { + case DT_NULL: done = 1; break; + case DT_DEBUG: + // point to the r_debug struct -- see link.h + DebugInfo = (Elf32_Addr) ptrace(PTRACE_PEEKDATA, pid, addr + 4, 0); + // point to the head of the link_map chain. + DebugInfo = (Elf32_Addr) ptrace(PTRACE_PEEKDATA, pid, DebugInfo + 4, 0); + break; + } + } + if (errno) { + perror("pstack"); + quit("failed to read target."); + } +} + +static void resolveSymbols(Symbols syms, int offset) +{ + Elf32_Sym *sym; + int i; + + syms->baseAddr = offset; + + for (i = 0, sym = syms->symbols; i < syms->nsyms; i++, sym++) { + if (sym->st_shndx && sym->st_shndx < syms->noffsets) { + sym->st_value += offset; + } + } +} + +static void loadString(int pid, int addr, char *dp, int bytes) +{ + long *lp = (long *) dp, nr; + + memset(dp, 0, bytes); + errno = 0; + + addr = ptrace(PTRACE_PEEKDATA, pid, addr, 0); + + for (nr = 0, errno = 0; !errno && bytes > 4 && strlen(dp) == nr; + addr += 4, bytes -= 4, nr += 4) { + *lp++ = ptrace(PTRACE_PEEKDATA, pid, addr, 0); + } + + if (errno) { + perror("ptrace"); + quit("loadString failed."); + } +} + +#define OFFSET(f, s) ((int) ((char *) &(s).f - (char *) &(s))) +static void readLinkMap(int pid, Elf32_Addr base, + struct link_map *lm, char *name, int namelen) +{ + errno = 0; + + /* base address */ + lm->l_addr = (Elf32_Addr) ptrace(PTRACE_PEEKDATA, pid, + base + OFFSET(l_addr, *lm), 0); + /* next element of link map chain */ + if (!errno) + lm->l_next = (struct link_map *) ptrace(PTRACE_PEEKDATA, pid, + base + OFFSET(l_next, *lm), 0); + if (errno) { + perror("ptrace"); + quit("can't read target."); + } + + loadString(pid, base + OFFSET(l_name, *lm), name, namelen); +} + +static void loadSymbols(int pid) +{ + char buf[256]; + Symbols syms; + struct link_map lm; + + sprintf(buf, "/proc/%d/exe", pid); + if (!(syms = loadSyms(buf))) { + fputs("(No symbols found)\n", stdout); + return; + } + + readDynoData(syms, pid); + readLinkMap(pid, DebugInfo, &lm, buf, sizeof(buf)); + + for ( ; lm.l_next; ) { + readLinkMap(pid, (Elf32_Addr) lm.l_next, &lm, buf, sizeof(buf)); + if (!(syms = loadSyms(buf))) { + printf("(No symbols found in %s)\n", buf); + continue; + } + resolveSymbols(syms, lm.l_addr); + if (!threads.found) checkForThreads(syms, pid); + } +} + +/* ------------------------------ */ + +static void print_pc(Elf32_Addr addr) +{ + Elf32_Sym *sym; + Symbols syms; + + findCodeAddress(addr, &sym, &syms); + + if (!sym) + printf("0x%08lx: ????", (unsigned long) addr); + else if (sym->st_value < addr) + printf("0x%08lx: %s + 0x%x", (unsigned long) addr, + &syms->strings[sym->st_name], addr - sym->st_value); + else + printf("0x%08lx: %s", (unsigned long) addr, &syms->strings[sym->st_name]); +} + +/* ------------------------------ */ + +#define MAXARGS 6 + +static int crawl(int pid) +{ + unsigned long pc, fp, nextfp, nargs, i, arg; + + errno = 0; + fp = -1; + + pc = ptrace(PTRACE_PEEKUSER, pid, EIP * 4, 0); + if (!errno) + fp = ptrace(PTRACE_PEEKUSER, pid, EBP * 4, 0); + + if (!errno) { + print_pc(pc); + for ( ; !errno && fp; ) { + nextfp = ptrace(PTRACE_PEEKDATA, pid, fp, 0); + if (errno) break; + + nargs = (nextfp - fp - 8) / 4; + if (nargs > MAXARGS) nargs = MAXARGS; + if (nargs > 0) { + fputs(" (", stdout); + for (i = 1; i <= nargs; i++) { + arg = ptrace(PTRACE_PEEKDATA, pid, fp + 4 * (i + 1), 0); + if (errno) break; + printf("%lx", arg); + if (i < nargs) fputs(", ", stdout); + } + fputc(')', stdout); + nargs = nextfp - fp - 8 - (4 * nargs); + if (!errno && nargs > 0) printf(" + %lx\n", nargs); + else fputc('\n', stdout); + } else fputc('\n', stdout); + + if (errno || !nextfp) break; + pc = ptrace(PTRACE_PEEKDATA, pid, fp + 4, 0); + fp = nextfp; + if (errno) break; + print_pc(pc); + } + } + + if (errno) perror("crawl"); + return errno; +} + +/* ------------------------------ */ + +static char cmd[128]; + +static char *cmdLine(int pid) +{ + int fd, len, i; + + fd = -1; + sprintf(cmd, "/proc/%d/cmdline", pid); + if ((fd = open(cmd, O_RDONLY)) >= 0 && + (len = read(fd, cmd, sizeof(cmd))) > 0) { + for (i = 0; i < len; i++) if (!cmd[i]) cmd[i] = ' '; + for ( ; len > 0 && cmd[len - 1] <= ' '; len--); + cmd[len] = 0; + if (len >= sizeof(cmd) - 4) + strcpy(&cmd[sizeof(cmd) - 4], "..."); + } + if (fd < 0 || len <= 0) strcpy(cmd, "(command line?)"); + if (fd >= 0) close(fd); + + return cmd; +} + +int main(int argc, char **argv) +{ + int i; + + /* Arrange to detach if we get an unexpected signal. This prevents + threads from being left in a suspended state if (for example) we + try to get a stack trace from a threaded process which has + been stripped. */ + for (i = 0; i < NSIG; i++) + if (i != SIGCHLD) + signal (i, handle_signal); + + for (argc--, argv++; argc > 0; argc--, argv++) { + thePid = atoi(*argv); + if (!thePid || thePid == getpid()) { + fprintf(stderr, "Invalid PID %d\n", thePid); + continue; + } + + if (attach(thePid) != 0) { + thePid = 0; + fprintf(stderr, "Could not attach to target.\n"); + } else { + printf("\n%d: %s\n", thePid, cmdLine(thePid)); + loadSymbols(thePid); + if (threads.found) { + for (i = 0; i < threads.npids; i++) { + if (threads.attached[i]) { + printf("----- Thread %d -----\n", threads.pids[i]); + if (crawl(threads.pids[i]) != 0) + fprintf(stderr, "Error tracing through thread %d\n", + threads.pids[i]); + } + } + } else if (crawl(thePid) != 0) + fprintf(stderr, "Error tracing through process %d\n", thePid); + } + + detachall(); + resetData(); + } + + exit(0); +} diff --git a/pstack.spec b/pstack.spec new file mode 100644 index 0000000..28d5740 --- /dev/null +++ b/pstack.spec @@ -0,0 +1,57 @@ +Summary: Display stack trace of a running process +Name: pstack +Version: 1.2 +Release: 3 +Copyright: GPL +Group: Development/Debuggers +Source: %{name}-%{version}.tar.gz +BuildRoot: %{_tmppath}/%{name}-root +ExclusiveArch: %{ix86} + +%description +pstack dumps a stack trace for a process, given the pid of that +process. If the process named is part of a thread group, then all the threads +in the group are traced. + +%prep +%setup -q + +%build +make + +%install +rm -rf $RPM_BUILD_ROOT +make install BINDIR=%{buildroot}%{_bindir} MANDIR=%{buildroot}%{_mandir} + +%clean +rm -rf $RPM_BUILD_ROOT + +%files +%defattr(-,root,root) +%doc COPYING README VERSION +%{_bindir}/pstack +%{_mandir}/man1/* + +%changelog +* Wed Nov 12 2003 Roland McGrath 1.2-3 +- updated linuxthreads support for newer linuxthreads internals (#107305) +- avoid buffer overflow in symbol printing (#109642) + +* Thu Sep 18 2003 Jakub Jelinek 1.1-7 +- don't crash if one of shared libraries has stripped .symtab/.strtab + (#98162) + +* Mon Feb 24 2003 Elliot Lee +- rebuilt + +* Sat Feb 22 2003 Jakub Jelinek +- rebuilt + +* Fri Jun 21 2002 Tim Powers +- automated rebuild + +* Tue May 28 2002 Jakub Jelinek +- build on x86 only + +* Mon Feb 25 2002 Preston Brown +- initial packaging