1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2003 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * mdb dcmds for selected structures from 31 * usr/src/uts/common/sys/crypto/common.h 32 */ 33 34 #include <sys/mdb_modapi.h> 35 #include <sys/modctl.h> 36 #include <sys/types.h> 37 #include <sys/crypto/api.h> 38 #include <sys/crypto/common.h> 39 #include <sys/crypto/spi.h> 40 #include <sys/crypto/impl.h> 41 #include "crypto_cmds.h" 42 43 /*ARGSUSED*/ 44 int 45 crypto_mechanism(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 46 { 47 crypto_mechanism_t mch; 48 49 if (!(flags & DCMD_ADDRSPEC)) 50 return (DCMD_USAGE); 51 52 if (mdb_vread(&mch, sizeof (crypto_mechanism_t), addr) == -1) { 53 mdb_warn("cannot read %p", addr); 54 return (DCMD_ERR); 55 } 56 /* XXX a future RFE will interpret cm_type */ 57 mdb_printf("cm_type\t%ll#x\n", mch.cm_type); 58 mdb_printf("cm_param\t%p\n", mch.cm_param); 59 mdb_printf("cm_param_len\t%u\n", mch.cm_param_len); 60 return (DCMD_OK); 61 } 62 63 /*ARGSUSED*/ 64 static void 65 iovec_prt(iovec_t *addr) 66 { 67 mdb_printf("iov_base\t%p\n", addr->iov_base); 68 mdb_printf("iov_len\t\t%d\n", addr->iov_len); 69 } 70 71 /*ARGSUSED*/ 72 static void 73 uio_prt(uio_t *addr) 74 { 75 char *segstrings[] = { 76 "UIO_USERSPACE", 77 "UIO_SYSSPACE", 78 "UIO_USERISPACE" 79 }; 80 iovec_t iov; 81 uio_t uio; 82 int i; 83 84 mdb_printf("uio\t%p\n", addr); 85 if (mdb_vread(&uio, sizeof (uio_t), (uintptr_t)addr) 86 == -1) { 87 mdb_warn("uio_prt: could not read uio"); 88 } 89 mdb_inc_indent(4); 90 for (i = 0; i < uio.uio_iovcnt; i++) { 91 if (mdb_vread(&iov, sizeof (iovec_t), 92 (uintptr_t)(uio.uio_iov +i)) 93 == -1) { 94 mdb_printf("uio_iov\t?????"); 95 mdb_warn("uio_prt: could not read uio_iov[%s]", i); 96 } else 97 iovec_prt(&iov); 98 } 99 mdb_dec_indent(4); 100 mdb_printf("uio_iovcnt\t%d\n", uio.uio_iovcnt); 101 mdb_printf("uio_offset\t%lld\n", uio.uio_offset); 102 mdb_printf("uio_segflg\t%s", segstrings[uio.uio_segflg]); 103 mdb_printf("uio_fmode\t0%o", (int)uio.uio_fmode); 104 mdb_printf("uio_limit\t%lld", uio.uio_limit); 105 mdb_printf("uio_resid\t%ld", uio.uio_resid); 106 } 107 108 static char *cdstrings[] = { 109 "INVALID FORMAT", 110 "CRYPTO_DATA_RAW", 111 "CRYPTO_DATA_UIO", 112 "CRYPTO_DATA_MBLK" 113 }; 114 115 /* 116 * Routine to print either of two structrually identical sub-structures -- 117 * with different naming conventions. Might be changed if we decide 118 * to merge the two. They are the cdu union from crypto_data_t and 119 * the one from crypto_dual_data_t. 120 */ 121 122 typedef union crypto_data_union { 123 iovec_t cdu_raw; /* Raw format */ 124 uio_t *cdu_uio; /* uio scatter-gather format */ 125 mblk_t *cdu_mp; /* The mblk chain */ 126 } crypto_data_union_t; 127 128 /*ARGSUSED*/ 129 static void 130 prt_cdu(crypto_data_union_t *cdu, int format, const char *prefix) 131 { 132 133 switch (format) { 134 case CRYPTO_DATA_RAW: 135 mdb_printf("%s_raw:\n", prefix); 136 mdb_inc_indent(4); 137 iovec_prt(&cdu->cdu_raw); 138 mdb_dec_indent(4); 139 break; 140 141 case CRYPTO_DATA_UIO: 142 mdb_printf("%s_uio:\n", prefix); 143 mdb_inc_indent(4); 144 uio_prt(cdu->cdu_uio); 145 mdb_dec_indent(4); 146 break; 147 148 case CRYPTO_DATA_MBLK: 149 mdb_printf("%s_mp:\t\t%p\n", prefix, cdu->cdu_mp); 150 break; 151 152 default: 153 mdb_printf("cm_format\t??????\n"); 154 break; 155 } 156 } 157 158 /*ARGSUSED*/ 159 int 160 crypto_data(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 161 { 162 crypto_data_t data; 163 164 if (!(flags & DCMD_ADDRSPEC)) 165 return (DCMD_USAGE); 166 167 if (mdb_vread(&data, sizeof (crypto_data_t), addr) == -1) { 168 mdb_warn("cannot read %p", addr); 169 return (DCMD_ERR); 170 } 171 if ((data.cd_format >= CRYPTO_DATA_RAW) && 172 (data.cd_format <= CRYPTO_DATA_MBLK)) 173 mdb_printf("cm_format\t%s\n", cdstrings[data.cd_format]); 174 else 175 mdb_printf("bad cm_format\t%d\n", data.cd_format); 176 mdb_printf("cm_offset\t%ld\n", data.cd_offset); 177 mdb_printf("cm_length\t%ld\n", data.cd_length); 178 mdb_printf("cm_miscdata\t%p\n", data.cd_miscdata); 179 mdb_inc_indent(4); 180 prt_cdu((crypto_data_union_t *)&data.cdu, data.cd_format, "cdu"); 181 mdb_dec_indent(4); 182 return (DCMD_OK); 183 } 184 185 /*ARGSUSED*/ 186 int 187 crypto_dual_data(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 188 { 189 crypto_dual_data_t ddata; 190 191 if (!(flags & DCMD_ADDRSPEC)) 192 return (DCMD_USAGE); 193 194 if (mdb_vread(&ddata, sizeof (crypto_dual_data_t), addr) == -1) { 195 mdb_warn("cannot read %p", addr); 196 return (DCMD_ERR); 197 } 198 if ((ddata.dd_format > CRYPTO_DATA_RAW) && 199 (ddata.dd_format <= CRYPTO_DATA_MBLK)) 200 mdb_printf("dd_format\t%s\n", cdstrings[ddata.dd_format]); 201 else 202 mdb_printf("bad dd_format\t%d\n", ddata.dd_format); 203 mdb_printf("dd_offset1\t%ld\n", ddata.dd_offset1); 204 mdb_printf("dd_len1\t%ld\n", ddata.dd_len1); 205 mdb_printf("dd_offset2\t%ld\n", ddata.dd_offset2); 206 mdb_printf("dd_len2\t%ld\n", ddata.dd_len2); 207 mdb_printf("dd_miscdata\t%p\n", ddata.dd_miscdata); 208 mdb_printf("cdu:\n"); 209 mdb_inc_indent(4); 210 prt_cdu((crypto_data_union_t *)&ddata.dd_data.cdu, ddata.dd_format, 211 "ddu"); 212 mdb_dec_indent(4); 213 return (DCMD_OK); 214 } 215 216 217 /*ARGSUSED*/ 218 int 219 crypto_key(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 220 { 221 crypto_key_t key; 222 223 if (!(flags & DCMD_ADDRSPEC)) 224 return (DCMD_USAGE); 225 226 if (mdb_vread(&key, sizeof (crypto_key_t), addr) == -1) { 227 mdb_warn("cannot read %p", addr); 228 return (DCMD_ERR); 229 } 230 switch (key.ck_format) { 231 case CRYPTO_KEY_RAW: 232 mdb_printf("ck_format:\tCRYPTO_KEY_RAW\n"); 233 mdb_printf( 234 "cku_data.cku_key_value.cku_data.cku_v_length:\t%d\n", 235 key.cku_data.cku_key_value.cku_v_length); 236 mdb_printf("cku_data.cku_key_value.cku_v_data:\t%p\n", 237 key.cku_data.cku_key_value.cku_v_data); 238 break; 239 case CRYPTO_KEY_REFERENCE: 240 mdb_printf("ck_format:\tCRYPTO_KEY_REFERENCE\n"); 241 mdb_printf("cku_data.cku_key_id:\t%u\n", 242 key.cku_data.cku_key_id); 243 break; 244 case CRYPTO_KEY_ATTR_LIST: 245 mdb_printf("ck_format:\tCRYPTO_KEY_ATTR_LIST\n"); 246 mdb_printf("cku_data.cku_key_attrs.cku_a_count:\t%u\n", 247 key.cku_data.cku_key_attrs.cku_a_count); 248 mdb_printf("cku_data.cku_key_attrs.cku_o_oattr:\t%p\n", 249 key.cku_data.cku_key_attrs.cku_a_oattr); 250 break; 251 default: 252 mdb_printf("ck_format:\t\t?????\n"); 253 break; 254 } 255 return (DCMD_OK); 256 } 257