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
rge_vprt(const char * fmt,va_list args)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
rge_notice(rge_t * rgep,const char * fmt,...)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
rge_log(rge_t * rgep,const char * fmt,...)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
rge_problem(rge_t * rgep,const char * fmt,...)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
rge_error(rge_t * rgep,const char * fmt,...)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
rge_prt(const char * fmt,...)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
rge_gdb(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
rge_db(rge_t * rgep)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
minidump(rge_t * rgep,const char * caption,void * dp,uint_t len)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
rge_pkt_dump(rge_t * rgep,rge_bd_t * hrbdp,sw_rbd_t * srbdp,const char * msg)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
rge_dbg_enter(rge_t * rgep,const char * s)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