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