/*      $NetBSD: db_trace.c,v 1.13 2013/10/19 14:03:04 skrll Exp $      */

/*      $OpenBSD: db_interface.c,v 1.16 2001/03/22 23:31:45 mickey Exp $        */

/*
 * Copyright (c) 1999-2003 Michael Shalayeff
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: db_trace.c,v 1.13 2013/10/19 14:03:04 skrll Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>

#include <machine/db_machdep.h>

#include <ddb/db_access.h>
#include <ddb/db_sym.h>
#include <ddb/db_interface.h>
#include <ddb/db_proc.h>

void
db_stack_trace_print(db_expr_t addr, bool have_addr, db_expr_t count,
    const char *modif, void (*pr)(const char *, ...))
{
        register_t *fp, pc, rp;
#if 0
        bool kernel_only = true;
#endif
        bool trace_thread = false;
        bool lwpaddr = false;
        db_sym_t sym;
        db_expr_t off;
        const char *name;
        const char *cp = modif;
        char c;

        if (count < 0)
                count = 65536;

        while ((c = *cp++) != 0) {
                if (c == 'a') {
                        lwpaddr = true;
                        trace_thread = true;
                }
                if (c == 't')
                        trace_thread = true;
#if 0
                if (c == 'u')
                        kernel_only = false;
#endif
        }

        if (!have_addr) {
                fp = (register_t *)ddb_regs.tf_r3;
                pc = ddb_regs.tf_iioq_head;
                rp = ddb_regs.tf_rp;
        } else {
                if (trace_thread) {
                        proc_t p;
                        lwp_t l;
                        pid_t pid;

                        if (lwpaddr) {
                                db_read_bytes(addr, sizeof(l), (char *)&l);
                                db_read_bytes((db_addr_t)l.l_proc, sizeof(p),
                                    (char *)&p);
                                (*pr)("trace: pid %d ", p.p_pid);
                        } else {
                                proc_t *pp;

                                pid = (pid_t)addr;
                                (*pr)("trace: pid %d ", pid);
                                pp = db_proc_find(pid);
                                if (pp == NULL) {
                                        (*pr)("not found\n");
                                        return;
                                }
                                db_read_bytes((db_addr_t)pp, sizeof(p),
                                    (char *)&p);
                                addr = (db_addr_t)p.p_lwps.lh_first;
                                db_read_bytes(addr, sizeof(l), (char *)&l);
                        }
                        (*pr)("lid %d ", l.l_lid);
#ifdef _KERNEL
                        if (l.l_proc == curproc && (lwp_t *)addr == curlwp) {
                                fp = (int *)ddb_regs.tf_r3;
                                pc = ddb_regs.tf_iioq_head;
                                rp = ddb_regs.tf_rp;
                        } else
#endif
                        {
                                struct pcb *pcb = lwp_getpcb(&l);
                                register_t sp;
                                /* cpu_switchto fp, and return point */
                                db_read_bytes((db_addr_t)&pcb->pcb_ksp,
                                    sizeof(sp), (char *)&sp);
                                fp = (register_t *)(sp -
                                    (HPPA_FRAME_SIZE + 16*4));
                                pc = 0;

                                db_read_bytes((db_addr_t)&fp[-5], sizeof(rp),
                                    (char *)&rp);
                        }
                        (*pr)("at %p\n", fp);
                } else {
                        pc = 0;
                        fp = (register_t *)addr;
                        db_read_bytes((db_addr_t)&fp[-5], sizeof(rp),
                            (char *)&rp);
                }
        }

        while (fp && count--) {
                register_t *newfp;
#ifdef DDB_DEBUG
                pr(">> %08x %08x %08x\t", fp, pc, rp);
#endif

                if (USERMODE(pc))
                        return;

                if (pc) {
                        sym = db_search_symbol(pc, DB_STGY_ANY, &off);
                        db_symbol_values (sym, &name, NULL);

                        pr("%s() at ", name);
                        db_printsym(pc, DB_STGY_PROC, pr);
                        pr("\n");
                }

                db_read_bytes((db_addr_t)&fp[0], sizeof(newfp), (char *)&newfp);

                /*
                 * if a terminal frame then report the trapframe and continue
                 * after it (if not the last one).
                 */
                if (!newfp) {
                        register_t scargs[5];
                        struct trapframe tf, *ktf;
                        int scoff;

                        /* Stack space for syscall args */
                        scoff = HPPA_FRAME_ROUND(HPPA_FRAME_SIZE +
                            HPPA_FRAME_MAXARGS);
                        ktf = (struct trapframe *)((char *)fp - scoff -
                            sizeof(tf));

                        db_read_bytes((db_addr_t)((char *)fp - scoff),
                             sizeof(scargs), (char *)&scargs);
                        db_read_bytes((db_addr_t)ktf, sizeof(tf), (char *)&tf);

                        if (tf.tf_flags & TFF_SYS)
                                pr("-- syscall #%d(%x, %x, %x, %x, ...) (%p)\n",
                                    tf.tf_t1, scargs[1], scargs[2],
                                    scargs[3], scargs[4], ktf);
                        else
                                pr("-- trap #%d (%p) %s\n", tf.tf_flags & 0x3f,
                                    ktf, (tf.tf_flags & T_USER)? " from user" :
                                    "");

                        if (!(tf.tf_flags & TFF_LAST)) {
                                fp = (register_t *)tf.tf_r3;
                                pc = tf.tf_iioq_head;
                                rp = tf.tf_rp;
                        } else {
                                pc = 0;
                                fp = 0;
                        }
                } else {
                        /* next frame */
                        fp = newfp;
                        pc = rp;
                        db_read_bytes((db_addr_t)&fp[-5], sizeof(rp),
                            (char *)&rp);
                }
        }

        if (count && pc) {
                db_printsym(pc, DB_STGY_XTRN, pr);
                pr(":\n");
        }
}