usr/src/cmd/mdb/common/modules/ptm/ptm.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  * Copyright 2017 Joyent, Inc.
  26  */
  27
  28 #include <mdb/mdb_modapi.h>
  29 #include <mdb/mdb_ks.h>
  30
  31 #include <sys/types.h>
  32 #include <sys/strsubr.h>
  33 #include <sys/ptms.h>
  34
  35 typedef struct pt_flags {
  36         const char *pt_name;
  37         const char *pt_descr;
  38 } ptflags_t;
  39
  40 static const struct pt_flags pf[] = {
  41         { "PTLOCK",             "Master/slave pair is locked" },
  42         { "PTMOPEN",            "Master side is open" },
  43         { "PTSOPEN",            "Slave side is open" },
  44         { "PTSTTY",             "Slave side is tty" },
  45         { NULL },
  46 };
  47
  48 static int
  49 pt_parse_flag(const ptflags_t ftable[],  const char *arg, uint32_t *flag)
  50 {
  51         int i;
  52
  53         for (i = 0; ftable[i].pt_name != NULL; i++) {
  54                 if (strcasecmp(arg, ftable[i].pt_name) == 0) {
  55                         *flag |= (1 << i);
  56                         return (0);
  57                 }
  58         }
  59
  60         return (-1);
  61 }
  62
  63 static void
  64 pt_flag_usage(const ptflags_t ftable[])
  65 {
  66         int i;
  67
  68         for (i = 0; ftable[i].pt_name != NULL; i++)
  69                 mdb_printf("%12s %s\n",
  70                     ftable[i].pt_name, ftable[i].pt_descr);
  71 }
  72
  73
  74
  75 static void
  76 ptms_pr_qinfo(char *buf, size_t nbytes, struct pt_ttys *pt, char *peername,
  77     queue_t *peerq, char *procname)
  78 {
  79         (void) mdb_snprintf(buf, nbytes,
  80             "pts/%d:%s: %p\nprocess:    %d(%s)",
  81             pt->pt_minor, peername, peerq, pt->pt_pid, procname);
  82 }
  83
  84 static int
  85 ptms(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
  86 {
  87         const int PT_FLGDELT = (int)(sizeof (uintptr_t) * 2 + 5);
  88
  89         struct pt_ttys pt;
  90         char c[MAXCOMLEN + 1];
  91         const char *flag = NULL, *not_flag = NULL;
  92         proc_t p;
  93         uint_t verbose = FALSE;
  94         uint32_t mask = 0, not_mask = 0;
  95
  96         if (!(flags & DCMD_ADDRSPEC))
  97                 return (mdb_walk_dcmd("ptms", "ptms", argc, argv));
  98
  99         if (mdb_getopts(argc, argv,
 100             'v', MDB_OPT_SETBITS, TRUE, &verbose,
 101             'f', MDB_OPT_STR, &flag,
 102             'F', MDB_OPT_STR, &not_flag, NULL) != argc)
 103                 return (DCMD_USAGE);
 104
 105         if (DCMD_HDRSPEC(flags) && flag == NULL && not_flag == NULL) {
 106                 (void) mdb_printf("%?-s %s %s %?-s %?-s %3s %-6s %s\n",
 107                     "ADDR", "PTY", "FL", "MASTERQ", "SLAVEQ",
 108                     "ZID", "PID", "PROC");
 109         }
 110
 111         if (flag != NULL && pt_parse_flag(pf, flag, &mask) == -1) {
 112                 mdb_warn("unrecognized pty flag '%s'\n", flag);
 113                 pt_flag_usage(pf);
 114                 return (DCMD_USAGE);
 115         }
 116
 117         if (not_flag != NULL && pt_parse_flag(pf, not_flag, &not_mask) == -1) {
 118                 mdb_warn("unrecognized queue flag '%s'\n", flag);
 119                 pt_flag_usage(pf);
 120                 return (DCMD_USAGE);
 121         }
 122
 123         if (mdb_vread(&pt, sizeof (pt), addr) == -1) {
 124                 mdb_warn("failed to read pty structure");
 125                 return (DCMD_ERR);
 126         }
 127
 128         if (mask != 0 && !(pt.pt_state & mask))
 129                 return (DCMD_OK);
 130
 131         if (not_mask != 0 && (pt.pt_state & not_mask))
 132                 return (DCMD_OK);
 133
 134         /*
 135          * Options are specified for filtering, so If any option is specified on
 136          * the command line, just print address and exit.
 137          */
 138         if (flag != NULL || not_flag != NULL) {
 139                 mdb_printf("%0?p\n", addr);
 140                 return (DCMD_OK);
 141         }
 142
 143         if (pt.pt_pid != 0) {
 144                 if (mdb_pid2proc(pt.pt_pid, &p) == 0)
 145                         (void) strcpy(c, "<defunct>");
 146                 else
 147                         (void) strcpy(c, p.p_user.u_comm);
 148         } else
 149                 (void) strcpy(c, "<unknown>");
 150
 151         (void) mdb_printf("%0?p %3d %2x %0?p %0?p %3d %6d %s\n",
 152             addr, pt.pt_minor, pt.pt_state, pt.ptm_rdq, pt.pts_rdq,
 153             pt.pt_zoneid, pt.pt_pid, c);
 154
 155         if (verbose) {
 156                 int i, arm = 0;
 157
 158                 for (i = 0; pf[i].pt_name != NULL; i++) {
 159                         if (!(pt.pt_state & (1 << i)))
 160                                 continue;
 161                         if (!arm) {
 162                                 mdb_printf("%*s|\n%*s+-->  ",
 163                                     PT_FLGDELT, "", PT_FLGDELT, "");
 164                                 arm = 1;
 165                         } else
 166                                 mdb_printf("%*s      ", PT_FLGDELT, "");
 167
 168                         mdb_printf("%-12s %s\n",
 169                             pf[i].pt_name, pf[i].pt_descr);
 170                 }
 171         }
 172
 173         return (DCMD_OK);
 174 }
 175
 176 static void
 177 ptms_qinfo(const queue_t *q, char *buf, size_t nbytes, int ismaster)
 178 {
 179         char c[MAXCOMLEN + 1];
 180         struct pt_ttys pt;
 181         proc_t p;
 182
 183         (void) mdb_vread(&pt, sizeof (pt), (uintptr_t)q->q_ptr);
 184
 185         if (pt.pt_pid != 0) {
 186                 if (mdb_pid2proc(pt.pt_pid, &p) == 0)
 187                         (void) strcpy(c, "<defunct>");
 188                 else
 189                         (void) strcpy(c, p.p_user.u_comm);
 190         } else
 191                 (void) strcpy(c, "<unknown>");
 192
 193         if (ismaster)
 194                 ptms_pr_qinfo(buf, nbytes, &pt, "slave", pt.pts_rdq, c);
 195         else
 196                 ptms_pr_qinfo(buf, nbytes, &pt, "master", pt.ptm_rdq, c);
 197 }
 198
 199 void
 200 ptm_qinfo(const queue_t *q, char *buf, size_t nbytes)
 201 {
 202         ptms_qinfo(q, buf, nbytes, 1);
 203 }
 204
 205 void
 206 pts_qinfo(const queue_t *q, char *buf, size_t nbytes)
 207 {
 208         ptms_qinfo(q, buf, nbytes, 0);
 209 }
 210
 211 static int
 212 ptms_walk_init(mdb_walk_state_t *wsp)
 213 {
 214         size_t nslots;
 215
 216         if (wsp->walk_addr != (uintptr_t)NULL) {
 217                 mdb_warn("ptms supports only global walks");
 218                 return (WALK_ERR);
 219         }
 220
 221         if (mdb_readvar(&wsp->walk_addr, "ptms_slots") == -1) {
 222                 mdb_warn("failed to read 'ptms_slots'");
 223                 return (WALK_ERR);
 224         }
 225
 226         if (mdb_readvar(&nslots, "ptms_nslots") == -1) {
 227                 mdb_warn("failed to read 'ptms_nslots'");
 228                 return (WALK_ERR);
 229         }
 230
 231         /*
 232          * We remember the pointer value at the end of the array.  When
 233          * the walk gets there, we're done.
 234          */
 235         wsp->walk_arg = (((struct pt_ttys **)wsp->walk_addr) + (nslots - 1));
 236         wsp->walk_data = mdb_alloc(sizeof (struct pt_ttys), UM_SLEEP);
 237
 238         return (WALK_NEXT);
 239 }
 240
 241 static int
 242 ptms_walk_step(mdb_walk_state_t *wsp)
 243 {
 244         int status;
 245         uintptr_t ptr;
 246
 247         if (wsp->walk_addr > (uintptr_t)wsp->walk_arg)
 248                 return (WALK_DONE);
 249
 250         if (mdb_vread(&ptr, sizeof (struct pt_ttys *), wsp->walk_addr) !=
 251             (sizeof (struct pt_ttys *))) {
 252                 mdb_warn("failed to read pt_ttys* at %p", wsp->walk_addr);
 253                 return (WALK_DONE);
 254         }
 255
 256         if (ptr == (uintptr_t)NULL) {
 257                 wsp->walk_addr += sizeof (uintptr_t);
 258                 return (WALK_NEXT);
 259         }
 260
 261         if (mdb_vread(wsp->walk_data, sizeof (struct pt_ttys), ptr) !=
 262             sizeof (struct pt_ttys)) {
 263                 mdb_warn("failed to read pt_ttys at %p", ptr);
 264                 return (WALK_DONE);
 265         }
 266
 267         status = wsp->walk_callback(ptr, wsp->walk_data, wsp->walk_cbdata);
 268         wsp->walk_addr += sizeof (uintptr_t);
 269
 270         return (status);
 271 }
 272
 273 static void
 274 ptms_walk_fini(mdb_walk_state_t *wsp)
 275 {
 276         mdb_free(wsp->walk_data, sizeof (struct pt_ttys));
 277 }
 278
 279 static const mdb_dcmd_t dcmds[] = {
 280         { "ptms", "?[-v] [-f flag] [-F flag]",
 281             "print pseudo-terminal information", ptms },
 282         { "pty", "?[-v] [-f flag] [-F flag]",
 283             "print pseudo-terminal information (alias of ::ptms", ptms },
 284         { NULL }
 285 };
 286
 287 static const mdb_walker_t walkers[] = {
 288         { "ptms", "walk list of pseudo-tty's",
 289             ptms_walk_init, ptms_walk_step, ptms_walk_fini },
 290         { "pty", "walk list of pseudo-tty's (alias of ::walk ptms)",
 291             ptms_walk_init, ptms_walk_step, ptms_walk_fini },
 292         { NULL }
 293 };
 294
 295 static const mdb_qops_t ptm_qops = {
 296         ptm_qinfo, mdb_qrnext_default, mdb_qwnext_default
 297 };
 298
 299 static const mdb_qops_t pts_qops = {
 300         pts_qinfo, mdb_qrnext_default, mdb_qwnext_default
 301 };
 302
 303 static const mdb_modinfo_t modinfo = {
 304         MDB_API_VERSION, dcmds, walkers
 305 };
 306
 307 const mdb_modinfo_t *
 308 _mdb_init(void)
 309 {
 310         GElf_Sym sym;
 311
 312         if (mdb_lookup_by_obj("ptm", "ptmwint", &sym) == 0)
 313                 mdb_qops_install(&ptm_qops, (uintptr_t)sym.st_value);
 314         if (mdb_lookup_by_obj("pts", "ptswint", &sym) == 0)
 315                 mdb_qops_install(&pts_qops, (uintptr_t)sym.st_value);
 316
 317         return (&modinfo);
 318 }
 319
 320 void
 321 _mdb_fini(void)
 322 {
 323         GElf_Sym sym;
 324
 325         if (mdb_lookup_by_obj("ptm", "ptmwint", &sym) == 0)
 326                 mdb_qops_remove(&ptm_qops, (uintptr_t)sym.st_value);
 327         if (mdb_lookup_by_obj("pts", "ptswint", &sym) == 0)
 328                 mdb_qops_remove(&pts_qops, (uintptr_t)sym.st_value);
 329 }