xref: /illumos-gate/usr/src/cmd/mdb/common/modules/ptm/ptm.c (revision 0c1b95bef39aa56a594619ae1fa17557c8a8b8ab)
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
pt_parse_flag(const ptflags_t ftable[],const char * arg,uint32_t * flag)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
pt_flag_usage(const ptflags_t ftable[])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
ptms_pr_qinfo(char * buf,size_t nbytes,struct pt_ttys * pt,char * peername,queue_t * peerq,char * procname)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
ptms(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)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
ptms_qinfo(const queue_t * q,char * buf,size_t nbytes,int ismaster)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
ptm_qinfo(const queue_t * q,char * buf,size_t nbytes)200 ptm_qinfo(const queue_t *q, char *buf, size_t nbytes)
201 {
202 	ptms_qinfo(q, buf, nbytes, 1);
203 }
204 
205 void
pts_qinfo(const queue_t * q,char * buf,size_t nbytes)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
ptms_walk_init(mdb_walk_state_t * wsp)212 ptms_walk_init(mdb_walk_state_t *wsp)
213 {
214 	size_t nslots;
215 
216 	if (wsp->walk_addr != 0) {
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
ptms_walk_step(mdb_walk_state_t * wsp)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 == 0) {
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
ptms_walk_fini(mdb_walk_state_t * wsp)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 	.q_info = ptm_qinfo,
297 	.q_rnext = mdb_qrnext_default,
298 	.q_wnext = mdb_qwnext_default,
299 };
300 
301 static const mdb_qops_t pts_qops = {
302 	.q_info = pts_qinfo,
303 	.q_rnext = mdb_qrnext_default,
304 	.q_wnext = mdb_qwnext_default,
305 };
306 
307 static const mdb_modinfo_t modinfo = {
308 	MDB_API_VERSION, dcmds, walkers
309 };
310 
311 const mdb_modinfo_t *
_mdb_init(void)312 _mdb_init(void)
313 {
314 	GElf_Sym sym;
315 
316 	if (mdb_lookup_by_obj("ptm", "ptmwint", &sym) == 0)
317 		mdb_qops_install(&ptm_qops, (uintptr_t)sym.st_value);
318 	if (mdb_lookup_by_obj("pts", "ptswint", &sym) == 0)
319 		mdb_qops_install(&pts_qops, (uintptr_t)sym.st_value);
320 
321 	return (&modinfo);
322 }
323 
324 void
_mdb_fini(void)325 _mdb_fini(void)
326 {
327 	GElf_Sym sym;
328 
329 	if (mdb_lookup_by_obj("ptm", "ptmwint", &sym) == 0)
330 		mdb_qops_remove(&ptm_qops, (uintptr_t)sym.st_value);
331 	if (mdb_lookup_by_obj("pts", "ptswint", &sym) == 0)
332 		mdb_qops_remove(&pts_qops, (uintptr_t)sym.st_value);
333 }
334