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