xref: /illumos-gate/usr/src/uts/common/io/rge/rge_log.c (revision c7fd2ed0)
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