xref: /titanic_41/usr/src/cmd/mdb/common/modules/ipc/ipc.c (revision eb9fe4ca958d89d923b240585deb93dd52e24335)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <mdb/mdb_modapi.h>
27 #include <mdb/mdb_ks.h>
28 
29 #include <sys/types.h>
30 #include <sys/mman.h>
31 #include <sys/project.h>
32 #include <sys/ipc_impl.h>
33 #include <sys/shm_impl.h>
34 #include <sys/sem_impl.h>
35 #include <sys/msg_impl.h>
36 
37 #include <vm/anon.h>
38 
39 #define	CMN_HDR_START	"%<u>"
40 #define	CMN_HDR_END	"%</u>\n"
41 #define	CMN_INDENT	(4)
42 #define	CMN_INACTIVE	"%s facility inactive.\n"
43 
44 /*
45  * Bitmap data for page protection flags suitable for use with %b.
46  */
47 const mdb_bitmask_t prot_flag_bits[] = {
48 	{ "PROT_READ", PROT_READ, PROT_READ },
49 	{ "PROT_WRITE", PROT_WRITE, PROT_WRITE },
50 	{ "PROT_EXEC", PROT_EXEC, PROT_EXEC },
51 	{ "PROT_USER", PROT_USER, PROT_USER },
52 	{ NULL, 0, 0 }
53 };
54 
55 static void
printtime_nice(const char * str,time_t time)56 printtime_nice(const char *str, time_t time)
57 {
58 	if (time)
59 		mdb_printf("%s%Y\n", str, time);
60 	else
61 		mdb_printf("%sn/a\n", str);
62 }
63 
64 /*
65  * Print header common to all IPC types.
66  */
67 static void
ipcperm_header()68 ipcperm_header()
69 {
70 	mdb_printf(CMN_HDR_START "%?s %5s %5s %8s %5s %5s %6s %5s %5s %5s %5s"
71 	    CMN_HDR_END, "ADDR", "REF", "ID", "KEY", "MODE", "PRJID", "ZONEID",
72 	    "OWNER", "GROUP", "CREAT", "CGRP");
73 }
74 
75 /*
76  * Print data common to all IPC types.
77  */
78 static void
ipcperm_print(uintptr_t addr,kipc_perm_t * perm)79 ipcperm_print(uintptr_t addr, kipc_perm_t *perm)
80 {
81 	kproject_t proj;
82 	int res;
83 
84 	res = mdb_vread(&proj, sizeof (kproject_t), (uintptr_t)perm->ipc_proj);
85 
86 	if (res == -1)
87 		mdb_warn("failed to read kproject_t at %#p", perm->ipc_proj);
88 
89 	mdb_printf("%0?p %5d %5d", addr, perm->ipc_ref, perm->ipc_id);
90 	if (perm->ipc_key)
91 		mdb_printf(" %8x", perm->ipc_key);
92 	else
93 		mdb_printf(" %8s", "private");
94 	mdb_printf(" %5#o", perm->ipc_mode & 07777);
95 	if (res == -1)
96 		mdb_printf(" %5s %5s", "<flt>", "<flt>");
97 	else
98 		mdb_printf(" %5d %6d", proj.kpj_id, proj.kpj_zoneid);
99 	mdb_printf(" %5d %5d %5d %5d\n", perm->ipc_uid, perm->ipc_gid,
100 	    perm->ipc_cuid, perm->ipc_cgid);
101 
102 }
103 
104 /*ARGSUSED*/
105 static int
ipcperm(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)106 ipcperm(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
107 {
108 	kipc_perm_t perm;
109 
110 	if (!(flags & DCMD_ADDRSPEC))
111 		return (DCMD_USAGE);
112 
113 	if (DCMD_HDRSPEC(flags))
114 		ipcperm_header();
115 
116 	if (mdb_vread(&perm, sizeof (kipc_perm_t), addr) == -1) {
117 		mdb_warn("failed to read kipc_perm_t at %#lx", addr);
118 		return (DCMD_ERR);
119 	}
120 
121 	ipcperm_print(addr, &perm);
122 	return (DCMD_OK);
123 }
124 
125 
126 #define	MSG_SND_SIZE 0x1
127 static int
msgq_check_for_waiters(list_t * walk_this,int min,int max,int copy_wait,uintptr_t addr,int flag)128 msgq_check_for_waiters(list_t *walk_this, int min, int max,
129 	int copy_wait, uintptr_t addr, int flag)
130 
131 {
132 	int found = 0;
133 	int ii;
134 	msgq_wakeup_t *walker, next;
135 	uintptr_t head;
136 
137 	for (ii = min; ii < max; ii++) {
138 		head = ((ulong_t)addr) + sizeof (list_t)*ii +
139 		    sizeof (list_node_t);
140 		if (head != (uintptr_t)walk_this[ii].list_head.list_next) {
141 			walker =
142 			    (msgq_wakeup_t *)walk_this[ii].list_head.list_next;
143 			while (head != (uintptr_t)walker) {
144 				if (mdb_vread(&next, sizeof (msgq_wakeup_t),
145 				    (uintptr_t)walker) == -1) {
146 					mdb_warn(
147 					    "Failed to read message queue\n");
148 					return (found);
149 				}
150 
151 				if (flag & MSG_SND_SIZE) {
152 					mdb_printf("%15lx\t%6d\t%15lx\t%15d\n",
153 					    next.msgw_thrd, next.msgw_type,
154 					    walker + (uintptr_t)
155 					    OFFSETOF(msgq_wakeup_t,
156 					    msgw_wake_cv), next.msgw_snd_size);
157 				} else {
158 					mdb_printf("%15lx\t%6d\t%15lx\t%15s\n",
159 					    next.msgw_thrd, next.msgw_type,
160 					    walker + (uintptr_t)
161 					    OFFSETOF(msgq_wakeup_t,
162 					    msgw_wake_cv),
163 					    (copy_wait ? "yes":"no"));
164 				}
165 				found++;
166 				walker =
167 				    (msgq_wakeup_t *)next.msgw_list.list_next;
168 			}
169 		}
170 	}
171 	return (found);
172 }
173 
174 static void
msq_print(kmsqid_t * msqid,uintptr_t addr)175 msq_print(kmsqid_t *msqid, uintptr_t addr)
176 {
177 	int	total = 0;
178 
179 	mdb_printf("&list: %-?p\n", addr + OFFSETOF(kmsqid_t, msg_list));
180 	mdb_printf("cbytes: 0t%lu    qnum: 0t%lu    qbytes: 0t%lu"
181 	    "    qmax: 0t%lu\n", msqid->msg_cbytes, msqid->msg_qnum,
182 	    msqid->msg_qbytes, msqid->msg_qmax);
183 	mdb_printf("lspid: 0t%d    lrpid: 0t%d\n",
184 	    (int)msqid->msg_lspid, (int)msqid->msg_lrpid);
185 	printtime_nice("stime: ", msqid->msg_stime);
186 	printtime_nice("rtime: ", msqid->msg_rtime);
187 	printtime_nice("ctime: ", msqid->msg_ctime);
188 	mdb_printf("snd_cnt: 0t%lld    snd_cv: %hd (%p)\n",
189 	    msqid->msg_snd_cnt, msqid->msg_snd_cv._opaque,
190 	    addr + (uintptr_t)OFFSETOF(kmsqid_t, msg_snd_cv));
191 	mdb_printf("Blocked recievers\n");
192 	mdb_printf("%15s\t%6s\t%15s\t%15s\n", "Thread Addr",
193 	    "Type", "cv addr", "copyout-wait?");
194 	total += msgq_check_for_waiters(&msqid->msg_cpy_block,
195 	    0, 1, 1, addr + OFFSETOF(kmsqid_t, msg_cpy_block), 0);
196 	total += msgq_check_for_waiters(msqid->msg_wait_snd_ngt,
197 	    0, MSG_MAX_QNUM + 1, 0,
198 	    addr + OFFSETOF(kmsqid_t, msg_wait_snd_ngt), 0);
199 	mdb_printf("Blocked senders\n");
200 	total += msgq_check_for_waiters(&msqid->msg_wait_rcv,
201 	    0, 1, 1, addr + OFFSETOF(kmsqid_t, msg_wait_rcv),
202 	    MSG_SND_SIZE);
203 	mdb_printf("%15s\t%6s\t%15s\t%15s\n", "Thread Addr",
204 	    "Type", "cv addr", "Msg Size");
205 	total += msgq_check_for_waiters(msqid->msg_wait_snd,
206 	    0, MSG_MAX_QNUM + 1, 0, addr + OFFSETOF(kmsqid_t,
207 	    msg_wait_snd), 0);
208 	mdb_printf("Total number of waiters: %d\n", total);
209 }
210 
211 
212 /*ARGSUSED1*/
213 static void
shm_print(kshmid_t * shmid,uintptr_t addr)214 shm_print(kshmid_t *shmid, uintptr_t addr)
215 {
216 	shmatt_t nattch;
217 
218 	nattch = shmid->shm_perm.ipc_ref - (IPC_FREE(&shmid->shm_perm) ? 0 : 1);
219 
220 	mdb_printf(CMN_HDR_START "%10s %?s %5s %7s %7s %7s %7s" CMN_HDR_END,
221 	    "SEGSZ", "AMP", "LKCNT", "LPID", "CPID", "NATTCH", "CNATTCH");
222 	mdb_printf("%10#lx %?p %5u %7d %7d %7lu %7lu\n",
223 	    shmid->shm_segsz, shmid->shm_amp, shmid->shm_lkcnt,
224 	    (int)shmid->shm_lpid, (int)shmid->shm_cpid, nattch,
225 	    shmid->shm_ismattch);
226 
227 	printtime_nice("atime: ", shmid->shm_atime);
228 	printtime_nice("dtime: ", shmid->shm_dtime);
229 	printtime_nice("ctime: ", shmid->shm_ctime);
230 	mdb_printf("sptinfo: %-?p    sptseg: %-?p\n",
231 	    shmid->shm_sptinfo, shmid->shm_sptseg);
232 	mdb_printf("sptprot: <%lb>\n", shmid->shm_sptprot, prot_flag_bits);
233 }
234 
235 
236 /*ARGSUSED1*/
237 static void
sem_print(ksemid_t * semid,uintptr_t addr)238 sem_print(ksemid_t *semid, uintptr_t addr)
239 {
240 	mdb_printf("base: %-?p    nsems: 0t%u\n",
241 	    semid->sem_base, semid->sem_nsems);
242 	printtime_nice("otime: ", semid->sem_otime);
243 	printtime_nice("ctime: ", semid->sem_ctime);
244 	mdb_printf("binary: %s\n", semid->sem_binary ? "yes" : "no");
245 }
246 
247 typedef struct ipc_ops_vec {
248 	char	*iv_wcmd;	/* walker name		*/
249 	char	*iv_ocmd;	/* output dcmd		*/
250 	char	*iv_service;	/* service pointer	*/
251 	void	(*iv_print)(void *, uintptr_t); /* output callback */
252 	size_t	iv_idsize;
253 } ipc_ops_vec_t;
254 
255 ipc_ops_vec_t msq_ops_vec = {
256 	"msq",
257 	"kmsqid",
258 	"msq_svc",
259 	(void(*)(void *, uintptr_t))msq_print,
260 	sizeof (kmsqid_t)
261 };
262 
263 ipc_ops_vec_t shm_ops_vec = {
264 	"shm",
265 	"kshmid",
266 	"shm_svc",
267 	(void(*)(void *, uintptr_t))shm_print,
268 	sizeof (kshmid_t)
269 };
270 
271 ipc_ops_vec_t sem_ops_vec = {
272 	"sem",
273 	"ksemid",
274 	"sem_svc",
275 	(void(*)(void *, uintptr_t))sem_print,
276 	sizeof (ksemid_t)
277 };
278 
279 
280 /*
281  * Generic IPC data structure display code
282  */
283 static int
ds_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv,ipc_ops_vec_t * iv)284 ds_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
285     ipc_ops_vec_t *iv)
286 {
287 	void *iddata;
288 
289 	if (!(flags & DCMD_ADDRSPEC)) {
290 		uint_t oflags = 0;
291 
292 		if (mdb_getopts(argc, argv, 'l', MDB_OPT_SETBITS, 1, &oflags,
293 		    NULL) != argc)
294 			return (DCMD_USAGE);
295 
296 		if (mdb_walk_dcmd(iv->iv_wcmd, oflags ? iv->iv_ocmd : "ipcperm",
297 		    argc, argv) == -1) {
298 			mdb_warn("can't walk '%s'", iv->iv_wcmd);
299 			return (DCMD_ERR);
300 		}
301 		return (DCMD_OK);
302 	}
303 
304 	iddata = mdb_alloc(iv->iv_idsize, UM_SLEEP | UM_GC);
305 	if (mdb_vread(iddata, iv->iv_idsize, addr) == -1) {
306 		mdb_warn("failed to read %s at %#lx", iv->iv_ocmd, addr);
307 		return (DCMD_ERR);
308 	}
309 
310 	if (!DCMD_HDRSPEC(flags) && iv->iv_print)
311 		mdb_printf("\n");
312 
313 	if (DCMD_HDRSPEC(flags) || iv->iv_print)
314 		ipcperm_header();
315 
316 	ipcperm_print(addr, (struct kipc_perm *)iddata);
317 	if (iv->iv_print) {
318 		mdb_inc_indent(CMN_INDENT);
319 		iv->iv_print(iddata, addr);
320 		mdb_dec_indent(CMN_INDENT);
321 	}
322 
323 	return (DCMD_OK);
324 }
325 
326 
327 /*
328  * Stubs to call ds_print with the appropriate ops vector
329  */
330 static int
cmd_kshmid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)331 cmd_kshmid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
332 {
333 	return (ds_print(addr, flags, argc, argv, &shm_ops_vec));
334 }
335 
336 
337 static int
cmd_kmsqid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)338 cmd_kmsqid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
339 {
340 	return (ds_print(addr, flags, argc, argv, &msq_ops_vec));
341 }
342 
343 static int
cmd_ksemid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)344 cmd_ksemid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
345 {
346 	return (ds_print(addr, flags, argc, argv, &sem_ops_vec));
347 }
348 
349 /*
350  * Generic IPC walker
351  */
352 
353 static int
ds_walk_init(mdb_walk_state_t * wsp)354 ds_walk_init(mdb_walk_state_t *wsp)
355 {
356 	ipc_ops_vec_t	*iv = wsp->walk_arg;
357 
358 	if (wsp->walk_arg != NULL && wsp->walk_addr != NULL)
359 		mdb_printf("ignoring provided address\n");
360 
361 	if (wsp->walk_arg)
362 		if (mdb_readvar(&wsp->walk_addr, iv->iv_service) == -1) {
363 			mdb_printf("failed to read '%s'; module not present\n",
364 			    iv->iv_service);
365 			return (WALK_DONE);
366 		}
367 	else
368 		wsp->walk_addr = wsp->walk_addr +
369 		    OFFSETOF(ipc_service_t, ipcs_usedids);
370 
371 	if (mdb_layered_walk("list", wsp) == -1)
372 		return (WALK_ERR);
373 
374 	return (WALK_NEXT);
375 }
376 
377 
378 static int
ds_walk_step(mdb_walk_state_t * wsp)379 ds_walk_step(mdb_walk_state_t *wsp)
380 {
381 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
382 	    wsp->walk_cbdata));
383 }
384 
385 /*
386  * Generic IPC ID/key to pointer code
387  */
388 
389 static int
ipcid_impl(uintptr_t svcptr,uintptr_t id,uintptr_t * addr)390 ipcid_impl(uintptr_t svcptr, uintptr_t id, uintptr_t *addr)
391 {
392 	ipc_service_t service;
393 	kipc_perm_t perm;
394 	ipc_slot_t slot;
395 	uintptr_t slotptr;
396 	uint_t index;
397 
398 	if (id > INT_MAX) {
399 		mdb_warn("id out of range\n");
400 		return (DCMD_ERR);
401 	}
402 
403 	if (mdb_vread(&service, sizeof (ipc_service_t), svcptr) == -1) {
404 		mdb_warn("failed to read ipc_service_t at %#lx", svcptr);
405 		return (DCMD_ERR);
406 	}
407 
408 	index = (uint_t)id & (service.ipcs_tabsz - 1);
409 	slotptr = (uintptr_t)(service.ipcs_table + index);
410 
411 	if (mdb_vread(&slot, sizeof (ipc_slot_t), slotptr) == -1) {
412 		mdb_warn("failed to read ipc_slot_t at %#lx", slotptr);
413 		return (DCMD_ERR);
414 	}
415 
416 	if (slot.ipct_data == NULL)
417 		return (DCMD_ERR);
418 
419 	if (mdb_vread(&perm, sizeof (kipc_perm_t),
420 	    (uintptr_t)slot.ipct_data) == -1) {
421 		mdb_warn("failed to read kipc_perm_t at %#p",
422 		    slot.ipct_data);
423 		return (DCMD_ERR);
424 	}
425 
426 	if (perm.ipc_id != (uint_t)id)
427 		return (DCMD_ERR);
428 
429 	*addr = (uintptr_t)slot.ipct_data;
430 
431 	return (DCMD_OK);
432 }
433 
434 
435 typedef struct findkey_data {
436 	key_t fk_key;
437 	uintptr_t fk_addr;
438 	boolean_t fk_found;
439 } findkey_data_t;
440 
441 static int
findkey(uintptr_t addr,kipc_perm_t * perm,findkey_data_t * arg)442 findkey(uintptr_t addr, kipc_perm_t *perm, findkey_data_t *arg)
443 {
444 	if (perm->ipc_key == arg->fk_key) {
445 		arg->fk_found = B_TRUE;
446 		arg->fk_addr = addr;
447 		return (WALK_DONE);
448 	}
449 	return (WALK_NEXT);
450 }
451 
452 static int
ipckey_impl(uintptr_t svcptr,uintptr_t key,uintptr_t * addr)453 ipckey_impl(uintptr_t svcptr, uintptr_t key, uintptr_t *addr)
454 {
455 	ipc_service_t	service;
456 	findkey_data_t	fkdata;
457 
458 	if ((key == IPC_PRIVATE) || (key > INT_MAX)) {
459 		mdb_warn("key out of range\n");
460 		return (DCMD_ERR);
461 	}
462 
463 	if (mdb_vread(&service, sizeof (ipc_service_t), svcptr) == -1) {
464 		mdb_warn("failed to read ipc_service_t at %#lx", svcptr);
465 		return (DCMD_ERR);
466 	}
467 
468 	fkdata.fk_key = (key_t)key;
469 	fkdata.fk_found = B_FALSE;
470 	if ((mdb_pwalk("avl", (mdb_walk_cb_t)findkey, &fkdata,
471 	    svcptr + OFFSETOF(ipc_service_t, ipcs_keys)) == -1) ||
472 	    !fkdata.fk_found)
473 		return (DCMD_ERR);
474 
475 	*addr = fkdata.fk_addr;
476 
477 	return (DCMD_OK);
478 }
479 
480 static int
ipckeyid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv,int (* fp)(uintptr_t,uintptr_t,uintptr_t *))481 ipckeyid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
482     int(*fp)(uintptr_t, uintptr_t, uintptr_t *))
483 {
484 	uintmax_t val;
485 	uintptr_t raddr;
486 	int result;
487 
488 	if (!(flags & DCMD_ADDRSPEC) || (argc != 1))
489 		return (DCMD_USAGE);
490 
491 	if (argv[0].a_type == MDB_TYPE_IMMEDIATE)
492 		val = argv[0].a_un.a_val;
493 	else if (argv[0].a_type == MDB_TYPE_STRING)
494 		val = mdb_strtoull(argv[0].a_un.a_str);
495 	else
496 		return (DCMD_USAGE);
497 
498 	result = fp(addr, val, &raddr);
499 
500 	if (result == DCMD_OK)
501 		mdb_printf("%lx", raddr);
502 
503 	return (result);
504 }
505 
506 static int
ipckey(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)507 ipckey(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
508 {
509 	return (ipckeyid(addr, flags, argc, argv, ipckey_impl));
510 }
511 
512 static int
ipcid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)513 ipcid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
514 {
515 	return (ipckeyid(addr, flags, argc, argv, ipcid_impl));
516 }
517 
518 static int
ds_ptr(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv,ipc_ops_vec_t * iv)519 ds_ptr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
520     ipc_ops_vec_t *iv)
521 {
522 	uint_t		kflag = FALSE;
523 	uintptr_t	svcptr, raddr;
524 	int		result;
525 
526 	if (!(flags & DCMD_ADDRSPEC))
527 		return (DCMD_USAGE);
528 
529 	if (mdb_getopts(argc, argv,
530 	    'k', MDB_OPT_SETBITS, TRUE, &kflag, NULL) != argc)
531 		return (DCMD_USAGE);
532 
533 	if (mdb_readvar(&svcptr, iv->iv_service) == -1) {
534 		mdb_warn("failed to read '%s'; module not present\n",
535 		    iv->iv_service);
536 		return (DCMD_ERR);
537 	}
538 
539 	result = kflag ? ipckey_impl(svcptr, addr, &raddr) :
540 	    ipcid_impl(svcptr, addr, &raddr);
541 
542 	if (result == DCMD_OK)
543 		mdb_printf("%lx", raddr);
544 
545 	return (result);
546 }
547 
548 /*
549  * Stubs to call ds_ptr with the appropriate ops vector
550  */
551 static int
id2shm(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)552 id2shm(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
553 {
554 	return (ds_ptr(addr, flags, argc, argv, &shm_ops_vec));
555 }
556 
557 static int
id2msq(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)558 id2msq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
559 {
560 	return (ds_ptr(addr, flags, argc, argv, &msq_ops_vec));
561 }
562 
563 static int
id2sem(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)564 id2sem(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
565 {
566 	return (ds_ptr(addr, flags, argc, argv, &sem_ops_vec));
567 }
568 
569 
570 /*
571  * The message queue contents walker
572  */
573 
574 static int
msg_walk_init(mdb_walk_state_t * wsp)575 msg_walk_init(mdb_walk_state_t *wsp)
576 {
577 	wsp->walk_addr += OFFSETOF(kmsqid_t, msg_list);
578 	if (mdb_layered_walk("list", wsp) == -1)
579 		return (WALK_ERR);
580 
581 	return (WALK_NEXT);
582 }
583 
584 static int
msg_walk_step(mdb_walk_state_t * wsp)585 msg_walk_step(mdb_walk_state_t *wsp)
586 {
587 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
588 	    wsp->walk_cbdata));
589 }
590 
591 /*
592  * The "::ipcs" command itself.  Just walks each IPC type in turn.
593  */
594 
595 /*ARGSUSED*/
596 static int
ipcs(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)597 ipcs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
598 {
599 	uint_t	oflags = 0;
600 
601 	if ((flags & DCMD_ADDRSPEC) || mdb_getopts(argc, argv, 'l',
602 	    MDB_OPT_SETBITS, 1, &oflags, NULL) != argc)
603 		return (DCMD_USAGE);
604 
605 	mdb_printf("Message queues:\n");
606 	if (mdb_walk_dcmd("msq", oflags ? "kmsqid" : "ipcperm", argc, argv) ==
607 	    -1) {
608 		mdb_warn("can't walk 'msq'");
609 		return (DCMD_ERR);
610 	}
611 
612 	mdb_printf("\nShared memory:\n");
613 	if (mdb_walk_dcmd("shm", oflags ? "kshmid" : "ipcperm", argc, argv) ==
614 	    -1) {
615 		mdb_warn("can't walk 'shm'");
616 		return (DCMD_ERR);
617 	}
618 
619 	mdb_printf("\nSemaphores:\n");
620 	if (mdb_walk_dcmd("sem", oflags ? "ksemid" : "ipcperm", argc, argv) ==
621 	    -1) {
622 		mdb_warn("can't walk 'sem'");
623 		return (DCMD_ERR);
624 	}
625 
626 	return (DCMD_OK);
627 }
628 
629 static int
msgprint(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)630 msgprint(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
631 {
632 	struct msg message;
633 	uint_t	lflag = FALSE;
634 	long	type = 0;
635 	char	*tflag = NULL;
636 
637 	if (!(flags & DCMD_ADDRSPEC) || (mdb_getopts(argc, argv,
638 	    'l', MDB_OPT_SETBITS, TRUE, &lflag,
639 	    't', MDB_OPT_STR, &tflag, NULL) != argc))
640 		return (DCMD_USAGE);
641 
642 	/*
643 	 * Handle negative values.
644 	 */
645 	if (tflag != NULL) {
646 		if (*tflag == '-') {
647 			tflag++;
648 			type = -1;
649 		} else {
650 			type = 1;
651 		}
652 		type *= mdb_strtoull(tflag);
653 	}
654 
655 	if (DCMD_HDRSPEC(flags))
656 		mdb_printf("%<u>%?s %?s %8s %8s %8s%</u>\n",
657 		    "ADDR", "TEXT", "SIZE", "TYPE", "REF");
658 
659 	if (mdb_vread(&message, sizeof (struct msg), addr) == -1) {
660 		mdb_warn("failed to read msg at %#lx", addr);
661 		return (DCMD_ERR);
662 	}
663 
664 	/*
665 	 * If we are meeting our type contraints, display the message.
666 	 * If -l was specified, we will also display the message
667 	 * contents.
668 	 */
669 	if ((type == 0) ||
670 	    (type > 0 && message.msg_type == type) ||
671 	    (type < 0 && message.msg_type <= -type)) {
672 
673 		if (lflag && !DCMD_HDRSPEC(flags))
674 			mdb_printf("\n");
675 
676 		mdb_printf("%0?lx %?p %8ld %8ld %8ld\n", addr, message.msg_addr,
677 		    message.msg_size, message.msg_type, message.msg_copycnt);
678 
679 		if (lflag) {
680 			mdb_printf("\n");
681 			mdb_inc_indent(CMN_INDENT);
682 			if (mdb_dumpptr(
683 			    (uintptr_t)message.msg_addr, message.msg_size,
684 			    MDB_DUMP_RELATIVE | MDB_DUMP_TRIM |
685 			    MDB_DUMP_ASCII | MDB_DUMP_HEADER |
686 			    MDB_DUMP_GROUP(4),
687 			    (mdb_dumpptr_cb_t)mdb_vread, NULL)) {
688 				mdb_dec_indent(CMN_INDENT);
689 				return (DCMD_ERR);
690 			}
691 			mdb_dec_indent(CMN_INDENT);
692 		}
693 	}
694 
695 	return (DCMD_OK);
696 }
697 
698 /*
699  * MDB module linkage
700  */
701 static const mdb_dcmd_t dcmds[] = {
702 	/* Generic routines */
703 	{ "ipcperm", ":", "display an IPC perm structure", ipcperm },
704 	{ "ipcid", ":id", "perform an IPC id lookup", ipcid },
705 	{ "ipckey", ":key", "perform an IPC key lookup", ipckey },
706 
707 	/* Specific routines */
708 	{ "kshmid", "?[-l]", "display a struct kshmid", cmd_kshmid },
709 	{ "kmsqid", "?[-l]", "display a struct kmsqid", cmd_kmsqid },
710 	{ "ksemid", "?[-l]", "display a struct ksemid", cmd_ksemid },
711 	{ "msg", ":[-l] [-t type]", "display contents of a message", msgprint },
712 
713 	/* Convenience routines */
714 	{ "id2shm", ":[-k]", "convert shared memory ID to pointer", id2shm },
715 	{ "id2msq", ":[-k]", "convert message queue ID to pointer", id2msq },
716 	{ "id2sem", ":[-k]", "convert semaphore ID to pointer", id2sem },
717 
718 	{ "ipcs", "[-l]", "display System V IPC information", ipcs },
719 	{ NULL }
720 };
721 
722 static const mdb_walker_t walkers[] = {
723 	{ "ipcsvc", "walk a System V IPC service",
724 		ds_walk_init, ds_walk_step },
725 	{ "shm", "walk the active shmid_ds structures",
726 		ds_walk_init, ds_walk_step, NULL, &shm_ops_vec },
727 	{ "msq", "walk the active msqid_ds structures",
728 		ds_walk_init, ds_walk_step, NULL, &msq_ops_vec },
729 	{ "sem", "walk the active semid_ds structures",
730 		ds_walk_init, ds_walk_step, NULL, &sem_ops_vec },
731 	{ "msgqueue", "walk messages on a message queue",
732 		msg_walk_init, msg_walk_step },
733 	{ NULL }
734 };
735 
736 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
737 
738 const mdb_modinfo_t *
_mdb_init(void)739 _mdb_init(void)
740 {
741 	return (&modinfo);
742 }
743