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 2006 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 "sys/bge_impl2.h" 30 31 32 /* 33 * Global variable for default debug flags 34 */ 35 uint32_t bge_debug; 36 37 /* 38 * Global mutex used by logging routines below 39 */ 40 kmutex_t bge_log_mutex[1]; 41 42 /* 43 * Static data used by logging routines; protected by <bge_log_mutex> 44 */ 45 static struct { 46 const char *who; 47 const char *fmt; 48 int level; 49 } bge_log_data; 50 51 52 /* 53 * Backend print routine for all the routines below 54 */ 55 static void 56 bge_vprt(const char *fmt, va_list args) 57 { 58 char buf[128]; 59 60 ASSERT(mutex_owned(bge_log_mutex)); 61 62 (void) vsnprintf(buf, sizeof (buf), fmt, args); 63 cmn_err(bge_log_data.level, bge_log_data.fmt, bge_log_data.who, buf); 64 } 65 66 /* 67 * Report a run-time event (CE_NOTE, to console & log) 68 */ 69 void 70 bge_notice(bge_t *bgep, const char *fmt, ...) 71 { 72 va_list args; 73 74 mutex_enter(bge_log_mutex); 75 bge_log_data.who = bgep->ifname; 76 bge_log_data.fmt = "%s: %s"; 77 bge_log_data.level = CE_NOTE; 78 79 va_start(args, fmt); 80 bge_vprt(fmt, args); 81 va_end(args); 82 83 mutex_exit(bge_log_mutex); 84 } 85 86 /* 87 * Log a run-time event (CE_NOTE, log only) 88 */ 89 void 90 bge_log(bge_t *bgep, const char *fmt, ...) 91 { 92 va_list args; 93 94 mutex_enter(bge_log_mutex); 95 bge_log_data.who = bgep->ifname; 96 bge_log_data.fmt = "!%s: %s"; 97 bge_log_data.level = CE_NOTE; 98 99 va_start(args, fmt); 100 bge_vprt(fmt, args); 101 va_end(args); 102 103 mutex_exit(bge_log_mutex); 104 } 105 106 /* 107 * Log a run-time problem (CE_WARN, log only) 108 */ 109 void 110 bge_problem(bge_t *bgep, const char *fmt, ...) 111 { 112 va_list args; 113 114 mutex_enter(bge_log_mutex); 115 bge_log_data.who = bgep->ifname; 116 bge_log_data.fmt = "!%s: %s"; 117 bge_log_data.level = CE_WARN; 118 119 va_start(args, fmt); 120 bge_vprt(fmt, args); 121 va_end(args); 122 123 mutex_exit(bge_log_mutex); 124 } 125 126 /* 127 * Log a programming error (CE_WARN, log only) 128 */ 129 void 130 bge_error(bge_t *bgep, const char *fmt, ...) 131 { 132 va_list args; 133 134 mutex_enter(bge_log_mutex); 135 bge_log_data.who = bgep->ifname; 136 bge_log_data.fmt = "!%s: %s"; 137 bge_log_data.level = CE_WARN; 138 139 va_start(args, fmt); 140 bge_vprt(fmt, args); 141 va_end(args); 142 143 mutex_exit(bge_log_mutex); 144 } 145 146 void 147 bge_fm_ereport(bge_t *bgep, char *detail) 148 { 149 uint64_t ena; 150 char buf[FM_MAX_CLASS]; 151 152 (void) snprintf(buf, FM_MAX_CLASS, "%s.%s", DDI_FM_DEVICE, detail); 153 ena = fm_ena_generate(0, FM_ENA_FMT1); 154 if (DDI_FM_EREPORT_CAP(bgep->fm_capabilities)) { 155 ddi_fm_ereport_post(bgep->devinfo, buf, ena, DDI_NOSLEEP, 156 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0, NULL); 157 } 158 } 159 160 #if BGE_DEBUGGING 161 162 static void 163 bge_prt(const char *fmt, ...) 164 { 165 va_list args; 166 167 ASSERT(mutex_owned(bge_log_mutex)); 168 169 va_start(args, fmt); 170 bge_vprt(fmt, args); 171 va_end(args); 172 173 mutex_exit(bge_log_mutex); 174 } 175 176 void 177 (*bge_gdb(void))(const char *fmt, ...) 178 { 179 mutex_enter(bge_log_mutex); 180 bge_log_data.who = "bge"; 181 bge_log_data.fmt = "?%s: %s\n"; 182 bge_log_data.level = CE_CONT; 183 184 return (bge_prt); 185 } 186 187 void 188 (*bge_db(bge_t *bgep))(const char *fmt, ...) 189 { 190 mutex_enter(bge_log_mutex); 191 bge_log_data.who = bgep->ifname; 192 bge_log_data.fmt = "?%s: %s\n"; 193 bge_log_data.level = CE_CONT; 194 195 return (bge_prt); 196 } 197 198 /* 199 * Dump a chunk of memory, 16 bytes at a time 200 */ 201 static void 202 minidump(bge_t *bgep, const char *caption, void *dp, uint_t len) 203 { 204 uint32_t buf[4]; 205 uint32_t nbytes; 206 207 bge_log(bgep, "%d bytes of %s at address %p:-", len, caption, dp); 208 209 for (len = MIN(len, BGE_STD_BUFF_SIZE); len != 0; len -= nbytes) { 210 nbytes = MIN(len, sizeof (buf)); 211 bzero(buf, sizeof (buf)); 212 bcopy(dp, buf, nbytes); 213 bge_log(bgep, "%08x %08x %08x %08x", 214 buf[0], buf[1], buf[2], buf[3]); 215 dp = (caddr_t)dp + nbytes; 216 } 217 } 218 219 void 220 bge_pkt_dump(bge_t *bgep, bge_rbd_t *hrbdp, sw_rbd_t *srbdp, const char *msg) 221 { 222 bge_problem(bgep, "driver-detected hardware error: %s", msg); 223 224 minidump(bgep, "hardware descriptor", hrbdp, sizeof (*hrbdp)); 225 226 bge_log(bgep, "PCI address %llx packet len 0x%x token 0x%x " 227 "flags 0x%x index 0x%x", 228 hrbdp->host_buf_addr, 229 hrbdp->len, 230 hrbdp->opaque, 231 hrbdp->flags, 232 hrbdp->index); 233 234 if (srbdp != NULL) { 235 minidump(bgep, "software descriptor", srbdp, sizeof (*srbdp)); 236 237 bge_log(bgep, "PCI address %llx buffer len 0x%x token 0x%x", 238 srbdp->pbuf.cookie.dmac_laddress, 239 srbdp->pbuf.alength, 240 srbdp->pbuf.token); 241 242 minidump(bgep, "packet data", srbdp->pbuf.mem_va, hrbdp->len); 243 } 244 } 245 246 void 247 bge_dbg_enter(bge_t *bgep, const char *s) 248 { 249 uint32_t debug; 250 251 debug = bgep != NULL ? bgep->debug : bge_debug; 252 if (debug & BGE_DBG_STOP) { 253 cmn_err(CE_CONT, "bge_dbg_enter(%p): %s\n", (void *)bgep, s); 254 debug_enter(""); 255 } 256 } 257 258 #endif /* BGE_DEBUGGING */ 259