db_xxx.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: db_xxx.c,v 1.40 2006/11/16 01:32:44 christos Exp $     */
    2 
    3 /*
    4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      from: kern_proc.c       8.4 (Berkeley) 1/4/94
   32  */
   33 
   34 /*
   35  * Miscellaneous DDB functions that are intimate (xxx) with various
   36  * data structures and functions used by the kernel (proc, callout).
   37  */
   38 
   39 #include "opt_kgdb.h"
   40 
   41 #include <sys/cdefs.h>
   42 __KERNEL_RCSID(0, "$NetBSD: db_xxx.c,v 1.40 2006/11/16 01:32:44 christos Exp $");
   43 
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/kernel.h>
   47 #include <sys/proc.h>
   48 #include <sys/msgbuf.h>
   49 
   50 #include <sys/callout.h>
   51 #include <sys/signalvar.h>
   52 #include <sys/resourcevar.h>
   53 #include <sys/pool.h>
   54 #include <sys/kauth.h>
   55 
   56 #include <machine/db_machdep.h>
   57 
   58 #include <ddb/db_access.h>
   59 #include <ddb/db_command.h>
   60 #include <ddb/db_interface.h>
   61 #include <ddb/db_lex.h>
   62 #include <ddb/db_output.h>
   63 #include <ddb/db_sym.h>
   64 #include <ddb/db_extern.h>
   65 #ifdef KGDB
   66 #include <sys/kgdb.h>
   67 #endif
   68 
   69 void
   70 db_kill_proc(db_expr_t addr, int haddr,
   71     db_expr_t count, const char *modif)
   72 {
   73         struct proc *p;
   74         db_expr_t pid, sig;
   75         int t;
   76 
   77         /* What pid? */
   78         if (!db_expression(&pid)) {
   79                 db_error("pid?\n");
   80                 /*NOTREACHED*/
   81         }
   82         /* What sig? */
   83         t = db_read_token();
   84         if (t == tCOMMA) {
   85                 if (!db_expression(&sig)) {
   86                         db_error("sig?\n");
   87                         /*NOTREACHED*/
   88                 }
   89         } else {
   90                 db_unread_token(t);
   91                 sig = 15;
   92         }
   93         if (db_read_token() != tEOL) {
   94                 db_error("?\n");
   95                 /*NOTREACHED*/
   96         }
   97 
   98         p = pfind((pid_t)pid);
   99         if (p == NULL) {
  100                 db_error("no such proc\n");
  101                 /*NOTREACHED*/
  102         }
  103         psignal(p, (int)sig);
  104 }
  105 
  106 #ifdef KGDB
  107 void
  108 db_kgdb_cmd(db_expr_t addr, int haddr,
  109     db_expr_t count, const char *modif)
  110 {
  111         kgdb_active++;
  112         kgdb_trap(db_trap_type, DDB_REGS);
  113         kgdb_active--;
  114 }
  115 #endif
  116 
  117 void
  118 db_show_all_procs(db_expr_t addr, int haddr,
  119     db_expr_t count, const char *modif)
  120 {
  121         int i;
  122 
  123         const char *mode;
  124         struct proc *p, *pp, *cp;
  125         struct lwp *l, *cl;
  126         struct timeval tv[2];
  127         const struct proclist_desc *pd;
  128 
  129         if (modif[0] == 0)
  130                 mode = "n";                     /* default == normal mode */
  131         else
  132                 mode = strchr("mawln", modif[0]);
  133 
  134         if (mode == NULL || *mode == 'm') {
  135                 db_printf("usage: show all procs [/a] [/l] [/n] [/w]\n");
  136                 db_printf("\t/a == show process address info\n");
  137                 db_printf("\t/l == show LWP info\n");
  138                 db_printf("\t/n == show normal process info [default]\n");
  139                 db_printf("\t/w == show process wait/emul info\n");
  140                 return;
  141         }
  142 
  143         switch (*mode) {
  144         case 'a':
  145                 db_printf(" PID       %10s %18s %18s %18s\n",
  146                     "COMMAND", "STRUCT PROC *", "UAREA *", "VMSPACE/VM_MAP");
  147                 break;
  148         case 'l':
  149                 db_printf(" PID        %4s S %9s %18s %18s %-12s\n",
  150                     "LID", "FLAGS", "STRUCT LWP *", "UAREA *", "WAIT");
  151                 break;
  152         case 'n':
  153                 db_printf(" PID       %8s %8s %10s S %7s %4s %16s %7s\n",
  154                     "PPID", "PGRP", "UID", "FLAGS", "LWPS", "COMMAND", "WAIT");
  155                 break;
  156         case 'w':
  157                 db_printf(" PID       %10s %8s %4s %5s %5s %-12s%s\n",
  158                     "COMMAND", "EMUL", "PRI", "UTIME", "STIME",
  159                     "WAIT-MSG", "WAIT-CHANNEL");
  160                 break;
  161         }
  162 
  163         /* XXX LOCKING XXX */
  164         pd = proclists;
  165         cp = curproc;
  166         cl = curlwp;
  167         for (pd = proclists; pd->pd_list != NULL; pd++) {
  168                 LIST_FOREACH(p, pd->pd_list, p_list) {
  169                         pp = p->p_pptr;
  170                         if (p->p_stat == 0) {
  171                                 continue;
  172                         }
  173                         l = LIST_FIRST(&p->p_lwps);
  174                         db_printf("%c%-10d", (cp == p ? '>' : ' '), p->p_pid);
  175 
  176                         switch (*mode) {
  177 
  178                         case 'a':
  179                                 db_printf("%10.10s %18p %18p %18p\n",
  180                                     p->p_comm, p,
  181                                     l != NULL ? l->l_addr : 0,
  182                                     p->p_vmspace);
  183                                 break;
  184                         case 'l':
  185                                  while (l != NULL) {
  186                                         db_printf("%c%4d %d %#9x %18p %18p %s\n",
  187                                             (cl == l ? '>' : ' '), l->l_lid,
  188                                             l->l_stat, l->l_flag, l,
  189                                             l->l_addr,
  190                                             (l->l_wchan && l->l_wmesg) ?
  191                                             l->l_wmesg : "");
  192 
  193                                         l = LIST_NEXT(l, l_sibling);
  194                                         if (l)
  195                                                 db_printf("%11s","");
  196                                 }
  197                                 break;
  198                         case 'n':
  199                                 db_printf("%8d %8d %10d %d %#7x %4d %16s %7.7s\n",
  200                                     pp ? pp->p_pid : -1, p->p_pgrp->pg_id,
  201                                     kauth_cred_getuid(p->p_cred), p->p_stat, p->p_flag,
  202                                     p->p_nlwps, p->p_comm,
  203                                     (p->p_nlwps != 1) ? "*" : (
  204                                     (l->l_wchan && l->l_wmesg) ?
  205                                     l->l_wmesg : ""));
  206                                 break;
  207 
  208                         case 'w':
  209                                 db_printf("%10s %8s %4d", p->p_comm,
  210                                     p->p_emul->e_name,
  211                                     (l != NULL) ? l->l_priority : -1);
  212                                 calcru(p, &tv[0], &tv[1], NULL);
  213                                 for (i = 0; i < 2; ++i) {
  214                                         db_printf("%4ld.%1ld",
  215                                             (long)tv[i].tv_sec,
  216                                             (long)tv[i].tv_usec/100000);
  217                                 }
  218                                 if (p->p_nlwps == 1) {
  219                                 if (l->l_wchan && l->l_wmesg) {
  220                                         db_printf(" %-12s", l->l_wmesg);
  221                                         db_printsym(
  222                                             (db_expr_t)(intptr_t)l->l_wchan,
  223                                             DB_STGY_XTRN, db_printf);
  224                                 } } else {
  225                                         db_printf(" * ");
  226                                 }
  227                                 db_printf("\n");
  228                                 break;
  229 
  230                         }
  231                 }
  232         }
  233 }
  234 
  235 void
  236 db_show_all_pools(db_expr_t addr, int haddr,
  237     db_expr_t count, const char *modif)
  238 {
  239 
  240         pool_printall(modif, db_printf);
  241 }
  242 
  243 void
  244 db_dmesg(db_expr_t addr, int haddr, db_expr_t count,
  245     const char *modif)
  246 {
  247         struct kern_msgbuf *mbp;
  248         db_expr_t print;
  249         int ch, newl, skip, i;
  250         char *p, *bufdata;
  251 
  252         if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) {
  253                 db_printf("message buffer not available\n");
  254                 return;
  255         }
  256 
  257         mbp = msgbufp;
  258         bufdata = &mbp->msg_bufc[0];
  259 
  260         if (haddr && addr < mbp->msg_bufs)
  261                 print = addr;
  262         else
  263                 print = mbp->msg_bufs;
  264 
  265         for (newl = skip = i = 0, p = bufdata + mbp->msg_bufx;
  266             i < mbp->msg_bufs; i++, p++) {
  267                 if (p == bufdata + mbp->msg_bufs)
  268                         p = bufdata;
  269                 if (i < mbp->msg_bufs - print)
  270                         continue;
  271                 ch = *p;
  272                 /* Skip "\n<.*>" syslog sequences. */
  273                 if (skip) {
  274                         if (ch == '>')
  275                                 newl = skip = 0;
  276                         continue;
  277                 }
  278                 if (newl && ch == '<') {
  279                         skip = 1;
  280                         continue;
  281                 }
  282                 if (ch == '\0')
  283                         continue;
  284                 newl = ch == '\n';
  285                 db_printf("%c", ch);
  286         }
  287         if (!newl)
  288                 db_printf("\n");
  289 }
  290 
  291 #ifdef __HAVE_BIGENDIAN_BITOPS
  292 #define RQMASK(n) (0x80000000 >> (n))
  293 #else
  294 #define RQMASK(n) (0x00000001 << (n))
  295 #endif
  296 
  297 void
  298 db_show_sched_qs(db_expr_t addr, int haddr,
  299     db_expr_t count, const char *modif)
  300 {
  301         struct prochd *ph;
  302         struct lwp *l;
  303         int i, first;
  304 
  305         for (i = 0; i < RUNQUE_NQS; i++)
  306         {
  307                 first = 1;
  308                 ph = &sched_qs[i];
  309                 for (l = ph->ph_link; l != (void *)ph; l = l->l_forw) {
  310                         if (first) {
  311                                 db_printf("%c%d",
  312                                     (sched_whichqs & RQMASK(i))
  313                                     ? ' ' : '!', i);
  314                                 first = 0;
  315                         }
  316                         db_printf("\t%d.%d (%s) pri=%d usrpri=%d\n",
  317                             l->l_proc->p_pid,
  318                             l->l_lid, l->l_proc->p_comm,
  319                             (int)l->l_priority, (int)l->l_usrpri);
  320                 }
  321         }
  322 }
Cache object: 1a0dc94a378a93a002beb566e6ab05ae
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/ddb/db_xxx.c

FreeBSD/Linux Kernel Cross Reference
sys/ddb/db_xxx.c
