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 /* 28 * mdb dcmds for selected structures from 29 * usr/src/uts/common/sys/crypto/common.h 30 */ 31 32 #include <sys/mdb_modapi.h> 33 #include <sys/modctl.h> 34 #include <sys/types.h> 35 #include <sys/crypto/api.h> 36 #include <sys/crypto/common.h> 37 #include <sys/crypto/spi.h> 38 #include <sys/crypto/impl.h> 39 #include "crypto_cmds.h" 40 41 /*ARGSUSED*/ 42 int 43 crypto_mechanism(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 44 { 45 crypto_mechanism_t mch; 46 47 if (!(flags & DCMD_ADDRSPEC)) 48 return (DCMD_USAGE); 49 50 if (mdb_vread(&mch, sizeof (crypto_mechanism_t), addr) == -1) { 51 mdb_warn("cannot read %p", addr); 52 return (DCMD_ERR); 53 } 54 /* XXX a future RFE will interpret cm_type */ 55 mdb_printf("cm_type\t%ll#x\n", mch.cm_type); 56 mdb_printf("cm_param\t%p\n", mch.cm_param); 57 mdb_printf("cm_param_len\t%u\n", mch.cm_param_len); 58 return (DCMD_OK); 59 } 60 61 /*ARGSUSED*/ 62 static void 63 iovec_prt(iovec_t *addr) 64 { 65 mdb_printf("iov_base\t%p\n", addr->iov_base); 66 mdb_printf("iov_len\t\t%d\n", addr->iov_len); 67 } 68 69 /*ARGSUSED*/ 70 static void 71 uio_prt(uio_t *addr) 72 { 73 char *segstrings[] = { 74 "UIO_USERSPACE", 75 "UIO_SYSSPACE", 76 "UIO_USERISPACE" 77 }; 78 iovec_t iov; 79 uio_t uio; 80 int i; 81 82 mdb_printf("uio\t%p\n", addr); 83 if (mdb_vread(&uio, sizeof (uio_t), (uintptr_t)addr) 84 == -1) { 85 mdb_warn("uio_prt: could not read uio"); 86 } 87 mdb_inc_indent(4); 88 for (i = 0; i < uio.uio_iovcnt; i++) { 89 if (mdb_vread(&iov, sizeof (iovec_t), 90 (uintptr_t)(uio.uio_iov +i)) 91 == -1) { 92 mdb_printf("uio_iov\t?????"); 93 mdb_warn("uio_prt: could not read uio_iov[%s]", i); 94 } else 95 iovec_prt(&iov); 96 } 97 mdb_dec_indent(4); 98 mdb_printf("uio_iovcnt\t%d\n", uio.uio_iovcnt); 99 mdb_printf("uio_offset\t%lld\n", uio.uio_offset); 100 mdb_printf("uio_segflg\t%s", segstrings[uio.uio_segflg]); 101 mdb_printf("uio_fmode\t0%o", (int)uio.uio_fmode); 102 mdb_printf("uio_limit\t%lld", uio.uio_limit); 103 mdb_printf("uio_resid\t%ld", uio.uio_resid); 104 } 105 106 static char *cdstrings[] = { 107 "INVALID FORMAT", 108 "CRYPTO_DATA_RAW", 109 "CRYPTO_DATA_UIO", 110 "CRYPTO_DATA_MBLK" 111 }; 112 113 /* 114 * Routine to print either of two structrually identical sub-structures -- 115 * with different naming conventions. Might be changed if we decide 116 * to merge the two. They are the cdu union from crypto_data_t and 117 * the one from crypto_dual_data_t. 118 */ 119 120 typedef union crypto_data_union { 121 iovec_t cdu_raw; /* Raw format */ 122 uio_t *cdu_uio; /* uio scatter-gather format */ 123 mblk_t *cdu_mp; /* The mblk chain */ 124 } crypto_data_union_t; 125 126 /*ARGSUSED*/ 127 static void 128 prt_cdu(crypto_data_union_t *cdu, int format, const char *prefix) 129 { 130 131 switch (format) { 132 case CRYPTO_DATA_RAW: 133 mdb_printf("%s_raw:\n", prefix); 134 mdb_inc_indent(4); 135 iovec_prt(&cdu->cdu_raw); 136 mdb_dec_indent(4); 137 break; 138 139 case CRYPTO_DATA_UIO: 140 mdb_printf("%s_uio:\n", prefix); 141 mdb_inc_indent(4); 142 uio_prt(cdu->cdu_uio); 143 mdb_dec_indent(4); 144 break; 145 146 case CRYPTO_DATA_MBLK: 147 mdb_printf("%s_mp:\t\t%p\n", prefix, cdu->cdu_mp); 148 break; 149 150 default: 151 mdb_printf("cm_format\t??????\n"); 152 break; 153 } 154 } 155 156 /*ARGSUSED*/ 157 int 158 crypto_data(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 159 { 160 crypto_data_t data; 161 162 if (!(flags & DCMD_ADDRSPEC)) 163 return (DCMD_USAGE); 164 165 if (mdb_vread(&data, sizeof (crypto_data_t), addr) == -1) { 166 mdb_warn("cannot read %p", addr); 167 return (DCMD_ERR); 168 } 169 if ((data.cd_format >= CRYPTO_DATA_RAW) && 170 (data.cd_format <= CRYPTO_DATA_MBLK)) 171 mdb_printf("cm_format\t%s\n", cdstrings[data.cd_format]); 172 else 173 mdb_printf("bad cm_format\t%d\n", data.cd_format); 174 mdb_printf("cm_offset\t%ld\n", data.cd_offset); 175 mdb_printf("cm_length\t%ld\n", data.cd_length); 176 mdb_printf("cm_miscdata\t%p\n", data.cd_miscdata); 177 mdb_inc_indent(4); 178 prt_cdu((crypto_data_union_t *)&data.cdu, data.cd_format, "cdu"); 179 mdb_dec_indent(4); 180 return (DCMD_OK); 181 } 182 183 /*ARGSUSED*/ 184 int 185 crypto_dual_data(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 186 { 187 crypto_dual_data_t ddata; 188 189 if (!(flags & DCMD_ADDRSPEC)) 190 return (DCMD_USAGE); 191 192 if (mdb_vread(&ddata, sizeof (crypto_dual_data_t), addr) == -1) { 193 mdb_warn("cannot read %p", addr); 194 return (DCMD_ERR); 195 } 196 if ((ddata.dd_format > CRYPTO_DATA_RAW) && 197 (ddata.dd_format <= CRYPTO_DATA_MBLK)) 198 mdb_printf("dd_format\t%s\n", cdstrings[ddata.dd_format]); 199 else 200 mdb_printf("bad dd_format\t%d\n", ddata.dd_format); 201 mdb_printf("dd_offset1\t%ld\n", ddata.dd_offset1); 202 mdb_printf("dd_len1\t%ld\n", ddata.dd_len1); 203 mdb_printf("dd_offset2\t%ld\n", ddata.dd_offset2); 204 mdb_printf("dd_len2\t%ld\n", ddata.dd_len2); 205 mdb_printf("dd_miscdata\t%p\n", ddata.dd_miscdata); 206 mdb_printf("cdu:\n"); 207 mdb_inc_indent(4); 208 prt_cdu((crypto_data_union_t *)&ddata.dd_data.cdu, ddata.dd_format, 209 "ddu"); 210 mdb_dec_indent(4); 211 return (DCMD_OK); 212 } 213 214 215 /*ARGSUSED*/ 216 int 217 crypto_key(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 218 { 219 crypto_key_t key; 220 221 if (!(flags & DCMD_ADDRSPEC)) 222 return (DCMD_USAGE); 223 224 if (mdb_vread(&key, sizeof (crypto_key_t), addr) == -1) { 225 mdb_warn("cannot read %p", addr); 226 return (DCMD_ERR); 227 } 228 switch (key.ck_format) { 229 case CRYPTO_KEY_RAW: 230 mdb_printf("ck_format:\tCRYPTO_KEY_RAW\n"); 231 mdb_printf( 232 "cku_data.cku_key_value.cku_data.cku_v_length:\t%d\n", 233 key.cku_data.cku_key_value.cku_v_length); 234 mdb_printf("cku_data.cku_key_value.cku_v_data:\t%p\n", 235 key.cku_data.cku_key_value.cku_v_data); 236 break; 237 case CRYPTO_KEY_REFERENCE: 238 mdb_printf("ck_format:\tCRYPTO_KEY_REFERENCE\n"); 239 mdb_printf("cku_data.cku_key_id:\t%u\n", 240 key.cku_data.cku_key_id); 241 break; 242 case CRYPTO_KEY_ATTR_LIST: 243 mdb_printf("ck_format:\tCRYPTO_KEY_ATTR_LIST\n"); 244 mdb_printf("cku_data.cku_key_attrs.cku_a_count:\t%u\n", 245 key.cku_data.cku_key_attrs.cku_a_count); 246 mdb_printf("cku_data.cku_key_attrs.cku_o_oattr:\t%p\n", 247 key.cku_data.cku_key_attrs.cku_a_oattr); 248 break; 249 default: 250 mdb_printf("ck_format:\t\t?????\n"); 251 break; 252 } 253 return (DCMD_OK); 254 } 255