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