sys/ddb/db_ps.c

   1 /*-
   2  * Copyright (c) 1993 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sys/ddb/db_ps.c,v 1.20 1999/08/28 00:41:09 peter Exp $
  30  */
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/proc.h>
  34 #include <sys/cons.h>
  35
  36 #include <ddb/ddb.h>
  37
  38 static void db_dump_td_tokens(thread_t td);
  39
  40 void
  41 db_ps(db_expr_t dummy1, boolean_t dummy2, db_expr_t dummy3, char *dummy4)
  42 {
  43         int np;
  44         int cpuidx;
  45         int nl = 0;
  46         volatile struct proc *p, *pp;
  47         struct lwp *lp;
  48
  49         np = nprocs;
  50
  51         if (allproc.lh_first != NULL)
  52                 p = allproc.lh_first;
  53         else
  54                 p = &proc0;
  55         lp = FIRST_LWP_IN_PROC(__DEVOLATILE(struct proc *, p));
  56
  57         if (db_more(&nl) < 0)
  58             return;
  59         db_printf("  pid      lwp  uid  ppid  pgrp  pflags lflags stat  wmesg    wchan cmd\n");
  60         for (;;) {
  61                 while (lp == NULL) {
  62                         --np;
  63                         p = p->p_list.le_next;
  64                         if (p == NULL && np > 0)
  65                                 p = zombproc.lh_first;
  66                         if (p == NULL)
  67                                 break;
  68                         lp = FIRST_LWP_IN_PROC(__DEVOLATILE(struct proc *, p));
  69                 }
  70                 /*
  71                  * XXX just take 20 for now...
  72                  */
  73                 if (db_more(&nl) < 0)
  74                         return;
  75                 if (p == NULL) {
  76                         kprintf("oops, ran out of processes early!\n");
  77                         break;
  78                 }
  79                 pp = p->p_pptr;
  80                 if (pp == NULL)
  81                         pp = p;
  82
  83                 db_printf("%5d %8p %4d %5d %5d %06x %06x  %d %d",
  84                     p->p_pid, (volatile void *)lp,
  85                     p->p_ucred ? p->p_ucred->cr_ruid : 0, pp->p_pid,
  86                     p->p_pgrp ? p->p_pgrp->pg_id : 0, p->p_flags,
  87                     lp->lwp_flags, p->p_stat, lp->lwp_stat);
  88                 if (lp->lwp_wchan) {
  89                         db_printf(" %6s %8p",
  90                                 (lp->lwp_wmesg ? lp->lwp_wmesg : "?"),
  91                                 lp->lwp_wchan);
  92                 } else {
  93                         db_printf("                 ");
  94                 }
  95                 db_printf(" %s\n", p->p_comm ? p->p_comm : "");
  96                 db_dump_td_tokens(lp->lwp_thread);
  97
  98                 lp = lwp_rb_tree_RB_NEXT(lp);
  99         }
 100
 101         /*
 102          * Dump running threads
 103          */
 104         for (cpuidx = 0; cpuidx < ncpus; ++cpuidx) {
 105             struct globaldata *gd = &CPU_prvspace[cpuidx].mdglobaldata.mi;
 106             thread_t td;
 107             int j;
 108
 109             if (db_more(&nl) < 0)
 110                 return;
 111             db_printf("cpu %d curthread %p reqflags %04x\n",
 112                     gd->gd_cpuid, gd->gd_curthread, gd->gd_reqflags);
 113             if (gd->gd_curthread && gd->gd_curthread->td_preempted) {
 114                     db_printf("       PREEMPTING THREAD %p\n",
 115                                 gd->gd_curthread->td_preempted);
 116             }
 117
 118             if (db_more(&nl) < 0)
 119                 return;
 120             db_printf("      INCOMING IPIQS:");
 121             for (j = 0; j < ncpus; ++j) {
 122                 lwkt_ipiq_t ip = globaldata_find(j)->gd_ipiq;
 123                 if (ip != NULL) {
 124                     ip = &ip[cpuidx];
 125                     if (ip->ip_windex != ip->ip_rindex)
 126                         db_printf(" cpu%d:%d", j, ip->ip_windex - ip->ip_rindex);
 127                 }
 128             }
 129             db_printf("\n");
 130
 131             if (db_more(&nl) < 0)
 132                 return;
 133             db_printf("  tdq     thread pid    flags pri/cs/mp        sp    wmesg wchan comm\n");
 134             TAILQ_FOREACH(td, &gd->gd_tdrunq, td_threadq) {
 135                 if (db_more(&nl) < 0)
 136                     return;
 137                 db_printf("  %p %3d %08x %2d/%02d %p %8.8s %p %s\n",
 138                     td,
 139                     (td->td_proc ? td->td_proc->p_pid : -1),
 140                     td->td_flags,
 141                     td->td_pri,
 142                     td->td_critcount,
 143                     td->td_sp,
 144                     td->td_wmesg ? td->td_wmesg : "-",
 145                     td->td_wchan,
 146                     td->td_proc ? td->td_proc->p_comm : td->td_comm);
 147                 if (td->td_preempted)
 148                     db_printf("  PREEMPTING THREAD %p\n", td->td_preempted);
 149                 db_dump_td_tokens(td);
 150             }
 151             if (db_more(&nl) < 0)
 152                 return;
 153             db_printf("\n");
 154             if (db_more(&nl) < 0)
 155                 return;
 156             db_printf("  tdq     thread pid    flags pri/cs/mp        sp    wmesg wchan comm\n");
 157             TAILQ_FOREACH(td, &gd->gd_tdallq, td_allq) {
 158                 if (td->td_flags & TDF_MARKER)
 159                     continue;
 160                 if (db_more(&nl) < 0)
 161                     return;
 162                 db_printf("  %3d %p %3d %08x %2d/%02d %p %8.8s %p %s\n",
 163                     np, td,
 164                     (td->td_proc ? td->td_proc->p_pid : -1),
 165                     td->td_flags,
 166                     td->td_pri,
 167                     td->td_critcount,
 168                     td->td_sp,
 169                     td->td_wmesg ? td->td_wmesg : "-",
 170                     td->td_wchan,
 171                     td->td_proc ? td->td_proc->p_comm : td->td_comm);
 172                 db_dump_td_tokens(td);
 173             }
 174         }
 175         if (db_more(&nl) < 0)
 176             return;
 177         db_printf("CURCPU %d CURTHREAD %p (%d)\n",
 178             mycpu->gd_cpuid,
 179             curthread,
 180             (curthread->td_proc ? curthread->td_proc->p_pid : -1));
 181         db_dump_td_tokens(curthread);
 182 }
 183
 184 static void
 185 db_dump_td_tokens(thread_t td)
 186 {
 187         lwkt_tokref_t ref;
 188         lwkt_token_t tok;
 189
 190         if (TD_TOKS_NOT_HELD(td))
 191                 return;
 192         db_printf("    TOKENS:");
 193         for (ref = &td->td_toks_base; ref < td->td_toks_stop; ++ref) {
 194                 tok = ref->tr_tok;
 195
 196                 db_printf(" %p[tok=%p", ref, ref->tr_tok);
 197                 if (tok->t_ref && td == tok->t_ref->tr_owner)
 198                     db_printf(",held");
 199                 db_printf("]");
 200         }
 201         db_printf("\n");
 202 }
 203