Print this page
NEX-1890 update oce from source provided by Emulex
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/fibre-channel/fca/oce/oce_stat.c
+++ new/usr/src/uts/common/io/fibre-channel/fca/oce/oce_stat.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 -/* Copyright © 2003-2011 Emulex. All rights reserved. */
22 +/*
23 + * Copyright (c) 2009-2012 Emulex. All rights reserved.
24 + * Use is subject to license terms.
25 + */
23 26
27 +
28 +
24 29 /*
25 30 * Source file containing the implementation of the driver statistics
26 31 * and related helper functions
27 32 */
28 33
29 34 #include <oce_impl.h>
30 35 #include <oce_stat.h>
31 36 #include <oce_buf.h>
32 37
33 -int pow10[5] = {
34 - 0,
35 - 10,
36 - 100,
37 - 1000,
38 - 10000
39 -};
40 38
41 -/*
42 - * function called by kstat to update the stats counters
43 - *
44 - * ksp - pointer to the kstats structure
45 - * rw - flags defining read/write
46 - *
47 - * return DDI_SUCCESS => success, failure otherwise
48 - */
49 39 static int
50 -oce_update_stats(kstat_t *ksp, int rw)
40 +oce_update_lancer_stats(struct oce_dev *dev, struct oce_stat *stats)
51 41 {
52 - struct oce_dev *dev;
53 - struct oce_stat *stats;
54 - struct rx_port_stats *port_stats;
42 + struct mbx_get_pport_stats *hw_stats;
55 43 int ret;
56 44
57 - if (rw == KSTAT_WRITE) {
58 - return (EACCES);
59 - }
60 -
61 - dev = ksp->ks_private;
62 - stats = (struct oce_stat *)ksp->ks_data;
63 - port_stats = &dev->hw_stats->params.rsp.rx.port[dev->port_id];
64 -
65 - mutex_enter(&dev->dev_lock);
66 - if (dev->suspended) {
67 - mutex_exit(&dev->dev_lock);
68 - return (EIO);
69 - }
70 - ret = oce_get_hw_stats(dev);
45 + hw_stats = (struct mbx_get_pport_stats *)DBUF_VA(dev->stats_dbuf);
46 + ret = oce_get_pport_stats(dev, MBX_ASYNC_MQ);
71 47 if (ret != DDI_SUCCESS) {
72 48 oce_log(dev, CE_WARN, MOD_CONFIG,
73 49 "Failed to get stats:%d", ret);
74 - mutex_exit(&dev->dev_lock);
75 50 return (EIO);
76 51 }
77 52
78 53 /* update the stats */
79 - stats->rx_bytes_lo.value.ul = port_stats->rx_bytes_lsd;
80 - stats->rx_bytes_hi.value.ul = port_stats->rx_bytes_msd;
54 + stats->rx_bytes_lo.value.ul =
55 + hw_stats->params.rsp.pport_stats.rx_bytes_lo;
56 + stats->rx_bytes_hi.value.ul =
57 + hw_stats->params.rsp.pport_stats.rx_bytes_hi;
81 58
82 - stats->rx_frames.value.ul = port_stats->rx_total_frames;
83 - stats->rx_errors.value.ul = port_stats->rx_crc_errors +
84 - port_stats->rx_alignment_symbol_errors +
85 - port_stats->rx_in_range_errors +
86 - port_stats->rx_out_range_errors +
87 - port_stats->rx_frame_too_long +
88 - port_stats->rx_ip_checksum_errs +
89 - port_stats->rx_tcp_checksum_errs +
90 - port_stats->rx_udp_checksum_errs;
59 + stats->rx_frames.value.ul =
60 + hw_stats->params.rsp.pport_stats.rx_packets_lo;
61 + stats->rx_errors.value.ul =
62 + hw_stats->params.rsp.pport_stats.rx_crc_errors_lo +
63 + hw_stats->params.rsp.pport_stats.rx_alignment_errors_lo +
64 + hw_stats->params.rsp.pport_stats.rx_symbol_errors_lo +
65 + hw_stats->params.rsp.pport_stats.rx_in_range_errors +
66 + hw_stats->params.rsp.pport_stats.rx_out_of_range_errors +
67 + hw_stats->params.rsp.pport_stats.rx_frames_too_long_lo +
68 + hw_stats->params.rsp.pport_stats.rx_ip_checksum_errors +
69 + hw_stats->params.rsp.pport_stats.rx_tcp_checksum_errors +
70 + hw_stats->params.rsp.pport_stats.rx_udp_checksum_errors;
91 71
92 - stats->rx_drops.value.ul = port_stats->rx_dropped_too_small +
93 - port_stats->rx_dropped_too_short +
94 - port_stats->rx_dropped_header_too_small +
95 - port_stats->rx_dropped_tcp_length +
96 - port_stats->rx_dropped_runt;
72 + stats->rx_drops.value.ul =
73 + hw_stats->params.rsp.pport_stats.rx_dropped_too_small +
74 + hw_stats->params.rsp.pport_stats.rx_dropped_too_short +
75 + hw_stats->params.rsp.pport_stats.rx_dropped_header_too_small +
76 + hw_stats->params.rsp.pport_stats.rx_dropped_invalid_tcp_length +
77 + hw_stats->params.rsp.pport_stats.rx_dropped_runt;
97 78
98 - stats->tx_bytes_lo.value.ul = port_stats->tx_bytes_lsd;
99 - stats->tx_bytes_hi.value.ul = port_stats->tx_bytes_msd;
79 + stats->tx_bytes_lo.value.ul =
80 + hw_stats->params.rsp.pport_stats.tx_packets_lo;
81 + stats->tx_bytes_hi.value.ul =
82 + hw_stats->params.rsp.pport_stats.tx_packets_hi;
100 83
101 - stats->tx_frames.value.ul = port_stats->tx_unicast_frames +
102 - port_stats->tx_multicast_frames +
103 - port_stats->tx_broadcast_frames +
104 - port_stats->tx_pause_frames +
105 - port_stats->tx_control_frames;
84 + stats->tx_frames.value.ul =
85 + hw_stats->params.rsp.pport_stats.tx_unicast_packets_lo +
86 + hw_stats->params.rsp.pport_stats.tx_multicast_packets_lo +
87 + hw_stats->params.rsp.pport_stats.tx_broadcast_packets_lo +
88 + hw_stats->params.rsp.pport_stats.tx_pause_frames_lo +
89 + hw_stats->params.rsp.pport_stats.tx_control_frames_lo;
90 +
91 + /* Update all Wq errors */
106 92 stats->tx_errors.value.ul = dev->tx_errors;
107 93
108 94 stats->rx_unicast_frames.value.ul =
109 - port_stats->rx_unicast_frames;
95 + hw_stats->params.rsp.pport_stats.rx_unicast_packets_lo;
110 96 stats->rx_multicast_frames.value.ul =
111 - port_stats->rx_multicast_frames;
97 + hw_stats->params.rsp.pport_stats.rx_multicast_packets_lo;
112 98 stats->rx_broadcast_frames.value.ul =
113 - port_stats->rx_broadcast_frames;
99 + hw_stats->params.rsp.pport_stats.rx_broadcast_packets_lo;
114 100 stats->rx_crc_errors.value.ul =
115 - port_stats->rx_crc_errors;
101 + hw_stats->params.rsp.pport_stats.rx_crc_errors_lo;
116 102
117 103 stats->rx_alignment_symbol_errors.value.ul =
118 - port_stats->rx_alignment_symbol_errors;
104 + hw_stats->params.rsp.pport_stats.rx_alignment_errors_lo +
105 + hw_stats->params.rsp.pport_stats.rx_symbol_errors_lo;
119 106 stats->rx_in_range_errors.value.ul =
120 - port_stats->rx_in_range_errors;
107 + hw_stats->params.rsp.pport_stats.rx_in_range_errors;
121 108 stats->rx_out_range_errors.value.ul =
122 - port_stats->rx_out_range_errors;
109 + hw_stats->params.rsp.pport_stats.rx_out_of_range_errors;
123 110 stats->rx_frame_too_long.value.ul =
124 - port_stats->rx_frame_too_long;
111 + hw_stats->params.rsp.pport_stats.rx_frames_too_long_lo;
125 112 stats->rx_address_match_errors.value.ul =
126 - port_stats->rx_address_match_errors;
113 + hw_stats->params.rsp.pport_stats.rx_address_match_errors;
127 114
128 115 stats->rx_pause_frames.value.ul =
129 - port_stats->rx_pause_frames;
116 + hw_stats->params.rsp.pport_stats.rx_pause_frames_lo;
130 117 stats->rx_control_frames.value.ul =
131 - port_stats->rx_control_frames;
118 + hw_stats->params.rsp.pport_stats.rx_control_frames_lo;
132 119 stats->rx_ip_checksum_errs.value.ul =
133 - port_stats->rx_ip_checksum_errs;
120 + hw_stats->params.rsp.pport_stats.rx_ip_checksum_errors;
134 121 stats->rx_tcp_checksum_errs.value.ul =
135 - port_stats->rx_tcp_checksum_errs;
122 + hw_stats->params.rsp.pport_stats.rx_tcp_checksum_errors;
136 123 stats->rx_udp_checksum_errs.value.ul =
137 - port_stats->rx_udp_checksum_errs;
138 - stats->rx_fifo_overflow.value.ul = port_stats->rx_fifo_overflow;
124 + hw_stats->params.rsp.pport_stats.rx_udp_checksum_errors;
125 + stats->rx_fifo_overflow.value.ul =
126 + hw_stats->params.rsp.pport_stats.rx_fifo_overflow;
139 127 stats->rx_input_fifo_overflow.value.ul =
140 - port_stats->rx_input_fifo_overflow;
128 + hw_stats->params.rsp.pport_stats.rx_input_fifo_overflow;
141 129
142 130 stats->tx_unicast_frames.value.ul =
143 - port_stats->tx_unicast_frames;
131 + hw_stats->params.rsp.pport_stats.tx_unicast_packets_lo;
144 132 stats->tx_multicast_frames.value.ul =
145 - port_stats->tx_multicast_frames;
133 + hw_stats->params.rsp.pport_stats.tx_multicast_packets_lo;
146 134 stats->tx_broadcast_frames.value.ul =
147 - port_stats->tx_broadcast_frames;
135 + hw_stats->params.rsp.pport_stats.tx_broadcast_packets_lo;
148 136 stats->tx_pause_frames.value.ul =
149 - port_stats->tx_pause_frames;
137 + hw_stats->params.rsp.pport_stats.tx_pause_frames_lo;
150 138 stats->tx_control_frames.value.ul =
151 - port_stats->tx_control_frames;
139 + hw_stats->params.rsp.pport_stats.tx_control_frames_lo;
152 140
153 141
154 - stats->rx_drops_no_pbuf.value.ul =
155 - dev->hw_stats->params.rsp.rx.rx_drops_no_pbuf;
156 - stats->rx_drops_no_txpb.value.ul =
157 - dev->hw_stats->params.rsp.rx.rx_drops_no_txpb;
158 - stats->rx_drops_no_erx_descr.value.ul =
159 - dev->hw_stats->params.rsp.rx.rx_drops_no_erx_descr;
160 - stats->rx_drops_no_tpre_descr.value.ul =
161 - dev->hw_stats->params.rsp.rx.rx_drops_no_tpre_descr;
162 142 stats->rx_drops_too_many_frags.value.ul =
163 - dev->hw_stats->params.rsp.rx.rx_drops_too_many_frags;
143 + hw_stats->params.rsp.pport_stats.rx_drops_too_many_frags_lo;
164 144 stats->rx_drops_invalid_ring.value.ul =
165 - dev->hw_stats->params.rsp.rx.rx_drops_invalid_ring;
145 + hw_stats->params.rsp.pport_stats.rx_drops_invalid_queue;
166 146 stats->rx_drops_mtu.value.ul =
167 - dev->hw_stats->params.rsp.rx.rx_drops_mtu;
147 + hw_stats->params.rsp.pport_stats.rx_drops_mtu_lo;
168 148
169 149 stats->rx_dropped_too_small.value.ul =
170 - port_stats->rx_dropped_too_small;
150 + hw_stats->params.rsp.pport_stats.rx_dropped_too_small;
171 151 stats->rx_dropped_too_short.value.ul =
172 - port_stats->rx_dropped_too_short;
152 + hw_stats->params.rsp.pport_stats.rx_dropped_too_short;
173 153 stats->rx_dropped_header_too_small.value.ul =
174 - port_stats->rx_dropped_header_too_small;
154 + hw_stats->params.rsp.pport_stats.rx_dropped_header_too_small;
175 155 stats->rx_dropped_tcp_length.value.ul =
176 - port_stats->rx_dropped_tcp_length;
156 + hw_stats->params.rsp.pport_stats.rx_dropped_invalid_tcp_length;
177 157 stats->rx_dropped_runt.value.ul =
178 - port_stats->rx_dropped_runt;
158 + hw_stats->params.rsp.pport_stats.rx_dropped_runt;
179 159
180 - stats->rx_drops_no_fragments.value.ul =
181 - dev->hw_stats->params.rsp.err_rx.rx_drops_no_fragments[0];
160 + return (DDI_SUCCESS);
161 +}
182 162
183 - mutex_exit(&dev->dev_lock);
163 +/*
164 + * function called by kstat to update the stats counters
165 + *
166 + * ksp - pointer to the kstats structure
167 + * rw - flags defining read/write
168 + *
169 + * return DDI_SUCCESS => success, failure otherwise
170 + */
171 +static int
172 +oce_update_be_stats(struct oce_dev *dev, struct oce_stat *stats)
173 +{
174 + struct mbx_get_nic_stats *fwcmd;
175 + int i, ret;
176 +
177 + ret = oce_get_hw_stats(dev, MBX_ASYNC_MQ);
178 + if (ret != DDI_SUCCESS) {
179 + return (EIO);
180 + }
181 +
182 + /* update the stats */
183 + fwcmd = (struct mbx_get_nic_stats *)DBUF_VA(dev->stats_dbuf);
184 + if (dev->chip_rev == OC_CNA_GEN2) {
185 + struct be_hw_stats_v0 *hw_stats = &fwcmd->params.rsp.v0;
186 + struct rx_stats_v0 *rx_stats = &hw_stats->rx;
187 + struct rx_port_stats_v0 *port_stats =
188 + &rx_stats->port[dev->port_id];
189 + struct rx_err_stats_v0 *err_stats = &hw_stats->err_rx;
190 +
191 + stats->rx_bytes_lo.value.ul = port_stats->rx_bytes_lsd;
192 + stats->rx_bytes_hi.value.ul = port_stats->rx_bytes_msd;
193 + stats->rx_frames.value.ul = port_stats->rx_total_frames;
194 + stats->rx_errors.value.ul = port_stats->rx_crc_errors +
195 + port_stats->rx_alignment_symbol_errors +
196 + port_stats->rx_in_range_errors +
197 + port_stats->rx_out_range_errors +
198 + port_stats->rx_frame_too_long +
199 + port_stats->rx_ip_checksum_errs +
200 + port_stats->rx_tcp_checksum_errs +
201 + port_stats->rx_udp_checksum_errs;
202 +
203 + stats->rx_drops.value.ul = port_stats->rx_dropped_too_small +
204 + port_stats->rx_dropped_too_short +
205 + port_stats->rx_dropped_header_too_small +
206 + port_stats->rx_dropped_tcp_length +
207 + port_stats->rx_dropped_runt;
208 +
209 + stats->tx_bytes_lo.value.ul = port_stats->tx_bytes_lsd;
210 + stats->tx_bytes_hi.value.ul = port_stats->tx_bytes_msd;
211 +
212 + stats->tx_frames.value.ul = port_stats->tx_unicast_frames +
213 + port_stats->tx_multicast_frames +
214 + port_stats->tx_broadcast_frames +
215 + port_stats->tx_pause_frames +
216 + port_stats->tx_control_frames;
217 + stats->tx_errors.value.ul = dev->tx_errors;
218 +
219 + stats->rx_unicast_frames.value.ul =
220 + port_stats->rx_unicast_frames;
221 + stats->rx_multicast_frames.value.ul =
222 + port_stats->rx_multicast_frames;
223 + stats->rx_broadcast_frames.value.ul =
224 + port_stats->rx_broadcast_frames;
225 + stats->rx_crc_errors.value.ul =
226 + port_stats->rx_crc_errors;
227 +
228 + stats->rx_alignment_symbol_errors.value.ul =
229 + port_stats->rx_alignment_symbol_errors;
230 + stats->rx_in_range_errors.value.ul =
231 + port_stats->rx_in_range_errors;
232 + stats->rx_out_range_errors.value.ul =
233 + port_stats->rx_out_range_errors;
234 + stats->rx_frame_too_long.value.ul =
235 + port_stats->rx_frame_too_long;
236 + stats->rx_address_match_errors.value.ul =
237 + port_stats->rx_address_match_errors;
238 +
239 + stats->rx_pause_frames.value.ul =
240 + port_stats->rx_pause_frames;
241 + stats->rx_control_frames.value.ul =
242 + port_stats->rx_control_frames;
243 + stats->rx_ip_checksum_errs.value.ul =
244 + port_stats->rx_ip_checksum_errs;
245 + stats->rx_tcp_checksum_errs.value.ul =
246 + port_stats->rx_tcp_checksum_errs;
247 + stats->rx_udp_checksum_errs.value.ul =
248 + port_stats->rx_udp_checksum_errs;
249 + stats->rx_fifo_overflow.value.ul = port_stats->rx_fifo_overflow;
250 + stats->rx_input_fifo_overflow.value.ul =
251 + port_stats->rx_input_fifo_overflow;
252 +
253 + stats->tx_unicast_frames.value.ul =
254 + port_stats->tx_unicast_frames;
255 + stats->tx_multicast_frames.value.ul =
256 + port_stats->tx_multicast_frames;
257 + stats->tx_broadcast_frames.value.ul =
258 + port_stats->tx_broadcast_frames;
259 + stats->tx_pause_frames.value.ul =
260 + port_stats->tx_pause_frames;
261 + stats->tx_control_frames.value.ul =
262 + port_stats->tx_control_frames;
263 +
264 +
265 + stats->rx_drops_no_pbuf.value.ul =
266 + rx_stats->rx_drops_no_pbuf;
267 + stats->rx_drops_no_txpb.value.ul =
268 + rx_stats->rx_drops_no_txpb;
269 + stats->rx_drops_no_erx_descr.value.ul =
270 + rx_stats->rx_drops_no_erx_descr;
271 + stats->rx_drops_no_tpre_descr.value.ul =
272 + rx_stats->rx_drops_no_tpre_descr;
273 + stats->rx_drops_too_many_frags.value.ul =
274 + rx_stats->rx_drops_too_many_frags;
275 + stats->rx_drops_invalid_ring.value.ul =
276 + rx_stats->rx_drops_invalid_ring;
277 + stats->rx_drops_mtu.value.ul =
278 + rx_stats->rx_drops_mtu;
279 +
280 + stats->rx_dropped_too_small.value.ul =
281 + port_stats->rx_dropped_too_small;
282 + stats->rx_dropped_too_short.value.ul =
283 + port_stats->rx_dropped_too_short;
284 + stats->rx_dropped_header_too_small.value.ul =
285 + port_stats->rx_dropped_header_too_small;
286 + stats->rx_dropped_tcp_length.value.ul =
287 + port_stats->rx_dropped_tcp_length;
288 + stats->rx_dropped_runt.value.ul =
289 + port_stats->rx_dropped_runt;
290 +
291 + stats->rx_drops_no_fragments.value.ul = 0;
292 + for (i = 0; i < dev->nrqs; i++) {
293 + stats->rx_drops_no_fragments.value.ul +=
294 + err_stats->rx_drops_no_fragments[dev->rq[i].rq_id];
295 + }
296 +
297 + stats->rx_priority_pause_frames.value.ul = 0;
298 + stats->pmem_fifo_overflow_drop.value.ul = 0;
299 + if (dev->port_id) {
300 + stats->jabber_events.value.ul =
301 + rx_stats->port1_jabber_events;
302 + } else {
303 + stats->jabber_events.value.ul =
304 + rx_stats->port0_jabber_events;
305 + }
306 + stats->forwarded_packets.value.ul = rx_stats->forwarded_packets;
307 +
308 + } else {
309 + struct be_hw_stats_v1 *hw_stats = &fwcmd->params.rsp.v1;
310 + struct rx_stats_v1 *rx_stats = &hw_stats->rx;
311 + struct rx_port_stats_v1 *port_stats =
312 + &rx_stats->port[dev->port_id];
313 + struct rx_err_stats_v1 *err_stats = &hw_stats->err_rx;
314 +
315 + stats->rx_bytes_lo.value.ul = port_stats->rx_bytes_lsd;
316 + stats->rx_bytes_hi.value.ul = port_stats->rx_bytes_msd;
317 + stats->rx_frames.value.ul = port_stats->rx_total_frames;
318 + stats->rx_errors.value.ul = port_stats->rx_crc_errors +
319 + port_stats->rx_alignment_symbol_errors +
320 + port_stats->rx_in_range_errors +
321 + port_stats->rx_out_range_errors +
322 + port_stats->rx_frame_too_long +
323 + port_stats->rx_ip_checksum_errs +
324 + port_stats->rx_tcp_checksum_errs +
325 + port_stats->rx_udp_checksum_errs;
326 +
327 + stats->rx_drops.value.ul = port_stats->rx_dropped_too_small +
328 + port_stats->rx_dropped_too_short +
329 + port_stats->rx_dropped_header_too_small +
330 + port_stats->rx_dropped_tcp_length +
331 + port_stats->rx_dropped_runt;
332 +
333 + stats->tx_bytes_lo.value.ul = port_stats->tx_bytes_lsd;
334 + stats->tx_bytes_hi.value.ul = port_stats->tx_bytes_msd;
335 +
336 + stats->tx_frames.value.ul = port_stats->tx_unicast_frames +
337 + port_stats->tx_multicast_frames +
338 + port_stats->tx_broadcast_frames +
339 + port_stats->tx_pause_frames +
340 + port_stats->tx_control_frames;
341 + stats->tx_errors.value.ul = dev->tx_errors;
342 +
343 + stats->rx_unicast_frames.value.ul =
344 + port_stats->rx_non_switched_unicast_frames +
345 + port_stats->rx_switched_unicast_packets;
346 + stats->rx_multicast_frames.value.ul =
347 + port_stats->rx_non_switched_multicast_frames +
348 + port_stats->rx_switched_multicast_packets;
349 + stats->rx_broadcast_frames.value.ul =
350 + port_stats->rx_non_switched_broadcast_frames +
351 + port_stats->rx_switched_broadcast_packets;
352 + stats->rx_crc_errors.value.ul =
353 + port_stats->rx_crc_errors;
354 +
355 + stats->rx_alignment_symbol_errors.value.ul =
356 + port_stats->rx_alignment_symbol_errors;
357 + stats->rx_in_range_errors.value.ul =
358 + port_stats->rx_in_range_errors;
359 + stats->rx_out_range_errors.value.ul =
360 + port_stats->rx_out_range_errors;
361 + stats->rx_frame_too_long.value.ul =
362 + port_stats->rx_frame_too_long;
363 + stats->rx_address_match_errors.value.ul =
364 + port_stats->rx_address_match_errors;
365 +
366 + stats->rx_pause_frames.value.ul =
367 + port_stats->rx_pause_frames;
368 + stats->rx_control_frames.value.ul =
369 + port_stats->rx_control_frames;
370 + stats->rx_ip_checksum_errs.value.ul =
371 + port_stats->rx_ip_checksum_errs;
372 + stats->rx_tcp_checksum_errs.value.ul =
373 + port_stats->rx_tcp_checksum_errs;
374 + stats->rx_udp_checksum_errs.value.ul =
375 + port_stats->rx_udp_checksum_errs;
376 + stats->rx_fifo_overflow.value.ul =
377 + port_stats->rxpp_fifo_overflow_drop;
378 + stats->rx_input_fifo_overflow.value.ul =
379 + port_stats->rx_input_fifo_overflow_drop;
380 +
381 + stats->tx_unicast_frames.value.ul =
382 + port_stats->tx_unicast_frames;
383 + stats->tx_multicast_frames.value.ul =
384 + port_stats->tx_multicast_frames;
385 + stats->tx_broadcast_frames.value.ul =
386 + port_stats->tx_broadcast_frames;
387 + stats->tx_pause_frames.value.ul =
388 + port_stats->tx_pause_frames;
389 + stats->tx_control_frames.value.ul =
390 + port_stats->tx_control_frames;
391 +
392 +
393 + stats->rx_drops_no_pbuf.value.ul =
394 + rx_stats->rx_drops_no_pbuf;
395 + stats->rx_drops_no_txpb.value.ul =
396 + rx_stats->rx_drops_no_txpb;
397 + stats->rx_drops_no_erx_descr.value.ul =
398 + rx_stats->rx_drops_no_erx_descr;
399 + stats->rx_drops_no_tpre_descr.value.ul =
400 + rx_stats->rx_drops_no_tpre_descr;
401 + stats->rx_drops_too_many_frags.value.ul =
402 + rx_stats->rx_drops_too_many_frags;
403 + stats->rx_drops_invalid_ring.value.ul =
404 + rx_stats->rx_drops_invalid_ring;
405 + stats->rx_drops_mtu.value.ul =
406 + rx_stats->rx_drops_mtu;
407 +
408 + stats->rx_dropped_too_small.value.ul =
409 + port_stats->rx_dropped_too_small;
410 + stats->rx_dropped_too_short.value.ul =
411 + port_stats->rx_dropped_too_short;
412 + stats->rx_dropped_header_too_small.value.ul =
413 + port_stats->rx_dropped_header_too_small;
414 + stats->rx_dropped_tcp_length.value.ul =
415 + port_stats->rx_dropped_tcp_length;
416 + stats->rx_dropped_runt.value.ul =
417 + port_stats->rx_dropped_runt;
418 +
419 + stats->rx_drops_no_fragments.value.ul = 0;
420 + for (i = 0; i < dev->nrqs; i++) {
421 + stats->rx_drops_no_fragments.value.ul +=
422 + err_stats->rx_drops_no_fragments[dev->rq[i].rq_id];
423 + }
424 +
425 + stats->rx_priority_pause_frames.value.ul =
426 + port_stats->rx_priority_pause_frames;
427 + stats->pmem_fifo_overflow_drop.value.ul =
428 + port_stats->pmem_fifo_overflow_drop;
429 + stats->jabber_events.value.ul = port_stats->jabber_events;
430 + stats->forwarded_packets.value.ul = rx_stats->forwarded_packets;
431 +
432 + }
433 +
184 434 return (DDI_SUCCESS);
435 +} /* oce_update_be_stats */
436 +
437 +/*
438 + * function called by kstat to update the stats counters
439 + *
440 + * ksp - pointer to the kstats structure
441 + * rw - flags defining read/write
442 + *
443 + * return DDI_SUCCESS => success, failure otherwise
444 + */
445 +static int
446 +oce_update_stats(kstat_t *ksp, int rw)
447 +{
448 + struct oce_dev *dev;
449 + struct oce_stat *stats;
450 + int ret;
451 +
452 + if (rw == KSTAT_WRITE) {
453 + return (EACCES);
454 + }
455 +
456 + dev = ksp->ks_private;
457 + stats = (struct oce_stat *)ksp->ks_data;
458 + mutex_enter(&dev->dev_lock);
459 + if (dev->suspended) {
460 + mutex_exit(&dev->dev_lock);
461 + return (EIO);
462 + }
463 + mutex_exit(&dev->dev_lock);
464 + mutex_enter(&dev->stat_lock);
465 + if (LANCER_CHIP(dev)) {
466 + ret = oce_update_lancer_stats(dev, stats);
467 + } else {
468 + ret = oce_update_be_stats(dev, stats);
469 + }
470 + mutex_exit(&dev->stat_lock);
471 + return (ret);
185 472 } /* oce_update_stats */
186 473
187 474 /*
188 475 * function to setup the kstat_t structure for the device and install it
189 476 *
190 477 * dev - software handle to the device
191 478 *
192 479 * return DDI_SUCCESS => success, failure otherwise
193 480 */
194 481 int
195 482 oce_stat_init(struct oce_dev *dev)
196 483 {
484 + int ret;
197 485 struct oce_stat *stats;
486 + uint32_t hw_stat_size = 0;
198 487 uint32_t num_stats = sizeof (struct oce_stat) /
199 488 sizeof (kstat_named_t);
200 489
201 490 /* allocate the kstat */
202 491 dev->oce_kstats = kstat_create(OCE_MOD_NAME, dev->dev_id, "stats",
203 492 "net", KSTAT_TYPE_NAMED,
204 493 num_stats, 0);
205 494 if (dev->oce_kstats == NULL) {
206 - oce_log(dev, CE_NOTE, MOD_CONFIG,
495 + oce_log(dev, CE_WARN, MOD_CONFIG,
207 496 "kstat creation failed: 0x%p",
208 497 (void *)dev->oce_kstats);
209 498 return (DDI_FAILURE);
210 499 }
211 500
501 + if (LANCER_CHIP(dev))
502 + hw_stat_size = sizeof (struct mbx_get_pport_stats);
503 + else
504 + hw_stat_size = sizeof (struct mbx_get_nic_stats);
505 +
212 506 /* allocate the device copy of the stats */
213 - dev->stats_dbuf = oce_alloc_dma_buffer(dev,
214 - sizeof (struct mbx_get_nic_stats),
215 - NULL, DDI_DMA_CONSISTENT);
216 - if (dev->stats_dbuf == NULL) {
217 - oce_log(dev, CE_NOTE, MOD_CONFIG,
218 - "Could not allocate stats_dbuf: %p",
219 - (void *)dev->stats_dbuf);
507 + ret = oce_alloc_dma_buffer(dev, &dev->stats_dbuf,
508 + hw_stat_size, NULL, DDI_DMA_CONSISTENT|DDI_DMA_RDWR);
509 + if (ret != DDI_SUCCESS) {
510 + oce_log(dev, CE_WARN, MOD_CONFIG,
511 + "Could not allocate stats_dbuf 0x%x", ret);
220 512 kstat_delete(dev->oce_kstats);
221 513 return (DDI_FAILURE);
222 514 }
223 - dev->hw_stats = (struct mbx_get_nic_stats *)DBUF_VA(dev->stats_dbuf);
224 515
225 516 /* initialize the counters */
226 517 stats = (struct oce_stat *)dev->oce_kstats->ks_data;
227 518 kstat_named_init(&stats->rx_bytes_hi, "rx bytes msd", KSTAT_DATA_ULONG);
228 519 kstat_named_init(&stats->rx_bytes_lo, "rx bytes lsd", KSTAT_DATA_ULONG);
229 520
230 521 kstat_named_init(&stats->rx_frames, "rx frames", KSTAT_DATA_ULONG);
231 522 kstat_named_init(&stats->rx_errors, "rx errors", KSTAT_DATA_ULONG);
232 523 kstat_named_init(&stats->rx_drops, "rx drops", KSTAT_DATA_ULONG);
233 524
234 525 kstat_named_init(&stats->tx_bytes_hi, "tx bytes msd", KSTAT_DATA_ULONG);
235 526 kstat_named_init(&stats->tx_bytes_lo, "tx bytes lsd", KSTAT_DATA_ULONG);
236 527
237 528 kstat_named_init(&stats->tx_frames, "tx frames", KSTAT_DATA_ULONG);
238 529 kstat_named_init(&stats->tx_errors, "tx errors", KSTAT_DATA_ULONG);
239 530
240 531 kstat_named_init(&stats->rx_unicast_frames,
241 532 "rx unicast frames", KSTAT_DATA_ULONG);
242 533 kstat_named_init(&stats->rx_multicast_frames,
243 534 "rx multicast frames", KSTAT_DATA_ULONG);
244 535 kstat_named_init(&stats->rx_broadcast_frames,
245 536 "rx broadcast frames", KSTAT_DATA_ULONG);
246 537 kstat_named_init(&stats->rx_crc_errors,
247 538 "rx crc errors", KSTAT_DATA_ULONG);
248 539
249 540 kstat_named_init(&stats->rx_alignment_symbol_errors,
250 541 "rx alignment symbol errors", KSTAT_DATA_ULONG);
251 542 kstat_named_init(&stats->rx_in_range_errors,
252 543 "rx in range errors", KSTAT_DATA_ULONG);
253 544 kstat_named_init(&stats->rx_out_range_errors,
254 545 "rx out range errors", KSTAT_DATA_ULONG);
255 546 kstat_named_init(&stats->rx_frame_too_long,
256 547 "rx frame too long", KSTAT_DATA_ULONG);
257 548 kstat_named_init(&stats->rx_address_match_errors,
258 549 "rx address match errors", KSTAT_DATA_ULONG);
259 550
260 551 kstat_named_init(&stats->rx_pause_frames,
261 552 "rx pause frames", KSTAT_DATA_ULONG);
262 553 kstat_named_init(&stats->rx_control_frames,
263 554 "rx control frames", KSTAT_DATA_ULONG);
264 555 kstat_named_init(&stats->rx_ip_checksum_errs,
265 556 "rx ip checksum errors", KSTAT_DATA_ULONG);
266 557 kstat_named_init(&stats->rx_tcp_checksum_errs,
267 558 "rx tcp checksum errors", KSTAT_DATA_ULONG);
268 559 kstat_named_init(&stats->rx_udp_checksum_errs,
269 560 "rx udp checksum errors", KSTAT_DATA_ULONG);
270 561 kstat_named_init(&stats->rx_fifo_overflow,
271 562 "rx fifo overflow", KSTAT_DATA_ULONG);
272 563 kstat_named_init(&stats->rx_input_fifo_overflow,
273 564 "rx input fifo overflow", KSTAT_DATA_ULONG);
274 565
275 566 kstat_named_init(&stats->tx_unicast_frames,
276 567 "tx unicast frames", KSTAT_DATA_ULONG);
277 568 kstat_named_init(&stats->tx_multicast_frames,
278 569 "tx multicast frames", KSTAT_DATA_ULONG);
279 570 kstat_named_init(&stats->tx_broadcast_frames,
280 571 "tx broadcast frames", KSTAT_DATA_ULONG);
281 572 kstat_named_init(&stats->tx_pause_frames,
282 573 "tx pause frames", KSTAT_DATA_ULONG);
283 574 kstat_named_init(&stats->tx_control_frames,
284 575 "tx control frames", KSTAT_DATA_ULONG);
285 576
286 577
287 578 kstat_named_init(&stats->rx_drops_no_pbuf,
288 579 "rx_drops_no_pbuf", KSTAT_DATA_ULONG);
289 580 kstat_named_init(&stats->rx_drops_no_txpb,
290 581 "rx_drops_no_txpb", KSTAT_DATA_ULONG);
291 582 kstat_named_init(&stats->rx_drops_no_erx_descr,
292 583 "rx_drops_no_erx_descr", KSTAT_DATA_ULONG);
293 584 kstat_named_init(&stats->rx_drops_no_tpre_descr,
294 585 "rx_drops_no_tpre_descr", KSTAT_DATA_ULONG);
295 586 kstat_named_init(&stats->rx_drops_too_many_frags,
296 587 "rx_drops_too_many_frags", KSTAT_DATA_ULONG);
297 588 kstat_named_init(&stats->rx_drops_invalid_ring,
298 589 "rx_drops_invalid_ring", KSTAT_DATA_ULONG);
299 590 kstat_named_init(&stats->rx_drops_mtu,
300 591 "rx_drops_mtu", KSTAT_DATA_ULONG);
301 592
302 593 kstat_named_init(&stats->rx_dropped_too_small,
303 594 "rx_dropped_too_small", KSTAT_DATA_ULONG);
304 595 kstat_named_init(&stats->rx_dropped_too_short,
305 596 "rx_dropped_too_short", KSTAT_DATA_ULONG);
|
↓ open down ↓ |
72 lines elided |
↑ open up ↑ |
306 597 kstat_named_init(&stats->rx_dropped_header_too_small,
307 598 "rx_dropped_header_too_small", KSTAT_DATA_ULONG);
308 599 kstat_named_init(&stats->rx_dropped_tcp_length,
309 600 "rx_dropped_tcp_length", KSTAT_DATA_ULONG);
310 601 kstat_named_init(&stats->rx_dropped_runt,
311 602 "rx_dropped_runt", KSTAT_DATA_ULONG);
312 603
313 604 kstat_named_init(&stats->rx_drops_no_fragments,
314 605 "rx_drop_no_frag", KSTAT_DATA_ULONG);
315 606
607 + kstat_named_init(&stats->rx_priority_pause_frames,
608 + "rx_priority_pause_frames", KSTAT_DATA_ULONG);
609 + kstat_named_init(&stats->pmem_fifo_overflow_drop,
610 + "pmem_fifo_overflow_drop", KSTAT_DATA_ULONG);
611 + kstat_named_init(&stats->jabber_events,
612 + "jabber_events", KSTAT_DATA_ULONG);
613 + kstat_named_init(&stats->forwarded_packets,
614 + "forwarded_packets", KSTAT_DATA_ULONG);
316 615
317 616 dev->oce_kstats->ks_update = oce_update_stats;
318 617 dev->oce_kstats->ks_private = (void *)dev;
319 618 kstat_install(dev->oce_kstats);
320 619
321 620 return (DDI_SUCCESS);
322 621 } /* oce_stat_init */
323 622
324 623 /*
325 624 * function to undo initialization done in oce_stat_init
326 625 *
327 626 * dev - software handle to the device
328 627 *
329 628 * return none
330 629 */
331 630 void
332 631 oce_stat_fini(struct oce_dev *dev)
333 632 {
334 - oce_free_dma_buffer(dev, dev->stats_dbuf);
335 - dev->hw_stats = NULL;
336 - dev->stats_dbuf = NULL;
633 + oce_free_dma_buffer(dev, &dev->stats_dbuf);
337 634 kstat_delete(dev->oce_kstats);
338 635 dev->oce_kstats = NULL;
339 636 } /* oce_stat_fini */
340 637
341 638 /*
342 639 * GLDv3 entry for statistic query
343 640 */
344 641 int
345 642 oce_m_stat(void *arg, uint_t stat, uint64_t *val)
346 643 {
347 644 struct oce_dev *dev = arg;
348 645 struct oce_stat *stats;
349 - struct rx_port_stats *port_stats;
646 + int ret;
350 647
351 648 stats = (struct oce_stat *)dev->oce_kstats->ks_data;
352 - port_stats = &dev->hw_stats->params.rsp.rx.port[dev->port_id];
353 -
354 649 mutex_enter(&dev->dev_lock);
355 650
356 651 if (dev->suspended ||
357 652 (dev->state & STATE_MAC_STOPPING) ||
358 653 !(dev->state & STATE_MAC_STARTED)) {
359 654 mutex_exit(&dev->dev_lock);
360 655 return (EIO);
361 656 }
657 + mutex_exit(&dev->dev_lock);
658 + mutex_enter(&dev->stat_lock);
362 659
660 + if (LANCER_CHIP(dev)) {
661 + ret = oce_update_lancer_stats(dev, stats);
662 + } else {
663 + ret = oce_update_be_stats(dev, stats);
664 + }
665 + if (ret != DDI_SUCCESS) {
666 + mutex_exit(&dev->stat_lock);
667 + return (EIO);
668 + }
363 669 switch (stat) {
364 - case MAC_STAT_IFSPEED: {
365 - struct link_status link = {0};
366 - if (dev->link_speed < 0) {
367 - (void) oce_get_link_status(dev, &link);
368 - dev->link_speed = link.qos_link_speed ?
369 - link.qos_link_speed * 10 :
370 - pow10[link.mac_speed];
371 - }
670 + case MAC_STAT_IFSPEED:
372 671 *val = dev->link_speed * 1000000ull;
373 - }
374 672 break;
375 673
376 674 case MAC_STAT_RBYTES:
377 - stats->rx_bytes_lo.value.ul = port_stats->rx_bytes_lsd;
378 - stats->rx_bytes_hi.value.ul = port_stats->rx_bytes_msd;
379 675 *val = (uint64_t)stats->rx_bytes_hi.value.ul << 32 |
380 676 (uint64_t)stats->rx_bytes_lo.value.ul;
381 677 break;
382 678
383 679 case MAC_STAT_IPACKETS:
384 - stats->rx_frames.value.ul = port_stats->rx_total_frames;
385 680 *val = stats->rx_frames.value.ul;
386 681 break;
387 682
388 683 case MAC_STAT_OBYTES:
389 - stats->tx_bytes_lo.value.ul = port_stats->tx_bytes_lsd;
390 - stats->tx_bytes_hi.value.ul = port_stats->tx_bytes_msd;
391 684 *val = (uint64_t)stats->tx_bytes_hi.value.ul << 32 |
392 685 (uint64_t)stats->tx_bytes_lo.value.ul;
393 686 break;
394 687
395 688 case MAC_STAT_OPACKETS:
396 - stats->tx_frames.value.ul = port_stats->tx_unicast_frames +
397 - port_stats->tx_multicast_frames +
398 - port_stats->tx_broadcast_frames +
399 - port_stats->tx_pause_frames +
400 - port_stats->tx_control_frames;
401 689 *val = stats->tx_frames.value.ul;
402 690 break;
403 691
404 692 case MAC_STAT_BRDCSTRCV:
405 - stats->rx_broadcast_frames.value.ul =
406 - port_stats->rx_broadcast_frames;
407 693 *val = stats->rx_broadcast_frames.value.ul;
408 694 break;
409 695
410 696 case MAC_STAT_MULTIRCV:
411 - stats->rx_multicast_frames.value.ul =
412 - port_stats->rx_multicast_frames;
413 697 *val = stats->rx_multicast_frames.value.ul;
414 698 break;
415 699
416 700 case MAC_STAT_MULTIXMT:
417 - stats->tx_multicast_frames.value.ul =
418 - port_stats->tx_multicast_frames;
419 701 *val = stats->tx_multicast_frames.value.ul;
420 702 break;
421 703
422 704 case MAC_STAT_BRDCSTXMT:
423 - stats->tx_broadcast_frames.value.ul =
424 - port_stats->tx_broadcast_frames;
425 705 *val = stats->tx_broadcast_frames.value.ul;
426 706 break;
427 707
428 708 case MAC_STAT_NORCVBUF:
429 - stats->rx_fifo_overflow.value.ul =
430 - port_stats->rx_fifo_overflow;
431 709 *val = stats->rx_fifo_overflow.value.ul;
432 710 break;
433 711
434 712 case MAC_STAT_IERRORS:
435 - stats->rx_errors.value.ul = port_stats->rx_crc_errors +
436 - port_stats->rx_alignment_symbol_errors +
437 - port_stats->rx_in_range_errors +
438 - port_stats->rx_out_range_errors +
439 - port_stats->rx_frame_too_long +
440 - port_stats->rx_ip_checksum_errs +
441 - port_stats->rx_tcp_checksum_errs +
442 - port_stats->rx_udp_checksum_errs;
443 713 *val = stats->rx_errors.value.ul;
444 714 break;
445 715
446 716 case MAC_STAT_NOXMTBUF:
447 717 *val = dev->tx_noxmtbuf;
448 718 break;
449 719
450 720 case MAC_STAT_OERRORS:
451 721 *val = stats->tx_errors.value.ul;
452 722 break;
453 723
454 724 case ETHER_STAT_LINK_DUPLEX:
455 725 if (dev->state & STATE_MAC_STARTED)
456 726 *val = LINK_DUPLEX_FULL;
457 727 else
458 728 *val = LINK_DUPLEX_UNKNOWN;
459 729 break;
460 730
461 731 case ETHER_STAT_ALIGN_ERRORS:
462 - stats->rx_alignment_symbol_errors.value.ul =
463 - port_stats->rx_alignment_symbol_errors;
464 - *val = port_stats->rx_alignment_symbol_errors;
732 + *val = stats->rx_alignment_symbol_errors.value.ul;
465 733 break;
466 734
467 735 case ETHER_STAT_FCS_ERRORS:
468 - stats->rx_crc_errors.value.ul =
469 - port_stats->rx_crc_errors;
470 - *val = port_stats->rx_crc_errors;
736 + *val = stats->rx_crc_errors.value.ul;
471 737 break;
472 738
473 739 case ETHER_STAT_MACRCV_ERRORS:
474 - stats->rx_errors.value.ul = port_stats->rx_crc_errors +
475 - port_stats->rx_alignment_symbol_errors +
476 - port_stats->rx_in_range_errors +
477 - port_stats->rx_out_range_errors +
478 - port_stats->rx_frame_too_long +
479 - port_stats->rx_ip_checksum_errs +
480 - port_stats->rx_tcp_checksum_errs +
481 - port_stats->rx_udp_checksum_errs;
482 -
483 740 *val = stats->rx_errors.value.ul;
484 741 break;
485 742
486 743 case ETHER_STAT_MACXMT_ERRORS:
487 744 *val = stats->tx_errors.value.ul;
488 745 break;
489 746
490 747 case ETHER_STAT_TOOLONG_ERRORS:
491 - stats->rx_frame_too_long.value.ul =
492 - port_stats->rx_frame_too_long;
493 - *val = port_stats->rx_frame_too_long;
748 + *val = stats->rx_frame_too_long.value.ul;
494 749 break;
495 750
496 751 case ETHER_STAT_CAP_PAUSE:
497 752 case ETHER_STAT_LINK_PAUSE:
498 753 if (dev->flow_control & OCE_FC_TX &&
499 754 dev->flow_control & OCE_FC_RX)
500 755 *val = LINK_FLOWCTRL_BI;
501 756 else if (dev->flow_control == OCE_FC_TX)
502 757 *val = LINK_FLOWCTRL_TX;
503 758 else if (dev->flow_control == OCE_FC_RX)
504 759 *val = LINK_FLOWCTRL_RX;
505 760 else if (dev->flow_control == 0)
506 761 *val = LINK_FLOWCTRL_NONE;
507 762 break;
508 763
509 764 default:
510 - mutex_exit(&dev->dev_lock);
765 + mutex_exit(&dev->stat_lock);
511 766 return (ENOTSUP);
512 767 }
513 - mutex_exit(&dev->dev_lock);
768 + mutex_exit(&dev->stat_lock);
514 769 return (0);
515 770 } /* oce_m_stat */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX