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