xref: /titanic_41/usr/src/cmd/mdb/common/modules/rdc/rdc.c (revision fcf3ce441efd61da9bb2884968af01cb7c1452cc)
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 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/types.h>
27 #include <sys/mdb_modapi.h>
28 
29 #include <sys/nsctl/nsctl.h>
30 #include <sys/unistat/spcs_s.h>
31 #include <sys/unistat/spcs_s_k.h>
32 
33 #include <rpc/auth.h>
34 #include <rpc/auth_unix.h>
35 #include <rpc/auth_des.h>
36 #include <rpc/svc.h>
37 #include <rpc/xdr.h>
38 #include <rpc/svc_soc.h>
39 
40 /* HACK HACK  so we can bring in rdc_io.h and friends */
41 #define	nstset_t	char
42 
43 #include <sys/nsctl/rdc.h>
44 #include <sys/nsctl/rdc_prot.h>
45 #include <sys/nsctl/rdc_ioctl.h>
46 #include <sys/nsctl/rdc_io.h>
47 #include <sys/nsctl/rdc_bitmap.h>
48 
49 #include <sys/nsctl/nsvers.h>
50 
51 
52 /*
53  * Walker for an array of rdc_k_info_t structures.
54  * A global walk is assumed to start at rdc_k_info.
55  */
56 
57 struct rdc_kinfo_winfo {
58 	uintptr_t start;
59 	uintptr_t end;
60 };
61 
62 char bitstr[33] = { '0' };
63 
64 static int
rdc_k_info_winit(mdb_walk_state_t * wsp)65 rdc_k_info_winit(mdb_walk_state_t *wsp)
66 {
67 	struct rdc_kinfo_winfo *winfo;
68 	rdc_k_info_t *rdc_k_info;
69 	int rdc_max_sets;
70 
71 	winfo = mdb_zalloc(sizeof (struct rdc_kinfo_winfo), UM_SLEEP);
72 
73 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
74 		mdb_warn("failed to read 'rdc_k_info'");
75 		mdb_free(winfo,  sizeof (struct rdc_kinfo_winfo));
76 		return (WALK_ERR);
77 	}
78 
79 	if (mdb_readvar(&rdc_max_sets, "rdc_max_sets") == -1) {
80 		mdb_warn("failed to read 'rdc_max_sets'");
81 		mdb_free(winfo, sizeof (struct rdc_kinfo_winfo));
82 		return (WALK_ERR);
83 	}
84 
85 	winfo->start = (uintptr_t)rdc_k_info;
86 	winfo->end = (uintptr_t)(rdc_k_info + rdc_max_sets);
87 
88 	if (wsp->walk_addr == NULL)
89 		wsp->walk_addr = winfo->start;
90 
91 	wsp->walk_data = winfo;
92 	return (WALK_NEXT);
93 }
94 
95 
96 static int
rdc_k_info_wstep(mdb_walk_state_t * wsp)97 rdc_k_info_wstep(mdb_walk_state_t *wsp)
98 {
99 	struct rdc_kinfo_winfo *winfo = wsp->walk_data;
100 	int status;
101 
102 	if (wsp->walk_addr == NULL)
103 		return (WALK_DONE);
104 
105 	if (wsp->walk_addr >= winfo->end)
106 		return (WALK_DONE);
107 
108 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
109 	    wsp->walk_cbdata);
110 
111 	wsp->walk_addr += sizeof (rdc_k_info_t);
112 	return (status);
113 }
114 
115 
116 static void
rdc_k_info_wfini(mdb_walk_state_t * wsp)117 rdc_k_info_wfini(mdb_walk_state_t *wsp)
118 {
119 	mdb_free(wsp->walk_data, sizeof (struct rdc_kinfo_winfo));
120 }
121 
122 /*
123  * Walker for an array of rdc_u_info_t structures.
124  * A global walk is assumed to start at rdc_u_info.
125  */
126 
127 struct rdc_uinfo_winfo {
128 	uintptr_t start;
129 	uintptr_t end;
130 };
131 
132 
133 static int
rdc_u_info_winit(mdb_walk_state_t * wsp)134 rdc_u_info_winit(mdb_walk_state_t *wsp)
135 {
136 	struct rdc_uinfo_winfo *winfo;
137 	rdc_u_info_t *rdc_u_info;
138 	int rdc_max_sets;
139 
140 	winfo = mdb_zalloc(sizeof (struct rdc_uinfo_winfo), UM_SLEEP);
141 
142 	if (mdb_readvar(&rdc_u_info, "rdc_u_info") == -1) {
143 		mdb_warn("failed to read 'rdc_u_info'");
144 		mdb_free(winfo,  sizeof (struct rdc_uinfo_winfo));
145 		return (WALK_ERR);
146 	}
147 
148 	if (mdb_readvar(&rdc_max_sets, "rdc_max_sets") == -1) {
149 		mdb_warn("failed to read 'rdc_max_sets'");
150 		mdb_free(winfo, sizeof (struct rdc_uinfo_winfo));
151 		return (WALK_ERR);
152 	}
153 
154 	winfo->start = (uintptr_t)rdc_u_info;
155 	winfo->end = (uintptr_t)(rdc_u_info + rdc_max_sets);
156 
157 	if (wsp->walk_addr == NULL)
158 		wsp->walk_addr = winfo->start;
159 
160 	wsp->walk_data = winfo;
161 	return (WALK_NEXT);
162 }
163 
164 
165 static int
rdc_u_info_wstep(mdb_walk_state_t * wsp)166 rdc_u_info_wstep(mdb_walk_state_t *wsp)
167 {
168 	struct rdc_uinfo_winfo *winfo = wsp->walk_data;
169 	int status;
170 
171 	if (wsp->walk_addr == NULL)
172 		return (WALK_DONE);
173 
174 	if (wsp->walk_addr >= winfo->end)
175 		return (WALK_DONE);
176 
177 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
178 	    wsp->walk_cbdata);
179 
180 	wsp->walk_addr += sizeof (rdc_u_info_t);
181 	return (status);
182 }
183 
184 
185 static void
rdc_u_info_wfini(mdb_walk_state_t * wsp)186 rdc_u_info_wfini(mdb_walk_state_t *wsp)
187 {
188 	mdb_free(wsp->walk_data, sizeof (struct rdc_uinfo_winfo));
189 }
190 
191 /*
192  * Walker for the rdc_if chain.
193  * A global walk is assumed to start at rdc_if_top.
194  */
195 
196 static int
rdc_if_winit(mdb_walk_state_t * wsp)197 rdc_if_winit(mdb_walk_state_t *wsp)
198 {
199 	if (wsp->walk_addr == NULL &&
200 	    mdb_readvar(&wsp->walk_addr, "rdc_if_top") == -1) {
201 		mdb_warn("unable to read 'rdc_if_top'");
202 		return (WALK_ERR);
203 	}
204 
205 	wsp->walk_data = mdb_zalloc(sizeof (rdc_if_t), UM_SLEEP);
206 
207 	return (WALK_NEXT);
208 }
209 
210 
211 static int
rdc_if_wstep(mdb_walk_state_t * wsp)212 rdc_if_wstep(mdb_walk_state_t *wsp)
213 {
214 	int status;
215 
216 	if (wsp->walk_addr == NULL)
217 		return (WALK_DONE);
218 
219 	if (mdb_vread(wsp->walk_data,
220 	    sizeof (rdc_if_t), wsp->walk_addr) == -1) {
221 		mdb_warn("failed to read rdc_if at %p", wsp->walk_addr);
222 		return (WALK_DONE);
223 	}
224 
225 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
226 	    wsp->walk_cbdata);
227 
228 	wsp->walk_addr = (uintptr_t)(((rdc_if_t *)wsp->walk_data)->next);
229 	return (status);
230 }
231 
232 
233 static void
rdc_if_wfini(mdb_walk_state_t * wsp)234 rdc_if_wfini(mdb_walk_state_t *wsp)
235 {
236 	mdb_free(wsp->walk_data, sizeof (rdc_if_t));
237 }
238 
239 /*
240  * Displays the asynchronous sleep q on the server.
241  */
242 /*ARGSUSED*/
243 static int
rdc_sleepq(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)244 rdc_sleepq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
245 {
246 	rdc_sleepq_t sq;
247 
248 	if (!(flags & DCMD_ADDRSPEC))
249 		return (DCMD_USAGE);
250 	while (addr) {
251 		if (mdb_vread(&sq, sizeof (sq), addr) != sizeof (sq)) {
252 			mdb_warn("failed to read rdc_sleepq at %p", addr);
253 			return (DCMD_ERR);
254 		}
255 		mdb_printf("sequence number %u  qpos %d \n", sq.seq, sq.qpos);
256 		addr = (uintptr_t)sq.next;
257 	}
258 	return (DCMD_OK);
259 }
260 
261 /*
262  * display the header info for the pending diskq requests
263  */
264 /*ARGSUSED*/
265 static int
rdc_iohdr(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)266 rdc_iohdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
267 {
268 	io_hdr hdr;
269 
270 	if (!(flags & DCMD_ADDRSPEC))
271 		return (DCMD_USAGE);
272 
273 	while (addr) {
274 		if (mdb_vread(&hdr, sizeof (io_hdr), addr) != sizeof (io_hdr)) {
275 			mdb_warn("failed to read io_hdr at %p", addr);
276 			return (DCMD_ERR);
277 		}
278 		mdb_printf("iohdr: type %d pos %d qpos %d len %d flag 0x%x"
279 		" iostatus %x setid %d next %p\n", hdr.dat.type, hdr.dat.pos,
280 		hdr.dat.qpos, hdr.dat.len, hdr.dat.flag, hdr.dat.iostatus,
281 		hdr.dat.setid, hdr.dat.next);
282 
283 		addr = (uintptr_t)hdr.dat.next;
284 	}
285 	return (DCMD_OK);
286 }
287 
288 /*
289  * Display a krdc->group.
290  * Requires an address.
291  */
292 /*ARGSUSED*/
293 static int
rdc_group(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)294 rdc_group(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
295 {
296 	struct rdc_group *group;
297 	disk_queue	*dq;
298 
299 	if (!(flags & DCMD_ADDRSPEC))
300 		return (DCMD_USAGE);
301 
302 
303 	group = mdb_zalloc(sizeof (*group), UM_GC);
304 
305 	if (mdb_vread(group, sizeof (*group), addr) != sizeof (*group)) {
306 		mdb_warn("failed to read rdc_group at %p", addr);
307 		return (DCMD_ERR);
308 	}
309 #ifdef XXXJET
310 	if (DCMD_HDRSPEC(flags)) {
311 		mdb_printf("%-?s  %8T%-8s  %8T%s\n", "ADDR", "MAJOR", "INUSE");
312 	}
313 #endif
314 	mdb_printf("count: %d  %8Twriter: %d  %8T flags: %d\n",
315 	    group->count, group->rdc_writer, group->flags);
316 	mdb_printf("thread num %d\n", group->rdc_thrnum);
317 
318 	dq = &group->diskq;
319 	if (RDC_IS_MEMQ(group)) {
320 		mdb_printf("queue type: Memory based\n");
321 	} else if (RDC_IS_DISKQ(group)) {
322 		mdb_printf("queue type: Disk based  %8Tqstate 0x%x\n",
323 		    QSTATE(dq));
324 	}
325 	mdb_printf("ra_queue head: 0x%p  %8Ttail 0x%p\n",
326 	    group->ra_queue.net_qhead, group->ra_queue.net_qtail);
327 	mdb_printf("ra_queue blocks: %d  %8Titems %d\n",
328 	    group->ra_queue.blocks, group->ra_queue.nitems);
329 	mdb_printf("ra_queue blockhwm: %d itemhwm: %d\n",
330 	    group->ra_queue.blocks_hwm, group->ra_queue.nitems_hwm);
331 	mdb_printf("ra_queue hwmhit: %d qfillsleep: %d\n",
332 	    group->ra_queue.hwmhit, group->ra_queue.qfill_sleeping);
333 	mdb_printf("ra_queue throttle: %ld\n",
334 	    group->ra_queue.throttle_delay);
335 
336 	if (RDC_IS_DISKQ(group)) {
337 		mdb_printf("head: %d %8Tnxtio: %d  %8Ttail %d %8Tlastail: %d\n",
338 		    QHEAD(dq), QNXTIO(dq), QTAIL(dq), LASTQTAIL(dq));
339 		mdb_printf("coalbounds: %d %8Tqwrap: %d\n", QCOALBOUNDS(dq),
340 		    QWRAP(dq));
341 		mdb_printf("blocks: %d  %8Titems %d qfflags 0x%x \n",
342 		    QBLOCKS(dq), QNITEMS(dq), group->ra_queue.qfflags);
343 		mdb_printf("diskq throttle: %ld %8Tflags: %x\n",
344 		    dq->throttle_delay, group->flags);
345 		mdb_printf("disk queue nitems_hwm: %d %8Tblocks_hwm: %d\n",
346 		    dq->nitems_hwm, dq->blocks_hwm);
347 		mdb_printf("diskqfd:   0x%p %8Tdisqrsrv: %d lastio: 0x%p\n",
348 		    group->diskqfd, group->diskqrsrv, dq->lastio);
349 		mdb_printf("outstanding req %d iohdrs 0x%p iohdrs_last 0x%p\n",
350 		    dq->hdrcnt, dq->iohdrs, dq->hdr_last);
351 	}
352 	mdb_printf("seq: %u\n", group->seq);
353 	mdb_printf("seqack: %u\n", group->seqack);
354 	mdb_printf("sleepq: 0x%p\n", group->sleepq);
355 	mdb_printf("asyncstall %d\n", group->asyncstall);
356 	mdb_printf("asyncdis %d\n", group->asyncdis);
357 
358 	mdb_inc_indent(4);
359 	if (group->sleepq) {
360 		rdc_sleepq((uintptr_t)group->sleepq, DCMD_ADDRSPEC,
361 		    0, 0);
362 	}
363 	mdb_dec_indent(4);
364 
365 	return (DCMD_OK);
366 }
367 
368 
369 /*
370  * Display a krdc->lsrv.
371  * Requires an address.
372  */
373 /*ARGSUSED*/
374 static int
rdc_srv(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)375 rdc_srv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
376 {
377 	rdc_srv_t *lsrv;
378 	char name[MAX_RDC_HOST_SIZE];
379 
380 	if (!(flags & DCMD_ADDRSPEC))
381 		return (DCMD_USAGE);
382 
383 
384 	lsrv = mdb_zalloc(sizeof (*lsrv), UM_GC);
385 
386 	if (mdb_vread(lsrv, sizeof (*lsrv), addr) != sizeof (*lsrv)) {
387 		mdb_warn("failed to read rdc_srv at %p", addr);
388 		return (DCMD_ERR);
389 	}
390 
391 	if (mdb_readstr(name, sizeof (name),
392 		(uintptr_t)lsrv->ri_hostname) == -1) {
393 		mdb_warn("failed to read ri_hostname name at %p", addr);
394 		return (DCMD_ERR);
395 	}
396 
397 	mdb_printf("host: %s  %16Tri_knconf 0x%p\n", name, lsrv->ri_knconf);
398 
399 	mdb_printf("ri_addr: 0x%p  %8Tsecdata 0x%p\n",
400 	    addr + OFFSETOF(rdc_srv_t, ri_addr), lsrv->ri_secdata);
401 
402 	return (DCMD_OK);
403 }
404 
405 /*
406  * Display a rdc_if_t.
407  * Requires an address.
408  */
409 static int
rdc_if(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)410 rdc_if(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
411 {
412 	rdc_if_t *ifp;
413 
414 	if (!(flags & DCMD_ADDRSPEC)) {
415 		/*
416 		 * paranoid mode on: qualify walker name with module name
417 		 * using '`' syntax.
418 		 */
419 		if (mdb_walk_dcmd("rdc`rdc_if",
420 			"rdc`rdc_if", argc, argv) == -1) {
421 			mdb_warn("failed to walk 'rdc_if'");
422 			return (DCMD_ERR);
423 		}
424 		return (DCMD_OK);
425 	}
426 
427 	ifp = mdb_zalloc(sizeof (*ifp), UM_GC);
428 
429 	if (mdb_vread(ifp, sizeof (*ifp), addr) != sizeof (*ifp)) {
430 		mdb_warn("failed to read rdc_srv at %p", addr);
431 		return (DCMD_ERR);
432 	}
433 
434 	mdb_printf("next: 0x%p  %8Tsrv 0x%p\n", ifp->next, ifp->srv);
435 	mdb_printf("if_addr: 0x%p  %8Tr_ifaddr 0x%p\n",
436 	    addr + OFFSETOF(rdc_if_t, ifaddr),
437 	    addr + OFFSETOF(rdc_if_t, r_ifaddr));
438 	mdb_printf("if_down: %d  %8Tprimary %d  %8Tsecondary  %d\n",
439 		ifp->if_down, ifp->isprimary, ifp->issecondary);
440 	mdb_printf("version %d  %8Tnoping  %d\n", ifp->rpc_version,
441 		ifp->no_ping);
442 	mdb_printf("\n");
443 
444 	return (DCMD_OK);
445 }
446 
447 
448 /*
449  * Display a rdc_buf_t
450  * Requires an address.
451  */
452 /*ARGSUSED*/
453 static int
rdc_buf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)454 rdc_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
455 {
456 	rdc_buf_t *buf;
457 
458 	if (!(flags & DCMD_ADDRSPEC))
459 		return (DCMD_USAGE);
460 
461 
462 	buf = mdb_zalloc(sizeof (*buf), UM_GC);
463 
464 	if (mdb_vread(buf, sizeof (*buf), addr) != sizeof (*buf)) {
465 		mdb_warn("failed to read rdc_buf at %p", addr);
466 		return (DCMD_ERR);
467 	}
468 
469 	mdb_printf("nsc_buf fd: 0x%p  %8Tvec 0x%p\n",
470 	    buf->rdc_bufh.sb_fd, buf->rdc_bufh.sb_vec);
471 
472 	mdb_printf("nsc_buf pos: %d  %8Tlen %d\n",
473 	    buf->rdc_bufh.sb_pos, buf->rdc_bufh.sb_len);
474 
475 	mdb_printf("nsc_buf flag: 0x%x  %8Terror %d\n",
476 	    buf->rdc_bufh.sb_flag, buf->rdc_bufh.sb_error);
477 
478 	mdb_printf("anon_buf : 0x%p  %8Tfd 0x%p  %8Tbufp  0x%p\n",
479 	    buf->rdc_anon, buf->rdc_fd, buf->rdc_bufp);
480 
481 	mdb_printf("vsize: %d  %8Tflags 0x%x\n",
482 	    buf->rdc_vsize, buf->rdc_flags);
483 
484 	return (DCMD_OK);
485 }
486 
487 /*ARGSUSED*/
488 static int
rdc_aio(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)489 rdc_aio(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
490 {
491 	rdc_aio_t *aio;
492 
493 	if (!(flags & DCMD_ADDRSPEC))
494 		return (DCMD_USAGE);
495 
496 	aio = mdb_zalloc(sizeof (*aio), UM_GC);
497 
498 	if (mdb_vread(aio, sizeof (*aio), addr) != sizeof (*aio)) {
499 		mdb_warn("failed to read rdc_aio at %p", addr);
500 		return (DCMD_ERR);
501 	}
502 	mdb_printf("rdc_aio next: %p %8T nsc_buf: %p %8T nsc_qbuf %p\n",
503 	    aio->next, aio->handle, aio->qhandle);
504 	mdb_printf("pos: %d len: %d qpos: %d flag: %x iostatus: %d index: %d"
505 	    " seq: %d\n", aio->pos, aio->len, aio->qpos, aio->flag,
506 	    aio->iostatus, aio->index, aio->seq);
507 	return (DCMD_OK);
508 }
509 
510 /*ARGSUSED*/
511 static int
rdc_dset(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)512 rdc_dset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
513 {
514 	rdc_net_dataset_t *dset;
515 
516 	if (!(flags & DCMD_ADDRSPEC))
517 		return (DCMD_USAGE);
518 
519 	dset = mdb_zalloc(sizeof (*dset), UM_GC);
520 
521 	if (mdb_vread(dset, sizeof (*dset), addr) != sizeof (*dset)) {
522 		mdb_warn("failed to read dset at %p", addr);
523 		return (DCMD_ERR);
524 	}
525 	mdb_printf("dset id: %d %8T dset inuse: %d %8T dset delpend: %d\n",
526 	    dset->id, dset->inuse, dset->delpend);
527 	mdb_printf("dset items: %d %8T dset head %p %8T dset tail %p \n",
528 	    dset->nitems, dset->head, dset->tail);
529 	mdb_printf("dset pos %d %8T dset len %d\n", dset->pos, dset->fbalen);
530 
531 	return (DCMD_OK);
532 }
533 /*
534  * Display a single rdc_k_info structure.
535  * If called with no address, performs a global walk of all rdc_k_info.
536  * -a : all (i.e. display all devices, even if disabled
537  * -v : verbose
538  */
539 
540 const mdb_bitmask_t sv_flag_bits[] = {
541 	{ "NSC_DEVICE", NSC_DEVICE, NSC_DEVICE },
542 	{ "NSC_CACHE", NSC_CACHE, NSC_CACHE },
543 	{ NULL, 0, 0 }
544 };
545 
546 static int
rdc_kinfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)547 rdc_kinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
548 {
549 	rdc_k_info_t *krdc;
550 	rdc_u_info_t *rdc_u_info, *urdc;
551 	int a_opt, v_opt;
552 	int dev_t_chars;
553 
554 	a_opt = v_opt = FALSE;
555 	dev_t_chars = sizeof (dev_t) * 2;	/* # chars to display dev_t */
556 
557 	if (mdb_getopts(argc, argv,
558 	    'a', MDB_OPT_SETBITS, TRUE, &a_opt,
559 	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
560 		return (DCMD_USAGE);
561 
562 	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
563 	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);
564 
565 	if (!(flags & DCMD_ADDRSPEC)) {
566 		/*
567 		 * paranoid mode on: qualify walker name with module name
568 		 * using '`' syntax.
569 		 */
570 		if (mdb_walk_dcmd("rdc`rdc_kinfo",
571 			"rdc`rdc_kinfo", argc, argv) == -1) {
572 			mdb_warn("failed to walk 'rdc_kinfo'");
573 			return (DCMD_ERR);
574 		}
575 		return (DCMD_OK);
576 	}
577 	if (DCMD_HDRSPEC(flags)) {
578 		mdb_printf("%-?s  %8T%-*s  %8T%s\n", "ADDR",
579 		    dev_t_chars, "TFLAG", "STATE");
580 	}
581 
582 	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
583 		mdb_warn("failed to read rdc_k_info at %p", addr);
584 		return (DCMD_ERR);
585 	}
586 
587 	if (mdb_readvar(&rdc_u_info, "rdc_u_info") == -1) {
588 		mdb_warn("failed to read 'rdc_u_info'");
589 		return (DCMD_ERR);
590 	}
591 
592 	urdc = &rdc_u_info[krdc->index];
593 
594 	if (!a_opt && ((krdc->type_flag & RDC_CONFIGURED) == 0))
595 		return (DCMD_OK);
596 
597 	mdb_printf("%?p  %8T%0*lx  %8T", addr, dev_t_chars, krdc->type_flag);
598 
599 
600 	if (krdc->type_flag & RDC_DISABLEPEND)
601 		mdb_printf(" disable pending");
602 	if (krdc->type_flag &  RDC_ASYNCMODE)
603 		mdb_printf(" async");
604 	if (krdc->type_flag & RDC_RESUMEPEND)
605 		mdb_printf(" resume pending");
606 	if (krdc->type_flag & RDC_BUSYWAIT)
607 		mdb_printf(" busywait");
608 #ifdef RDC_SMALLIO
609 	if (krdc->type_flag & RDC_SMALLIO)
610 		mdb_printf(" smallio");
611 #endif
612 
613 	mdb_printf("\n");
614 
615 	if (!v_opt)
616 		return (DCMD_OK);
617 
618 	/*
619 	 * verbose - print the rest of the structure as well.
620 	 */
621 
622 	mdb_inc_indent(4);
623 
624 	mdb_printf("index: %d  %8Trindex: %d  %8Tbusyc: %d  %8Tmaxfbas:  %d\n",
625 	    krdc->index, krdc->remote_index, krdc->busy_count, krdc->maxfbas);
626 
627 	mdb_printf("info_dev:  0x%p %8Tiodev: 0x%p  %8T %8T vers %d\n",
628 	krdc->devices, krdc->iodev, krdc->rpc_version);
629 
630 	mdb_printf("iokstats:  0x%p\n", krdc->io_kstats);
631 	mdb_printf("group:  0x%p %8Tgroup_next:  0x%p\n",
632 		krdc->group, krdc->group_next);
633 	mdb_printf("group lock: 0x%p aux_state: %d\n",
634 	    &krdc->group->lock, krdc->aux_state);
635 
636 	mdb_inc_indent(4);
637 	if (krdc->type_flag & RDC_ASYNCMODE) {
638 		rdc_group((uintptr_t)krdc->group, DCMD_ADDRSPEC, 0, 0);
639 	}
640 	mdb_dec_indent(4);
641 
642 	mdb_printf("servinfo:  0x%p %8Tintf:  0x%p\nbitmap: 0x%p  %8T"
643 	    "bitmap_ref:  0x%p\n",
644 	    krdc->lsrv, krdc->intf, krdc->dcio_bitmap, krdc->bitmap_ref);
645 
646 	mdb_printf("bmap_size:  %d %8Tbmaprsrv: %d%8T bmap_write:  %d\n",
647 	    krdc->bitmap_size, krdc->bmaprsrv, krdc->bitmap_write);
648 
649 	mdb_printf("bitmapfd:  0x%p %8Tremote_fd: 0x%p  %8T\n", krdc->bitmapfd,
650 	    krdc->remote_fd);
651 
652 	mdb_printf("net_dataset:  0x%p %8Tdisk_status: %d  %8T\n",
653 	    krdc->net_dataset, krdc->disk_status);
654 
655 	mdb_printf("many:  0x%p %8Tmulti: 0x%p  %8T\n", krdc->many_next,
656 	    krdc->multi_next);
657 
658 	mdb_printf("rdc_uinfo: 0x%p\n\n", urdc);
659 	mdb_dec_indent(4);
660 	return (DCMD_OK);
661 }
662 
663 
664 static int
rdc_uinfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)665 rdc_uinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
666 {
667 	rdc_u_info_t *urdc;
668 	rdc_k_info_t *rdc_k_info, *krdc, krdc1;
669 	rdc_group_t grp;
670 	disk_queue *dqp = NULL;
671 	int a_opt, v_opt;
672 	int dev_t_chars;
673 	int rdcflags;
674 
675 	a_opt = v_opt = FALSE;
676 	dev_t_chars = sizeof (dev_t) * 2;	/* # chars to display dev_t */
677 
678 	if (mdb_getopts(argc, argv,
679 	    'a', MDB_OPT_SETBITS, TRUE, &a_opt,
680 	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
681 		return (DCMD_USAGE);
682 
683 	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);
684 	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
685 
686 	if (!(flags & DCMD_ADDRSPEC)) {
687 		/*
688 		 * paranoid mode on: qualify walker name with module name
689 		 * using '`' syntax.
690 		 */
691 		if (mdb_walk_dcmd("rdc`rdc_uinfo",
692 			"rdc`rdc_uinfo", argc, argv) == -1) {
693 			mdb_warn("failed to walk 'rdc_uinfo'");
694 			return (DCMD_ERR);
695 		}
696 		return (DCMD_OK);
697 	}
698 	if (DCMD_HDRSPEC(flags)) {
699 		mdb_printf("%-?s  %8T%-*s  %8T%s\n", "ADDR",
700 		    dev_t_chars, "FLAG", "STATE");
701 	}
702 
703 	if (mdb_vread(urdc, sizeof (*urdc), addr) != sizeof (*urdc)) {
704 		mdb_warn("failed to read rdc_u_info at %p", addr);
705 		return (DCMD_ERR);
706 	}
707 
708 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
709 		mdb_warn("failed to read 'rdc_k_info'");
710 		return (DCMD_ERR);
711 	}
712 
713 	krdc = &rdc_k_info[urdc->index];
714 
715 	if (!a_opt && ((urdc->flags & RDC_ENABLED) == 0))
716 		return (DCMD_OK);
717 
718 
719 	if (mdb_vread(&krdc1, sizeof (krdc1),
720 	    (uintptr_t)krdc) != sizeof (krdc1)) {
721 		mdb_warn("failed to read 'rdc_k_info1'");
722 		return (DCMD_ERR);
723 	}
724 
725 	if (krdc1.group) {
726 		if (mdb_vread(&grp, sizeof (grp),
727 		    (uintptr_t)krdc1.group) != sizeof (grp)) {
728 			mdb_warn("failed to read group info ");
729 			return (DCMD_ERR);
730 		}
731 		dqp = &grp.diskq;
732 	}
733 
734 	rdcflags = (urdc->flags | urdc->sync_flags | urdc->bmap_flags);
735 	mdb_printf("%?p  %8T%0*lx  %8T", addr, dev_t_chars, rdcflags);
736 
737 
738 	if (rdcflags & RDC_PRIMARY)
739 		mdb_printf(" primary");
740 	if (rdcflags &  RDC_SLAVE)
741 		mdb_printf(" slave");
742 	if (rdcflags &  RDC_SYNCING)
743 		mdb_printf(" syncing");
744 	if (rdcflags &  RDC_SYNC_NEEDED)
745 		mdb_printf(" sync_need");
746 	if (rdcflags &  RDC_RSYNC_NEEDED)
747 		mdb_printf(" rsync_need");
748 	if (rdcflags & RDC_LOGGING)
749 		mdb_printf(" logging");
750 	if (rdcflags & RDC_QUEUING)
751 		mdb_printf(" queuing");
752 	if (rdcflags & RDC_DISKQ_FAILED)
753 		mdb_printf(" diskq failed");
754 	if (rdcflags & RDC_VOL_FAILED)
755 		mdb_printf(" vol failed");
756 	if (rdcflags & RDC_BMP_FAILED)
757 		mdb_printf(" bmp failed");
758 	if (rdcflags & RDC_ASYNC)
759 		mdb_printf(" async");
760 	if (rdcflags & RDC_CLR_AFTERSYNC)
761 		mdb_printf(" clr_bitmap_aftersync");
762 	if (dqp) {
763 		if (IS_QSTATE(dqp, RDC_QNOBLOCK))
764 			mdb_printf(" noblock");
765 	}
766 #ifdef RDC_SMALLIO
767 	if (rdcflags & RDC_SMALLIO)
768 		mdb_printf(" smallio");
769 #endif
770 
771 	mdb_printf("\n");
772 
773 	if (!v_opt)
774 		return (DCMD_OK);
775 
776 	/*
777 	 * verbose - print the rest of the structure as well.
778 	 */
779 
780 	mdb_inc_indent(4);
781 	mdb_printf("\n");
782 
783 	mdb_printf("primary: %s  %8Tfile: %s  \nbitmap: %s  ",
784 	    urdc->primary.intf, urdc->primary.file, urdc->primary.bitmap);
785 	mdb_printf("netbuf: 0x%p\n", addr + OFFSETOF(rdc_set_t, primary));
786 	mdb_printf("secondary: %s  %8Tfile: %s  \nbitmap: %s  ",
787 	    urdc->secondary.intf, urdc->secondary.file, urdc->secondary.bitmap);
788 	mdb_printf("netbuf: 0x%p\n", addr + OFFSETOF(rdc_set_t, secondary));
789 
790 	mdb_printf("sflags:  %d %8Tbflags: %d%8T mflags:  %d\n",
791 		urdc->sync_flags, urdc->bmap_flags, urdc->mflags);
792 	mdb_printf("index:  %d %8Tsync_pos: %d%8T vsize:  %d\n",
793 		urdc->index, urdc->sync_pos, urdc->volume_size);
794 	mdb_printf("setid:  %d %8Tbits set:  %d %8Tautosync: %d\n",
795 		urdc->setid, urdc->bits_set, urdc->autosync);
796 	mdb_printf("maxqfbas:  %d %8Tmaxqitems: %d\n",
797 		urdc->maxqfbas, urdc->maxqitems);
798 	mdb_printf("netconfig:  %p\n", urdc->netconfig);
799 	mdb_printf("group:  %s %8TdirectIO: %s\n",
800 		urdc->group_name, urdc->direct_file);
801 	mdb_printf("diskqueue: %s ", urdc->disk_queue);
802 	if (dqp) {
803 		mdb_printf("diskqsize: %d\n", QSIZE(dqp));
804 	} else {
805 		mdb_printf("\n");
806 	}
807 	mdb_printf("rdc_k_info: 0x%p\n", krdc);
808 	mdb_printf("\n");
809 	mdb_dec_indent(4);
810 
811 	mdb_printf("\n");
812 	return (DCMD_OK);
813 }
814 
815 /*ARGSUSED*/
816 static int
rdc_infodev(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)817 rdc_infodev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
818 {
819 	rdc_info_dev_t *infodev;
820 	_rdc_info_dev_t *infp;
821 
822 	if (!(flags & DCMD_ADDRSPEC))
823 		return (DCMD_USAGE);
824 
825 	infodev = mdb_zalloc(sizeof (*infodev), UM_GC);
826 	infp = mdb_zalloc(sizeof (*infp), UM_GC);
827 
828 	if (mdb_vread(infodev, sizeof (*infodev), addr) != sizeof (*infodev)) {
829 		mdb_warn("failed to read rdc_infodev at 0x%p\n", addr);
830 		return (DCMD_ERR);
831 	}
832 
833 	infp = &infodev->id_cache_dev;
834 	mdb_inc_indent(4);
835 
836 	mdb_printf("id_next: 0x%p\n", infodev->id_next);
837 	mdb_printf("id_cache_dev:\n");
838 
839 	mdb_inc_indent(4);
840 	mdb_printf("bi_fd: 0x%p %8Tbi_iodev: 0x%p %8Tbi_krdc 0x%p\n",
841 	    infp->bi_fd, infp->bi_iodev, infp->bi_krdc);
842 	mdb_printf("bi_rsrv: %d %8Tbi_orsrv: %d %8Tbi_failed: %d %8T\n"
843 	    "bi_ofailed: %d %8Tbi_flag: %d\n", infp->bi_rsrv, infp->bi_orsrv,
844 	    infp->bi_failed, infp->bi_ofailed, infp->bi_flag);
845 
846 	infp = &infodev->id_raw_dev;
847 
848 	mdb_dec_indent(4);
849 	mdb_printf("id_cache_dev:\n");
850 	mdb_inc_indent(4);
851 
852 	mdb_printf("bi_fd: 0x%p %8Tbi_iodev: 0x%p %8Tbi_krdc 0x%p\n",
853 	    infp->bi_fd, infp->bi_iodev, infp->bi_krdc);
854 	mdb_printf("bi_rsrv: %d %8Tbi_orsrv: %d %8Tbi_failed: %d %8T\n"
855 	    "bi_ofailed: %d %8Tbi_flag: %d\n", infp->bi_rsrv, infp->bi_orsrv,
856 	    infp->bi_failed, infp->bi_ofailed, infp->bi_flag);
857 
858 	mdb_dec_indent(4);
859 
860 	mdb_printf("id_sets: %d %8Tid_release: %d %8Tid_flag %d",
861 	    infodev->id_sets, infodev->id_release, infodev->id_flag);
862 
863 	if (infodev->id_flag & RDC_ID_CLOSING) {
864 		mdb_printf("closing");
865 	}
866 	mdb_printf("\n");
867 
868 	mdb_dec_indent(4);
869 	return (DCMD_OK);
870 }
871 
872 /*
873  * Display general sv module information.
874  */
875 
876 #define	rdc_get_print(kvar, str, fmt, val)		\
877 	if (mdb_readvar(&(val), #kvar) == -1) {		\
878 		mdb_dec_indent(4);			\
879 		mdb_warn("unable to read '" #kvar "'");	\
880 		return (DCMD_ERR);			\
881 	}						\
882 	mdb_printf("%-20s" fmt "\n", str ":", val)
883 
884 /*ARGSUSED*/
885 static int
rdc(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)886 rdc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
887 {
888 	int maj, min, mic, baseline, i;
889 
890 	if (argc != 0)
891 		return (DCMD_USAGE);
892 
893 	if (mdb_readvar(&maj, "sndr_major_rev") == -1) {
894 		mdb_warn("unable to read 'sndr_major_rev'");
895 		return (DCMD_ERR);
896 	}
897 
898 	if (mdb_readvar(&min, "sndr_minor_rev") == -1) {
899 		mdb_warn("unable to read 'sndr_minor_rev'");
900 		return (DCMD_ERR);
901 	}
902 
903 	if (mdb_readvar(&mic, "sndr_micro_rev") == -1) {
904 		mdb_warn("unable to read 'sndr_micro_rev'");
905 		return (DCMD_ERR);
906 	}
907 
908 	if (mdb_readvar(&baseline, "sndr_baseline_rev") == -1) {
909 		mdb_warn("unable to read 'sndr_baseline_rev'");
910 		return (DCMD_ERR);
911 	}
912 
913 	mdb_printf("Remote Mirror module version: kernel %d.%d.%d.%d; "
914 		    "mdb %d.%d.%d.%d\n", maj, min, mic, baseline,
915 	    ISS_VERSION_MAJ, ISS_VERSION_MIN, ISS_VERSION_MIC, ISS_VERSION_NUM);
916 	mdb_inc_indent(4);
917 
918 	rdc_get_print(rdc_debug, "debug", "%d", i);
919 	rdc_get_print(rdc_bitmap_mode, "bitmap mode", "%d", i);
920 	rdc_get_print(rdc_max_sets, "max sndr devices", "%d", i);
921 	rdc_get_print(rdc_rpc_tmout, "client RPC timeout", "%d", i);
922 	rdc_get_print(rdc_health_thres, "health threshold", "%d", i);
923 	rdc_get_print(MAX_RDC_FBAS, "max trans fba", "%d", i);
924 
925 	mdb_dec_indent(4);
926 	return (DCMD_OK);
927 }
928 
929 static int
rdc_k2u(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)930 rdc_k2u(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
931 {
932 	rdc_k_info_t *krdc;
933 	rdc_u_info_t *rdc_u_info, *urdc;
934 	int rc;
935 
936 	if (!(flags & DCMD_ADDRSPEC))
937 		return (DCMD_USAGE);
938 
939 	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
940 	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);
941 
942 	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
943 		mdb_warn("failed to read krdc at %p", addr);
944 		return (DCMD_ERR);
945 	}
946 
947 	if (mdb_readvar(&rdc_u_info, "rdc_u_info") == -1) {
948 		mdb_warn("failed to read 'rdc_u_info'");
949 		return (DCMD_ERR);
950 	}
951 
952 	urdc = &rdc_u_info[krdc->index];
953 
954 	rc = rdc_uinfo((uintptr_t)urdc, DCMD_ADDRSPEC, argc, argv);
955 	return (rc);
956 }
957 
958 static int
rdc_u2k(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)959 rdc_u2k(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
960 {
961 	rdc_u_info_t *urdc;
962 	rdc_k_info_t *rdc_k_info, *krdc;
963 	int rc;
964 
965 	if (!(flags & DCMD_ADDRSPEC))
966 		return (DCMD_USAGE);
967 
968 	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);
969 	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
970 
971 	if (mdb_vread(urdc, sizeof (*urdc), addr) != sizeof (*urdc)) {
972 		mdb_warn("failed to read urdc at %p\n", addr);
973 		return (DCMD_ERR);
974 	}
975 
976 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
977 		mdb_warn("failed to read 'rdc_k_info'");
978 		return (DCMD_ERR);
979 	}
980 
981 	krdc = &rdc_k_info[urdc->index];
982 
983 	rc = rdc_kinfo((uintptr_t)krdc, DCMD_ADDRSPEC, argc, argv);
984 	return (rc);
985 }
986 
987 #ifdef DEBUG
988 /*
989  * This routine is used to set the seq field in the rdc_kinfo->group
990  * structure. Used to test that the queue code handles the integer
991  * overflow correctly.
992  * Takes two arguments index and value.
993  * The index is the index into the kinfo structure array and
994  * the value is the new value to set into the seq field.
995  */
996 /*ARGSUSED*/
997 static int
rdc_setseq(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)998 rdc_setseq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
999 {
1000 	rdc_k_info_t *rdc_k_info;
1001 	rdc_group_t *group;
1002 	int index;
1003 	uint_t val;
1004 	uintptr_t pokeaddr;
1005 
1006 	if (argc != 2) {
1007 		mdb_warn("must have two arguments, index and value\n");
1008 		return (DCMD_ERR);
1009 	}
1010 
1011 	index = (int)mdb_strtoull(argv[0].a_un.a_str);
1012 	val = (uint_t)mdb_strtoull(argv[1].a_un.a_str);
1013 
1014 	/*
1015 	 * Find out where in memory the seq field.
1016 	 * The structure offset first.
1017 	 */
1018 
1019 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
1020 		mdb_warn("failed to read 'rdc_k_info'");
1021 		return (DCMD_ERR);
1022 	}
1023 	pokeaddr = (uintptr_t)&rdc_k_info[index].group;
1024 	if (mdb_vread(&group, sizeof (rdc_group_t *), pokeaddr) !=
1025 	    sizeof (rdc_group_t *)) {
1026 		mdb_warn("failed to fetch the group structure for set %d\n",
1027 		    index);
1028 		return (DCMD_ERR);
1029 	}
1030 	pokeaddr = (uintptr_t)(&group->seq);
1031 	if (mdb_vwrite(&val, sizeof (val), pokeaddr) != sizeof (val)) {
1032 		mdb_warn("failed to write seq at %p\n", pokeaddr);
1033 		return (DCMD_ERR);
1034 	}
1035 
1036 	return (DCMD_OK);
1037 }
1038 
1039 
1040 /*
1041  * This routine is used to set the seqack field in the rdc_kinfo->group
1042  * structure. Used to test that the queue code handles the integer
1043  * overflow correctly.
1044  * Takes two arguments index and value.
1045  * The index is the index into the kinfo structure array and
1046  * the value is the new value to set into the seqack field.
1047  */
1048 /*ARGSUSED*/
1049 static int
rdc_setseqack(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1050 rdc_setseqack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1051 {
1052 	rdc_k_info_t *rdc_k_info;
1053 	rdc_group_t *group;
1054 	int index;
1055 	uint_t val;
1056 	uintptr_t pokeaddr;
1057 
1058 	if (argc != 2) {
1059 		mdb_warn("must have two arguments, index and value\n");
1060 		return (DCMD_ERR);
1061 	}
1062 
1063 	index = (int)mdb_strtoull(argv[0].a_un.a_str);
1064 	val = (uint_t)mdb_strtoull(argv[1].a_un.a_str);
1065 
1066 	/*
1067 	 * Find out where in memory the seqack field.
1068 	 * The structure offset first.
1069 	 */
1070 
1071 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
1072 		mdb_warn("failed to read 'rdc_k_info'");
1073 		return (DCMD_ERR);
1074 	}
1075 	pokeaddr = (uintptr_t)&rdc_k_info[index].group;
1076 	if (mdb_vread(&group, sizeof (rdc_group_t *), pokeaddr) !=
1077 	    sizeof (rdc_group_t *)) {
1078 		mdb_warn("failed to fetch the group structure for set %d\n",
1079 		    index);
1080 		return (DCMD_ERR);
1081 	}
1082 	pokeaddr = (uintptr_t)(&group->seqack);
1083 	if (mdb_vwrite(&val, sizeof (val), pokeaddr) != sizeof (val)) {
1084 		mdb_warn("failed to write seqack at %p\n", pokeaddr);
1085 		return (DCMD_ERR);
1086 	}
1087 
1088 	return (DCMD_OK);
1089 }
1090 
1091 /*
1092  * random define printing stuff, just does the define, and print the result
1093  */
1094 /*ARGSUSED*/
1095 static int
fba_to_log_num(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1096 fba_to_log_num(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1097 {
1098 	int num;
1099 	if (argc < 1) {
1100 		mdb_warn("must have an argument\n");
1101 		return (DCMD_ERR);
1102 	}
1103 	num = (int)mdb_strtoull(argv[0].a_un.a_str);
1104 	num = FBA_TO_LOG_NUM(num);
1105 	mdb_printf("LOG NUM: %d (0x%x)", num, num);
1106 
1107 	return (DCMD_OK);
1108 }
1109 
1110 /*ARGSUSED*/
1111 static int
log_to_fba_num(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1112 log_to_fba_num(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1113 {
1114 	int num;
1115 	if (argc < 1) {
1116 		mdb_warn("must have an argument\n");
1117 		return (DCMD_ERR);
1118 	}
1119 	num = (int)mdb_strtoull(argv[0].a_un.a_str);
1120 	num = LOG_TO_FBA_NUM(num);
1121 	mdb_printf("LOG NUM: %d (0x%x)", num, num);
1122 
1123 	return (DCMD_OK);
1124 }
1125 
1126 static int
bmap_bit_isset(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1127 bmap_bit_isset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1128 {
1129 	int st;
1130 	int i, num;
1131 	rdc_k_info_t *krdc;
1132 	unsigned char *bmap;
1133 	unsigned char *bmaddr;
1134 	int bmsize;
1135 
1136 	if (!(flags & DCMD_ADDRSPEC))
1137 		return (DCMD_USAGE);
1138 
1139 	if (argc < 1) {
1140 		mdb_warn("must have an argument\n");
1141 		return (DCMD_ERR);
1142 	}
1143 	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
1144 
1145 	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
1146 		mdb_warn("failed to read rdc_k_info at %p", addr);
1147 		return (DCMD_ERR);
1148 	}
1149 
1150 	bmaddr = krdc->dcio_bitmap;
1151 	bmsize = krdc->bitmap_size;
1152 	bmap = mdb_zalloc(bmsize, UM_GC);
1153 	if (mdb_vread(bmap, bmsize, (uintptr_t)bmaddr) != bmsize) {
1154 		mdb_warn("failed to read bitmap");
1155 		return (DCMD_ERR);
1156 	}
1157 
1158 	num = (int)mdb_strtoull(argv[0].a_un.a_str);
1159 	st = FBA_TO_LOG_NUM(num);
1160 	i = BMAP_BIT_ISSET(bmap, st);
1161 	mdb_printf(" BIT (%d) for %x %s set (%02x)", st, num, i?"IS":"IS NOT",
1162 	    bmap[IND_BYTE(st)] & 0xff);
1163 
1164 	return (DCMD_OK);
1165 }
1166 
1167 static int
bmap_bitref_isset(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1168 bmap_bitref_isset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1169 {
1170 	int num, st, i;
1171 	rdc_k_info_t *krdc;
1172 	unsigned char *brefbyte;
1173 	unsigned int *brefint;
1174 	void *bradder;
1175 	int brsize;
1176 	size_t refcntsize = sizeof (unsigned char);
1177 	struct bm_ref_ops *refops;
1178 
1179 	if (!(flags & DCMD_ADDRSPEC))
1180 		return (DCMD_USAGE);
1181 
1182 	if (argc < 1) {
1183 		mdb_warn("must have an argument\n");
1184 		return (DCMD_ERR);
1185 	}
1186 
1187 	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
1188 
1189 	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
1190 		mdb_warn("failed to read rdc_k_info at %p", addr);
1191 		return (DCMD_ERR);
1192 	}
1193 
1194 	bradder = krdc->bitmap_ref;
1195 	refops = mdb_zalloc(sizeof (*refops), UM_GC);
1196 	if (mdb_vread(refops, sizeof (*refops), (uintptr_t)krdc->bm_refs) !=
1197 	    sizeof (*refops)) {
1198 		mdb_warn("failed to read bm_refops at %p", krdc->bm_refs);
1199 		return (DCMD_ERR);
1200 	}
1201 	refcntsize = refops->bmap_ref_size;
1202 	brsize = krdc->bitmap_size * BITS_IN_BYTE * refcntsize;
1203 	if (refcntsize == sizeof (unsigned char)) {
1204 		brefbyte = mdb_zalloc(brsize, UM_GC);
1205 		if (mdb_vread(brefbyte, brsize, (uintptr_t)bradder) != brsize) {
1206 			mdb_warn("failed to read bitmap");
1207 			return (DCMD_ERR);
1208 		}
1209 	} else {
1210 		brefint = mdb_zalloc(brsize, UM_GC);
1211 		if (mdb_vread(brefint, brsize, (uintptr_t)bradder) != brsize) {
1212 			mdb_warn("failed to read bitmap");
1213 			return (DCMD_ERR);
1214 		}
1215 	}
1216 
1217 	num = (int)mdb_strtoull(argv[0].a_un.a_str);
1218 	st = FBA_TO_LOG_NUM(num);
1219 	if (refcntsize == sizeof (unsigned char))
1220 		i = brefbyte[st];
1221 	else
1222 		i = brefint[st];
1223 
1224 	mdb_printf("BITREF (%d) for %x %s set (%02x)", st, num, i?"IS":"IS NOT",
1225 	    i);
1226 
1227 	return (DCMD_OK);
1228 }
1229 
1230 /*ARGSUSED*/
1231 static int
ind_byte(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1232 ind_byte(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1233 {
1234 	int num;
1235 
1236 	if (argc < 1) {
1237 		mdb_warn("must have an argument\n");
1238 		return (DCMD_ERR);
1239 	}
1240 	num = FBA_TO_LOG_NUM((int)mdb_strtoull(argv[0].a_un.a_str));
1241 	mdb_printf("IND_BYTE: %d", IND_BYTE(num));
1242 
1243 	return (DCMD_OK);
1244 }
1245 
1246 /*ARGSUSED*/
1247 static int
ind_bit(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1248 ind_bit(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1249 {
1250 	int num;
1251 
1252 	if (argc < 1) {
1253 		mdb_warn("must have an argument\n");
1254 		return (DCMD_ERR);
1255 	}
1256 	num = FBA_TO_LOG_NUM((int)mdb_strtoull(argv[0].a_un.a_str));
1257 	mdb_printf("IND_BIT: %d 0x%x", IND_BIT(num), IND_BIT(num));
1258 
1259 	return (DCMD_OK);
1260 }
1261 
1262 static char *
print_bit(uint_t bitmask)1263 print_bit(uint_t bitmask)
1264 {
1265 	int bitval = 1;
1266 	int i;
1267 
1268 	bitstr[32] = '\0';
1269 
1270 	for (i = 31; i >= 0; i--) {
1271 		if (bitmask & bitval) {
1272 			bitstr[i] = '1';
1273 		} else {
1274 			bitstr[i] = '0';
1275 		}
1276 		bitval *= 2;
1277 	}
1278 	return (bitstr);
1279 }
1280 
1281 /*ARGSUSED*/
1282 static int
rdc_bitmask(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1283 rdc_bitmask(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1284 {
1285 	uint_t bitmask = 0;
1286 	int first, st, en, pos, len;
1287 
1288 	if (argc < 2) {
1289 		mdb_warn("must have 2 args (pos, len)\n");
1290 		return (DCMD_ERR);
1291 	}
1292 	pos = (int)mdb_strtoull(argv[0].a_un.a_str);
1293 	len = (int)mdb_strtoull(argv[1].a_un.a_str);
1294 
1295 	if (len <= 0) {
1296 		mdb_printf("non positive len specified");
1297 		return (DCMD_ERR);
1298 	}
1299 
1300 	if ((len - pos) > 2048) {
1301 		mdb_printf("len out of range, 32 bit bitmask");
1302 		return (DCMD_ERR);
1303 	}
1304 
1305 	first = st = FBA_TO_LOG_NUM(pos);
1306 	en = FBA_TO_LOG_NUM(pos + len - 1);
1307 	while (st <= en) {
1308 		BMAP_BIT_SET((uchar_t *)&bitmask, st - first);
1309 		st++;
1310 	}
1311 
1312 	mdb_printf("bitmask for POS: %d LEN: %d : 0x%08x (%s)", pos, len,
1313 	    bitmask & 0xffffffff, print_bit(bitmask));
1314 	return (DCMD_OK);
1315 
1316 }
1317 
1318 /*
1319  * Dump the bitmap of the krdc structure indicated by the index
1320  * argument. Used by the ZatoIchi tests.
1321  */
1322 /*ARGSUSED*/
1323 static int
rdc_bmapdump(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1324 rdc_bmapdump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1325 {
1326 	rdc_k_info_t *rdc_k_info;
1327 	int index;
1328 	uintptr_t bmapaddr;
1329 	uintptr_t bmapdata;
1330 	unsigned char *data;
1331 	int bmapsize;
1332 	int i;
1333 	int st = 0;
1334 	int en = 0;
1335 
1336 	if (argc < 1) {
1337 		mdb_warn("must have index argument\n");
1338 		return (DCMD_ERR);
1339 	}
1340 
1341 	i = argc;
1342 	if (i == 3) {
1343 		en = (int)mdb_strtoull(argv[2].a_un.a_str);
1344 		en = FBA_TO_LOG_NUM(en);
1345 		i--;
1346 	}
1347 	if (i == 2) {
1348 		st = (int)mdb_strtoull(argv[1].a_un.a_str);
1349 		st = FBA_TO_LOG_NUM(st);
1350 	}
1351 
1352 	index = (int)mdb_strtoull(argv[0].a_un.a_str);
1353 	/*
1354 	 * Find out where in memory the rdc_k_kinfo array starts
1355 	 */
1356 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
1357 		mdb_warn("failed to read 'rdc_k_info'");
1358 		return (DCMD_ERR);
1359 	}
1360 	bmapaddr = (uintptr_t)(&rdc_k_info[index].bitmap_size);
1361 	if (mdb_vread(&bmapsize, sizeof (bmapsize), bmapaddr)
1362 	    != sizeof (bmapsize)) {
1363 		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
1364 		return (DCMD_ERR);
1365 	}
1366 
1367 	bmapaddr = (uintptr_t)(&rdc_k_info[index].dcio_bitmap);
1368 	if (mdb_vread(&bmapdata, sizeof (bmapdata), bmapaddr)
1369 	    != sizeof (bmapdata)) {
1370 		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
1371 		return (DCMD_ERR);
1372 	}
1373 	data = mdb_zalloc(bmapsize, UM_SLEEP);
1374 
1375 	if (mdb_vread(data, bmapsize, bmapdata) != bmapsize) {
1376 		mdb_warn("failed to read the bitmap data\n");
1377 		mdb_free(data, bmapsize);
1378 		return (DCMD_ERR);
1379 	}
1380 	mdb_printf("bitmap data address 0x%p bitmap size %d\n"
1381 	    "kinfo 0x%p\n", bmapdata, bmapsize, &rdc_k_info[index]);
1382 
1383 	if ((st < 0) || ((st/8) > bmapsize) || (en < 0)) {
1384 		mdb_warn("offset is out of range st %d bms %d en %d",
1385 		    st, bmapsize, en);
1386 		return (DCMD_ERR);
1387 	}
1388 	if (((en/8) > bmapsize) || (en == 0))
1389 		en = bmapsize * 8;
1390 
1391 	mdb_printf("bit start pos: %d bit end pos: %d\n\n", st, en);
1392 	st /= 8;
1393 	en /= 8;
1394 	for (i = st; i < en; i++) {
1395 		mdb_printf("%02x ", data[i] & 0xff);
1396 		if ((i % 16) == 15) {
1397 			int s = LOG_TO_FBA_NUM((i-15)*8);
1398 			int e = LOG_TO_FBA_NUM(((i+1)*8)) - 1;
1399 			mdb_printf(" fbas: %x - %x\n", s, e);
1400 		}
1401 	}
1402 	mdb_printf("\n");
1403 	mdb_free(data, bmapsize);
1404 	return (DCMD_OK);
1405 }
1406 
1407 /*
1408  * dump the bitmap reference count
1409  */
1410 /*ARGSUSED*/
1411 static int
rdc_brefdump(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1412 rdc_brefdump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1413 {
1414 	rdc_k_info_t *rdc_k_info;
1415 	int index;
1416 	uintptr_t bmapaddr;
1417 	uintptr_t bmapdata;
1418 	unsigned char *data;
1419 	int bmapsize;
1420 	int i;
1421 	int st = 0;
1422 	int en = 0;
1423 
1424 	if (argc < 1) {
1425 		mdb_warn("must have index argument\n");
1426 		return (DCMD_ERR);
1427 	}
1428 	index = (int)mdb_strtoull(argv[0].a_un.a_str);
1429 
1430 	i = argc;
1431 	if (i == 3) {
1432 		en = (int)mdb_strtoull(argv[2].a_un.a_str);
1433 		en = FBA_TO_LOG_NUM(en);
1434 		i--;
1435 
1436 	}
1437 	if (i == 2) {
1438 		st = (int)mdb_strtoull(argv[1].a_un.a_str);
1439 		st = FBA_TO_LOG_NUM(st);
1440 	}
1441 
1442 	/*
1443 	 * Find out where in memory the rdc_k_kinfo array starts
1444 	 */
1445 	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
1446 		mdb_warn("failed to read 'rdc_k_info'");
1447 		return (DCMD_ERR);
1448 	}
1449 	bmapaddr = (uintptr_t)(&rdc_k_info[index].bitmap_size);
1450 
1451 	if (mdb_vread(&bmapsize, sizeof (bmapsize), bmapaddr)
1452 	    != sizeof (bmapsize)) {
1453 		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
1454 		return (DCMD_ERR);
1455 	}
1456 
1457 	bmapsize *= 8;
1458 	bmapaddr = (uintptr_t)(&rdc_k_info[index].bitmap_ref);
1459 
1460 	if (mdb_vread(&bmapdata, sizeof (bmapdata), bmapaddr)
1461 	    != sizeof (bmapdata)) {
1462 		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
1463 		return (DCMD_ERR);
1464 	}
1465 	data = mdb_zalloc(bmapsize, UM_SLEEP);
1466 
1467 	if (mdb_vread(data, bmapsize, bmapdata) != bmapsize) {
1468 		mdb_warn("failed to read the bitmap data\n");
1469 		mdb_free(data, bmapsize);
1470 		return (DCMD_ERR);
1471 	}
1472 	mdb_printf("bitmap data address 0x%p bitmap size %d\n"
1473 	    "kinfo 0x%p\n", bmapdata, bmapsize, &rdc_k_info[index]);
1474 
1475 	if ((st < 0) || (st > bmapsize) || (en < 0)) {
1476 		mdb_warn("offset is out of range");
1477 	}
1478 	if ((en > bmapsize) || (en == 0))
1479 		en = bmapsize;
1480 
1481 	mdb_printf("bit start pos: %d bit end pos: %d\n\n", st, en);
1482 
1483 	for (i = st; i < en; i++) {
1484 		mdb_printf("%02x ", data[i] & 0xff);
1485 		if ((i % 16) == 15) {
1486 			int s = LOG_TO_FBA_NUM(i-15);
1487 			int e = LOG_TO_FBA_NUM(i+1) - 1;
1488 			mdb_printf(" fbas: 0x%x - 0x%x \n", s, e);
1489 		}
1490 	}
1491 	mdb_printf("\n");
1492 	mdb_free(data, bmapsize);
1493 	return (DCMD_OK);
1494 }
1495 
1496 static int
rdc_bmapnref(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1497 rdc_bmapnref(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1498 {
1499 	mdb_printf("\nRDC bitmap info\n");
1500 	rdc_bmapdump(addr, flags, argc, argv);
1501 	mdb_printf("RDC bitmap reference count info\n");
1502 	rdc_brefdump(addr, flags, argc, argv);
1503 	return (DCMD_OK);
1504 }
1505 
1506 #endif
1507 /*
1508  * MDB module linkage information:
1509  */
1510 
1511 static const mdb_dcmd_t dcmds[] = {
1512 	{ "rdc", NULL, "display sndr module info", rdc },
1513 	{ "rdc_buf", "?[-v]", "rdc_buf structure", rdc_buf },
1514 	{ "rdc_kinfo", "?[-av]", "rdc_k_info structure", rdc_kinfo },
1515 	{ "rdc_uinfo", "?[-av]", "rdc_u_info structure", rdc_uinfo },
1516 	{ "rdc_group", "?", "rdc group structure", rdc_group },
1517 	{ "rdc_srv", "?", "rdc_srv structure", rdc_srv },
1518 	{ "rdc_if", "?", "rdc_if structure", rdc_if },
1519 	{ "rdc_infodev", "?", "rdc_info_dev structure", rdc_infodev },
1520 	{ "rdc_k2u", "?", "rdc_kinfo to rdc_uinfo", rdc_k2u },
1521 	{ "rdc_u2k", "?", "rdc_uinfo to rdc_kinfo", rdc_u2k },
1522 	{ "rdc_aio", "?", "rdc_aio structure", rdc_aio},
1523 	{ "rdc_iohdr", "?", "rdc_iohdr structure", rdc_iohdr},
1524 #ifdef DEBUG
1525 	{ "rdc_setseq", "?", "Write seq field in group", rdc_setseq },
1526 	{ "rdc_setseqack", "?", "Write seqack field in group", rdc_setseqack },
1527 	{ "rdc_dset", "?", "Dump dset info", rdc_dset },
1528 	{ "rdc_bmapdump", "?", "Dump bitmap", rdc_bmapdump },
1529 	{ "rdc_brefdump", "?", "Dump bitmap reference count", rdc_brefdump },
1530 	{ "rdc_bmapnref", "?", "Dump bitmap and ref count", rdc_bmapnref },
1531 	{ "rdc_fba2log", "?", "fba to log num", fba_to_log_num },
1532 	{ "rdc_log2fba", "?", "log to fba num", log_to_fba_num },
1533 	{ "rdc_bitisset", "?", "check bit set", bmap_bit_isset },
1534 	{ "rdc_brefisset", "?", "check bit ref set", bmap_bitref_isset },
1535 	{ "rdc_indbyte", "?", "print indbyte", ind_byte },
1536 	{ "rdc_indbit", "?", "print indbit", ind_bit },
1537 	{ "rdc_bitmask", "?", "print bitmask for pos->len", rdc_bitmask },
1538 #endif
1539 	{ NULL }
1540 };
1541 
1542 
1543 static const mdb_walker_t walkers[] = {
1544 	{ "rdc_kinfo", "walk the rdc_k_info array",
1545 	    rdc_k_info_winit, rdc_k_info_wstep, rdc_k_info_wfini },
1546 	{ "rdc_uinfo", "walk the rdc_u_info array",
1547 	    rdc_u_info_winit, rdc_u_info_wstep, rdc_u_info_wfini },
1548 	{ "rdc_if", "walk rdc_if chain",
1549 	    rdc_if_winit, rdc_if_wstep, rdc_if_wfini },
1550 	{ NULL }
1551 };
1552 
1553 
1554 static const mdb_modinfo_t modinfo = {
1555 	MDB_API_VERSION, dcmds, walkers
1556 };
1557 
1558 
1559 const mdb_modinfo_t *
_mdb_init(void)1560 _mdb_init(void)
1561 {
1562 	return (&modinfo);
1563 }
1564