xref: /titanic_44/usr/src/cmd/mdb/common/modules/crypto/sched_impl.c (revision fc10aa482a49e233a416c80fd303cf3b857329eb)
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 /*
23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <stdio.h>
27 #include <sys/mdb_modapi.h>
28 #include <sys/modctl.h>
29 #include <sys/types.h>
30 #include <sys/crypto/api.h>
31 #include <sys/crypto/common.h>
32 #include <sys/crypto/api.h>
33 #include <sys/crypto/sched_impl.h>
34 #include "crypto_cmds.h"
35 
36 static void
prt_an_state(int state)37 prt_an_state(int state)
38 {
39 	switch (state) {
40 		case REQ_ALLOCATED:
41 			mdb_printf("REQ_ALLOCATED  ");
42 			break;
43 		case REQ_WAITING:
44 			mdb_printf("REQ_WAITING    ");
45 			break;
46 		case REQ_INPROGRESS:
47 			mdb_printf("REQ_INPROGRESS ");
48 			break;
49 		case REQ_DONE:
50 			mdb_printf("REQ_DONE       ");
51 			break;
52 		case REQ_CANCELED:
53 			mdb_printf("REQ_CANCELED   ");
54 			break;
55 		default:
56 			mdb_printf("? %d ??        ", state);
57 			break;
58 	}
59 }
60 
61 
62 static const mdb_bitmask_t call_flags[] = {
63 	{ "CRYPTO_ALWAYS_QUEUE", CRYPTO_ALWAYS_QUEUE, CRYPTO_ALWAYS_QUEUE },
64 	{ "CRYPTO_NOTIFY_OPDONE", CRYPTO_NOTIFY_OPDONE, CRYPTO_NOTIFY_OPDONE },
65 	{ "CRYPTO_SKIP_REQID", CRYPTO_SKIP_REQID, CRYPTO_SKIP_REQID },
66 	{ NULL, 0, 0 }
67 };
68 
69 /*ARGSUSED*/
70 static int
kcf_areq_node_simple(kcf_areq_node_t * areqn)71 kcf_areq_node_simple(kcf_areq_node_t *areqn)
72 {
73 	mdb_printf("\nan_type: ");
74 	if (areqn->an_type != CRYPTO_ASYNCH)
75 		mdb_printf("%-8d    ", areqn->an_type);
76 	else
77 		mdb_printf("CRYPTO_ASYNCH");
78 
79 	mdb_printf("\nan_state: ");
80 	prt_an_state(areqn->an_state);
81 
82 	mdb_printf("\nan_context: %-16p\t", areqn->an_context);
83 	mdb_printf("an_is_my_turn: %s\t     ", areqn->an_is_my_turn == B_FALSE ?
84 	    "B_FALSE" : "B_TRUE");
85 
86 	mdb_printf("\ncr_reqid: %lx\n", areqn->an_reqarg.cr_reqid);
87 	return (DCMD_OK);
88 }
89 /*
90  * Verbose print of kcf_areq_node_t
91  */
92 static int
v_kcf_areq_node(kcf_areq_node_t * areqn)93 v_kcf_areq_node(kcf_areq_node_t *areqn)
94 {
95 
96 	/* contents only -- the address is printed elsewhere */
97 	/* First column */
98 
99 	mdb_printf("\n%16s:  ", "an_type");
100 	if (areqn->an_type != CRYPTO_ASYNCH)
101 		mdb_printf("%-8d    ", areqn->an_type);
102 	else
103 		mdb_printf("CRYPTO_ASYNCH");
104 
105 	/* Second column */
106 	mdb_printf("\t\t%16s:  %p\n", "an_lock", areqn->an_lock);
107 
108 	/* First column */
109 	mdb_printf("%16s:  ", "an_state");
110 	prt_an_state(areqn->an_state);
111 
112 	/* Second column */
113 	mdb_printf("%14s:  next 4 items\n", "an_reqarg");
114 
115 	/* First column again */
116 	mdb_printf("%16s: '%16b'", "cr_flag", areqn->an_reqarg.cr_flag,
117 	    call_flags);
118 
119 	/* Second column */
120 	mdb_printf("\t%16s:  %p\n", "cr_callback_func",
121 	    areqn->an_reqarg.cr_callback_func);
122 
123 	/* First column again */
124 	mdb_printf("%16s:  %-16p", "cr_callback_arg",
125 	    areqn->an_reqarg.cr_callback_arg);
126 
127 	/* Second column */
128 	mdb_printf("\t%16s:  %lx\n", "cr_reqid",
129 	    (ulong_t)areqn->an_reqarg.cr_reqid);
130 
131 	/* First column again */
132 	mdb_printf("%16s:  %d", "an_params.rp_opgrp",
133 	    areqn->an_params.rp_opgrp);
134 
135 	/* Second column */
136 	mdb_printf("\t%16s:  %d\n", "an_params.rp_optype",
137 	    areqn->an_params.rp_optype);
138 
139 	/* First column again */
140 	mdb_printf("%16s:  %-16p", "an_context",
141 	    areqn->an_context);
142 
143 	/* Second column */
144 	mdb_printf("\t%16s:  %p\n", "an_ctxchain_next",
145 	    areqn->an_ctxchain_next);
146 
147 	/* First column again */
148 	mdb_printf("%16s:  %s", "an_is_my_turn",
149 	    areqn->an_is_my_turn == B_FALSE ? "B_FALSE" : "B_TRUE");
150 
151 	/* Second column */
152 	mdb_printf("\t\t%16s:  %s\n", "an_isdual",
153 	    areqn->an_isdual == B_FALSE ? "B_FALSE" : "B_TRUE");
154 
155 	/* First column again */
156 	mdb_printf("%16s:  %p", "an_next",
157 	    areqn->an_next);
158 
159 	/* Second column */
160 	mdb_printf("\t\t%16s:  %p\n", "an_prev", areqn->an_prev);
161 
162 	/* First column again */
163 	mdb_printf("%16s:  %p", "an_provider",
164 	    areqn->an_provider);
165 
166 	/* Second column */
167 	mdb_printf("\t\t%16s:  %p\n", "an_idnext", areqn->an_idnext);
168 
169 	/* First column again */
170 	mdb_printf("%16s:  %p", "an_idprev",
171 	    areqn->an_idprev);
172 
173 	/* Second column */
174 	mdb_printf("\t\t%16s:  %hx\n", "an_done", areqn->an_done);
175 
176 	/* First column again */
177 	mdb_printf("%16s:  %d\n", "an_refcnt",
178 	    areqn->an_refcnt);
179 
180 	return (DCMD_OK);
181 }
182 /*ARGSUSED*/
183 int
kcf_areq_node(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)184 kcf_areq_node(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
185 {
186 	kcf_areq_node_t areqn;
187 	uint_t opt_v = FALSE;
188 
189 
190 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &opt_v,
191 	    NULL) != argc)
192 			return (DCMD_USAGE);
193 
194 	/*
195 	 * read even if we're looping, because the cbdata design does not
196 	 * apply to mdb_pwalk_dcmd
197 	 */
198 	if (mdb_vread(&areqn, sizeof (kcf_areq_node_t), addr) == -1) {
199 		mdb_warn("cannot read %p", addr);
200 		return (DCMD_ERR);
201 	}
202 	if (opt_v)	/* verbose */
203 		return (v_kcf_areq_node(&areqn));
204 	else
205 		return (kcf_areq_node_simple(&areqn));
206 }
207 
208 /*ARGSUSED*/
209 int
kcf_global_swq(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)210 kcf_global_swq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
211 {
212 	kcf_global_swq_t swq;
213 	kcf_global_swq_t *ptr;
214 
215 	if (!(flags & DCMD_ADDRSPEC)) {
216 		if (mdb_readsym(&ptr, sizeof (uintptr_t), "gswq")
217 		    == -1) {
218 			mdb_warn("cannot read gswq");
219 			return (DCMD_ERR);
220 		}
221 	}
222 	else
223 		ptr = (kcf_global_swq_t *)addr;
224 
225 	if (mdb_vread(&swq, sizeof (kcf_global_swq_t), (uintptr_t)ptr) == -1) {
226 		mdb_warn("cannot read %p", ptr);
227 		return (DCMD_ERR);
228 	}
229 	mdb_printf("gs_lock (mutex):\t%p\n", swq.gs_lock);
230 	mdb_printf("gs_cv:\t%hx\n", swq.gs_cv._opaque);
231 	mdb_printf("gs_njobs:\t%u\n", swq.gs_njobs);
232 	mdb_printf("gs_maxjobs:\t%u\n", swq.gs_maxjobs);
233 	mdb_printf("gs_first:\t%p\n", swq.gs_first);
234 	mdb_printf("gs_last:\t%p\n", swq.gs_last);
235 	return (mdb_pwalk_dcmd("an_next", "kcf_areq_node", argc,
236 	    argv, (uintptr_t)swq.gs_first));
237 }
238 
239 static int
areq_walk_init_common(mdb_walk_state_t * wsp,boolean_t use_first)240 areq_walk_init_common(mdb_walk_state_t *wsp, boolean_t use_first)
241 {
242 	kcf_global_swq_t gswq_copy;
243 	uintptr_t gswq_ptr;
244 
245 	if (mdb_readsym(&gswq_ptr, sizeof (gswq_ptr), "gswq") == -1) {
246 		mdb_warn("failed to read 'gswq'");
247 		return (WALK_ERR);
248 	}
249 	if (mdb_vread(&gswq_copy, sizeof (gswq_copy), gswq_ptr) == -1) {
250 		mdb_warn("cannot read %p", gswq_ptr);
251 		return (WALK_ERR);
252 	}
253 	if ((wsp->walk_addr = (use_first ? (uintptr_t)gswq_copy.gs_first :
254 	    (uintptr_t)gswq_copy.gs_last)) == NULL) {
255 		mdb_printf("Global swq is empty\n");
256 		return (WALK_DONE);
257 	}
258 	wsp->walk_data = mdb_alloc(sizeof (kcf_areq_node_t), UM_SLEEP);
259 	return (WALK_NEXT);
260 }
261 
262 int
areq_first_walk_init(mdb_walk_state_t * wsp)263 areq_first_walk_init(mdb_walk_state_t *wsp)
264 {
265 	return (areq_walk_init_common(wsp, B_TRUE));
266 }
267 
268 int
areq_last_walk_init(mdb_walk_state_t * wsp)269 areq_last_walk_init(mdb_walk_state_t *wsp)
270 {
271 	return (areq_walk_init_common(wsp, B_FALSE));
272 }
273 
274 typedef enum idwalk_type {
275 	IDNEXT,		/* an_idnext */
276 	IDPREV,		/* an_idprev */
277 	CTXCHAIN	/* an_ctxchain_next */
278 } idwalk_type_t;
279 
280 static int
an_id_walk_init(mdb_walk_state_t * wsp,idwalk_type_t type)281 an_id_walk_init(mdb_walk_state_t *wsp, idwalk_type_t type)
282 {
283 	kcf_areq_node_t *adn;
284 
285 	if (wsp->walk_addr == NULL) {
286 		mdb_warn("must give kcf_areq_node address\n");
287 		return (WALK_ERR);
288 	}
289 	adn = wsp->walk_data = mdb_alloc(sizeof (kcf_areq_node_t), UM_SLEEP);
290 
291 	if (mdb_vread(adn, sizeof (kcf_areq_node_t), wsp->walk_addr) == -1) {
292 		mdb_warn("cannot read %p", wsp->walk_addr);
293 		return (WALK_ERR);
294 	}
295 
296 	switch (type) {
297 		case IDNEXT:
298 			wsp->walk_addr = (uintptr_t)adn->an_idnext;
299 			break;
300 		case IDPREV:
301 			wsp->walk_addr = (uintptr_t)adn->an_idprev;
302 			break;
303 		case CTXCHAIN:
304 			wsp->walk_addr = (uintptr_t)adn->an_ctxchain_next;
305 			break;
306 		default:
307 			mdb_warn("Bad structure member in walk_init\n");
308 			return (WALK_ERR);
309 	}
310 	return (WALK_NEXT);
311 }
312 int
an_idnext_walk_init(mdb_walk_state_t * wsp)313 an_idnext_walk_init(mdb_walk_state_t *wsp)
314 {
315 	return (an_id_walk_init(wsp, IDNEXT));
316 }
317 int
an_idprev_walk_init(mdb_walk_state_t * wsp)318 an_idprev_walk_init(mdb_walk_state_t *wsp)
319 {
320 	return (an_id_walk_init(wsp, IDPREV));
321 }
322 int
an_ctxchain_walk_init(mdb_walk_state_t * wsp)323 an_ctxchain_walk_init(mdb_walk_state_t *wsp)
324 {
325 	return (an_id_walk_init(wsp, CTXCHAIN));
326 }
327 /*
328  * At each step, read a kcf_areq_node_t into our private storage, then invoke
329  * the callback function.  We terminate when we reach a NULL type pointer.
330  */
331 static int
an_id_walk_step(mdb_walk_state_t * wsp,idwalk_type_t type)332 an_id_walk_step(mdb_walk_state_t *wsp, idwalk_type_t type)
333 {
334 	int status;
335 	kcf_areq_node_t *ptr;
336 
337 	if (wsp->walk_addr == NULL)	/* then we're done */
338 		return (WALK_DONE);
339 
340 	ptr = wsp->walk_data;
341 
342 	if (mdb_vread(wsp->walk_data, sizeof (kcf_areq_node_t),
343 	    wsp->walk_addr) == -1) {
344 		mdb_warn("cannot read %p", wsp->walk_addr);
345 		return (WALK_ERR);
346 	}
347 
348 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
349 	    wsp->walk_cbdata);
350 
351 	switch (type) {
352 		case IDNEXT:
353 			if ((wsp->walk_addr =
354 			    (uintptr_t)ptr->an_idnext) == NULL)
355 				return (WALK_DONE);
356 			break;
357 
358 		case IDPREV:
359 			if ((wsp->walk_addr =
360 			    (uintptr_t)ptr->an_idprev) == NULL)
361 				return (WALK_DONE);
362 			break;
363 
364 		case CTXCHAIN:
365 			if ((wsp->walk_addr =
366 			    (uintptr_t)ptr->an_ctxchain_next) == NULL)
367 				return (WALK_DONE);
368 			break;
369 
370 		default:
371 			mdb_warn("Bad structure member in walk_step\n");
372 			return (WALK_ERR);
373 	}
374 	return (status);
375 }
376 int
an_idnext_walk_step(mdb_walk_state_t * wsp)377 an_idnext_walk_step(mdb_walk_state_t *wsp)
378 {
379 	return (an_id_walk_step(wsp, IDNEXT));
380 }
381 int
an_idprev_walk_step(mdb_walk_state_t * wsp)382 an_idprev_walk_step(mdb_walk_state_t *wsp)
383 {
384 	return (an_id_walk_step(wsp, IDPREV));
385 }
386 int
an_ctxchain_walk_step(mdb_walk_state_t * wsp)387 an_ctxchain_walk_step(mdb_walk_state_t *wsp)
388 {
389 	return (an_id_walk_step(wsp, CTXCHAIN));
390 }
391 
392 /*
393  * The walker's fini function is invoked at the end of each walk.  Since we
394  * dynamically allocated a kcf_areq_node_t in areq_walk_init,
395  * we must free it now.
396  */
397 void
areq_walk_fini(mdb_walk_state_t * wsp)398 areq_walk_fini(mdb_walk_state_t *wsp)
399 {
400 #ifdef	DEBUG
401 	mdb_printf("...end of kcf_areq_node walk\n");
402 #endif
403 	mdb_free(wsp->walk_data, sizeof (kcf_areq_node_t));
404 }
405 
406 /*
407  * At each step, read a kcf_areq_node_t into our private storage, then invoke
408  * the callback function.  We terminate when we reach a NULL an_next pointer
409  * or a NULL an_prev pointer. use_next flag indicates which one to check.
410  */
411 static int
an_walk_step_common(mdb_walk_state_t * wsp,boolean_t use_next)412 an_walk_step_common(mdb_walk_state_t *wsp, boolean_t use_next)
413 {
414 	int status;
415 	kcf_areq_node_t *ptr;
416 
417 	ptr = (kcf_areq_node_t *)wsp->walk_data;
418 
419 	if (mdb_vread(wsp->walk_data, sizeof (kcf_areq_node_t),
420 	    wsp->walk_addr) == -1) {
421 		mdb_warn("failed to read kcf_areq_node at %p", wsp->walk_addr);
422 		return (WALK_DONE);
423 	}
424 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
425 	    wsp->walk_cbdata);
426 
427 	if ((wsp->walk_addr = (use_next ? (uintptr_t)ptr->an_next :
428 	    (uintptr_t)ptr->an_prev)) == NULL)
429 		return (WALK_DONE);
430 
431 	return (status);
432 }
433 
434 int
an_next_walk_step(mdb_walk_state_t * wsp)435 an_next_walk_step(mdb_walk_state_t *wsp)
436 {
437 	return (an_walk_step_common(wsp, B_TRUE));
438 }
439 
440 int
an_prev_walk_step(mdb_walk_state_t * wsp)441 an_prev_walk_step(mdb_walk_state_t *wsp)
442 {
443 	return (an_walk_step_common(wsp, B_FALSE));
444 }
445 
446 /*
447  * Walker data for reqid_table walking
448  */
449 typedef	struct reqid_data {
450 	kcf_reqid_table_t rd_table;
451 	kcf_reqid_table_t *rd_tbl_ptrs[REQID_TABLES];
452 	int		rd_cur_index;
453 } reqid_data_t;
454 
455 typedef struct reqid_cb_data {
456 	crypto_req_id_t cb_reqid;
457 	int verbose;
458 	int found;
459 } reqid_cb_data_t;
460 
461 extern int crypto_pr_reqid(uintptr_t, reqid_data_t *, reqid_cb_data_t *);
462 
463 
464 int
reqid_table_walk_init(mdb_walk_state_t * wsp)465 reqid_table_walk_init(mdb_walk_state_t *wsp)
466 {
467 	reqid_data_t *wdata;
468 	reqid_cb_data_t *cbdata;
469 
470 	wsp->walk_callback = (mdb_walk_cb_t)crypto_pr_reqid;
471 
472 	wsp->walk_data = mdb_alloc(sizeof (reqid_data_t), UM_SLEEP);
473 
474 	/* see if the walker was called from the command line or mdb_pwalk */
475 	if (wsp->walk_cbdata == NULL) {		/* command line */
476 		if ((wsp->walk_cbdata = mdb_zalloc(sizeof (reqid_cb_data_t),
477 		    UM_SLEEP)) == NULL) {
478 			mdb_warn("couldn't get cb memory for "
479 			    "reqid_table_walker");
480 			return (WALK_ERR);
481 		}
482 		/* initialize for a simple walk, as opposed to a reqid search */
483 		cbdata = wsp->walk_cbdata;
484 		cbdata->verbose = TRUE;
485 		cbdata->cb_reqid = 0;
486 	}
487 
488 	wdata = (reqid_data_t *)wsp->walk_data;
489 
490 	if (mdb_readsym(wdata->rd_tbl_ptrs, sizeof (wdata->rd_tbl_ptrs),
491 	    "kcf_reqid_table") == -1) {
492 		mdb_warn("failed to read 'kcf_reqid_table'");
493 		return (WALK_ERR);
494 
495 	}
496 	wdata->rd_cur_index = 0;
497 	wsp->walk_addr = (uintptr_t)wdata->rd_tbl_ptrs[wdata->rd_cur_index];
498 
499 
500 	return (WALK_NEXT);
501 }
502 
503 /*
504  * At each step, read a kcf_reqid_table_t into our private storage, then invoke
505  * the callback function.  We terminate when we reach a
506  */
507 int
reqid_table_walk_step(mdb_walk_state_t * wsp)508 reqid_table_walk_step(mdb_walk_state_t *wsp)
509 {
510 	int status;
511 	reqid_data_t *wdata;
512 
513 
514 	wdata = wsp->walk_data;
515 	wsp->walk_addr = (uintptr_t)wdata->rd_tbl_ptrs[wdata->rd_cur_index];
516 
517 #ifdef DEBUG
518 	mdb_printf(
519 	    "DEBUG: kcf_reqid_table at %p, sizeof kcf_reqid_table_t = %d\n",
520 	    wsp->walk_addr, sizeof (kcf_reqid_table_t));
521 #endif
522 
523 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
524 	    wsp->walk_cbdata);
525 
526 	/* get ready for next call */
527 	wdata->rd_cur_index++;
528 	if (wdata->rd_cur_index >= REQID_TABLES)
529 		return (WALK_DONE);
530 	return (status);
531 }
532 
533 /*
534  * The walker's fini function is invoked at the end of each walk.  Since we
535  * dynamically allocated a reqid_data_t in areq_walk_init,
536  * we must free it now.
537  */
538 void
reqid_table_walk_fini(mdb_walk_state_t * wsp)539 reqid_table_walk_fini(mdb_walk_state_t *wsp)
540 {
541 #ifdef DEBUG
542 	mdb_printf("...end of kcf_reqid walk\n");
543 #endif
544 	mdb_free(wsp->walk_data, sizeof (reqid_data_t));
545 }
546 
547 /*
548  * If there's an argument beyond -v, then we're looking for a specific
549  * reqid, otherwise, print any non-null kcf_areq things we run across.
550  */
551 
552 int
crypto_pr_reqid(uintptr_t addr,reqid_data_t * data,reqid_cb_data_t * cbdata)553 crypto_pr_reqid(uintptr_t addr, reqid_data_t *data, reqid_cb_data_t *cbdata)
554 {
555 	kcf_areq_node_t node;
556 	int i;
557 	int needhdr = TRUE;
558 
559 	if (addr == NULL) {
560 		mdb_printf("kcf_reqid_table[%d] = NULL\n", data->rd_cur_index);
561 		return (WALK_NEXT);
562 	}
563 
564 	if (mdb_vread(&(data->rd_table), sizeof (kcf_reqid_table_t),
565 	    addr) == -1) {
566 		mdb_warn("failed to read kcf_reqid_table at %p",
567 		    addr);
568 		return (WALK_ERR);
569 	}
570 
571 	/* Loop over all rt_idhash's */
572 	for (i = 0; i < REQID_BUCKETS; i++) {
573 	    uint_t number_in_chain = 0;
574 	    uintptr_t node_addr;
575 
576 	    /* follow the an_idnext chains for each bucket */
577 	    do {
578 		/* read kcf_areq_node */
579 		if (number_in_chain == 0)
580 		    node_addr = (uintptr_t)data->rd_table.rt_idhash[i];
581 		else
582 		    /*LINTED*/
583 		    node_addr = (uintptr_t)node.an_idnext;
584 #ifdef DEBUG
585 		mdb_printf("DEBUG: node_addr = %p\n", node_addr);
586 #endif
587 
588 		if (node_addr == NULL)
589 			break;  /* skip */
590 
591 		if (mdb_vread(&node, sizeof (kcf_areq_node_t), node_addr)
592 		    == -1) {
593 			if (cbdata->verbose == TRUE)
594 			    mdb_printf(
595 				"cannot read rt_idhash %d an_idnext %d\n",
596 				i, number_in_chain);
597 			break;
598 		}
599 		/* see if we want to print it */
600 		if ((cbdata->cb_reqid == 0) ||
601 		    (node.an_reqarg.cr_reqid == cbdata->cb_reqid)) {
602 			cbdata->found = TRUE;  /* printed if false || reqid */
603 			/* is this the first rd_idhash found for this table? */
604 			if (needhdr == TRUE) {
605 			    /* print both indices in bold */
606 			    mdb_printf("%<b>kcf_reqid_table[%lu] at %p:%</b>\n",
607 				data->rd_cur_index, addr);
608 			    mdb_printf("\trt_lock:  %p\trt_curid: %llx\n",
609 				data->rd_table.rt_lock,
610 				data->rd_table.rt_curid);
611 			    needhdr = FALSE;
612 			}
613 			/* print kcf_areq_node */
614 			if (number_in_chain < 1)
615 			    mdb_printf(
616 				"    %<b>rt_idhash[%lu%]%</b> = %<b>%p:%</b>\n",
617 				i, node_addr);
618 			else
619 			    mdb_printf(
620 				"    rt_idhash[%lu%]"
621 					" an_idnext %d  = %<b>%p:%</b>\n",
622 					i, number_in_chain, node_addr);
623 			mdb_inc_indent(8);
624 
625 			/* if we're looking for one and only one reqid */
626 			/* do it REALLY verbose */
627 			if ((node.an_reqarg.cr_reqid == cbdata->cb_reqid) &&
628 			    (cbdata->cb_reqid != 0))
629 				v_kcf_areq_node(&node);
630 			else if (cbdata->verbose == TRUE)
631 			/*
632 			 * verbose for this walker means non-verbose for
633 			 * the kcf_areq_node details
634 			 */
635 			    kcf_areq_node_simple(&node);
636 			mdb_dec_indent(8);
637 		}
638 		/* if we only wanted one reqid, quit now */
639 		if (node.an_reqarg.cr_reqid == cbdata->cb_reqid) {
640 			return (WALK_DONE);
641 		}
642 
643 		number_in_chain++;
644 
645 	    } while (node.an_idnext != NULL); /* follow chain in same bucket */
646 
647 	}  /* for each REQID_BUCKETS */
648 
649 	if ((needhdr == TRUE) && (cbdata->cb_reqid == 0)) {
650 	    mdb_printf("%kcf_reqid_table[%lu]: %p\n",
651 		data->rd_cur_index, addr);
652 	}
653 	return (WALK_NEXT);
654 }
655 
656 /*ARGSUSED*/
657 int
crypto_find_reqid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)658 crypto_find_reqid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
659 {
660 	const mdb_arg_t *argp = NULL;
661 	reqid_cb_data_t cbdata;
662 	int i, status;
663 
664 	cbdata.cb_reqid = 0L;
665 	cbdata.verbose = FALSE;
666 	cbdata.found = FALSE;
667 
668 	if (flags & DCMD_ADDRSPEC) {
669 		mdb_printf("use addr ::kcf_reqid_table\n");
670 		return (DCMD_USAGE);
671 	}
672 	if ((i = mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE,
673 	    &cbdata.verbose, NULL)) != argc) {
674 		if (argc - i > 1)
675 			return (DCMD_USAGE);
676 	}
677 
678 	if (argc > i)
679 		argp = &argv[i];
680 
681 	if ((argp != NULL)) {
682 		if (argp->a_type == MDB_TYPE_IMMEDIATE)
683 			cbdata.cb_reqid = argp->a_un.a_val;
684 		else
685 			cbdata.cb_reqid = (crypto_req_id_t)
686 			    mdb_strtoull(argp->a_un.a_str);
687 	}
688 	status = mdb_pwalk("kcf_reqid_table", (mdb_walk_cb_t)crypto_pr_reqid,
689 	    &cbdata, addr);
690 
691 	if ((cbdata.cb_reqid != 0L) && (cbdata.found == FALSE))
692 		mdb_printf("ID 0x%lx not found\n", cbdata.cb_reqid);
693 #ifdef DEBUG
694 	else
695 		mdb_printf("DEBUG: cbdata.db_reqid = %lx, cbdata.found = %d\n",
696 		    cbdata.cb_reqid, cbdata.found);
697 #endif
698 
699 	return (status);
700 }
701 
702 int
kcf_reqid_table_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)703 kcf_reqid_table_dcmd(uintptr_t addr, uint_t flags, int argc,
704     const mdb_arg_t *argv)
705 {
706 	reqid_data_t wdata;
707 	reqid_cb_data_t cbdata;
708 
709 	if (!(flags & DCMD_ADDRSPEC))
710 		return (DCMD_USAGE);
711 
712 	memset(&wdata, 0, sizeof (wdata));
713 	memset(&cbdata, 0, sizeof (cbdata));
714 
715 	if ((mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE,
716 	    &cbdata.verbose, NULL)) != argc) {
717 			return (DCMD_USAGE);
718 	}
719 	crypto_pr_reqid(addr, &wdata, &cbdata);
720 	return (DCMD_OK);
721 }
722