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 2002 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <sys/types.h>
28 #include <sys/kmem.h>
29 #include <sys/conf.h>
30 #include <sys/sysmacros.h>
31 #include <netinet/in.h>
32 #include <netinet/in_systm.h>
33 #include <netinet/ip6.h>
34 #include <inet/common.h>
35 #include <inet/ip.h>
36 #include <inet/ip6.h>
37 #include <ipp/meters/meter_impl.h>
38
39 /*
40 * Module : Single or Two Rate Metering module - tokenmt
41 * Description
42 * This module implements the metering part of RFC 2698 & 2697. It accepts the
43 * committed rate, peak rate (optional), committed burst and peak burst for a
44 * flow and determines if the flow is within the cfgd. rates and assigns
45 * next action appropriately..
46 * If the peak rate is provided this acts as a two rate meter (RFC 2698), else
47 * a single rate meter (RFC 2697). If this is a two rate meter, then
48 * the outcome is either green, red or yellow. Else if this a single rate
49 * meter and the peak burst size is not provided, the outcome is either
50 * green or red.
51 * Internally, it maintains 2 token buckets, Tc & Tp, each filled with
52 * tokens equal to committed burst & peak burst respectively initially.
53 * When a packet arrives, tokens in Tc or Tp are updated at the committed
54 * or the peak rate up to a maximum of the committed or peak burst size.
55 * If there are enough tokens in Tc, the packet is Green, else if there are
56 * enough tokens in Tp, the packet is Yellow, else the packet is Red. In case
57 * of Green and Yellow packets, Tc and/or Tp is updated accordingly.
58 */
59
60 int tokenmt_debug = 0;
61
62 /* Updating tokens */
63 static void tokenmt_update_tokens(tokenmt_data_t *, hrtime_t);
64
65 /*
66 * Given a packet and the tokenmt_data it belongs to, this routine meters the
67 * ToS or DSCP for IPv4 and IPv6 resp. with the values configured for
68 * the tokenmt_data.
69 */
70 int
71 tokenmt_process(mblk_t **mpp, tokenmt_data_t *tokenmt_data,
72 ipp_action_id_t *next_action)
73 {
74 uint8_t dscp;
75 ipha_t *ipha;
76 ip6_t *ip6_hdr;
77 uint32_t pkt_len;
78 mblk_t *mp = *mpp;
79 hrtime_t now;
80 enum meter_colour colour;
81 tokenmt_cfg_t *cfg_parms = tokenmt_data->cfg_parms;
82
83 if (mp == NULL) {
84 tokenmt0dbg(("tokenmt_process: null mp!\n"));
85 atomic_inc_64(&tokenmt_data->epackets);
86 return (EINVAL);
87 }
88
89 if (mp->b_datap->db_type != M_DATA) {
90 if ((mp->b_cont != NULL) &&
91 (mp->b_cont->b_datap->db_type == M_DATA)) {
92 mp = mp->b_cont;
93 } else {
94 tokenmt0dbg(("tokenmt_process: no data\n"));
95 atomic_inc_64(&tokenmt_data->epackets);
96 return (EINVAL);
97 }
98 }
99
100 /* Figure out the ToS/Traffic Class and length from the message */
101 if ((mp->b_wptr - mp->b_rptr) < IP_SIMPLE_HDR_LENGTH) {
102 if (!pullupmsg(mp, IP_SIMPLE_HDR_LENGTH)) {
103 tokenmt0dbg(("tokenmt_process: pullup error\n"));
104 atomic_inc_64(&tokenmt_data->epackets);
105 return (EINVAL);
106 }
107 }
108 ipha = (ipha_t *)mp->b_rptr;
109 if (IPH_HDR_VERSION(ipha) == IPV4_VERSION) {
110 /* discard last 2 unused bits */
111 dscp = ipha->ipha_type_of_service;
112 pkt_len = ntohs(ipha->ipha_length);
113 } else {
114 ip6_hdr = (ip6_t *)mp->b_rptr;
115 /* discard ECN bits */
116 dscp = __IPV6_TCLASS_FROM_FLOW(ip6_hdr->ip6_vcf);
117 pkt_len = ntohs(ip6_hdr->ip6_plen) +
118 ip_hdr_length_v6(mp, ip6_hdr);
119 }
120
121 /* Convert into bits */
122 pkt_len <<= 3;
123
124 now = gethrtime();
125
126 mutex_enter(&tokenmt_data->tokenmt_lock);
127 /* Update the token counts */
128 tokenmt_update_tokens(tokenmt_data, now);
129
130 /*
131 * Figure out the drop preced. for the pkt. Need to be careful here
132 * because if the mode is set to COLOUR_AWARE, then the dscp value
133 * is used regardless of whether it was explicitly set or not.
134 * If the value is defaulted to 000 (drop precd.) then the pkt
135 * will always be coloured RED.
136 */
137 if (cfg_parms->tokenmt_type == SRTCL_TOKENMT) {
138 if (!cfg_parms->colour_aware) {
139 if (pkt_len <= tokenmt_data->committed_tokens) {
140 tokenmt_data->committed_tokens -= pkt_len;
141 *next_action = cfg_parms->green_action;
142 } else if (pkt_len <= tokenmt_data->peak_tokens) {
143 /*
144 * Can't do this if yellow_action is not
145 * configured.
146 */
147 ASSERT(cfg_parms->yellow_action !=
148 TOKENMT_NO_ACTION);
149 tokenmt_data->peak_tokens -= pkt_len;
150 *next_action = cfg_parms->yellow_action;
151 } else {
152 *next_action = cfg_parms->red_action;
153 }
154 } else {
155 colour = cfg_parms->dscp_to_colour[dscp >> 2];
156 if ((colour == TOKENMT_GREEN) &&
157 (pkt_len <= tokenmt_data->committed_tokens)) {
158 tokenmt_data->committed_tokens -= pkt_len;
159 *next_action = cfg_parms->green_action;
160 } else if (((colour == TOKENMT_GREEN) ||
161 (colour == TOKENMT_YELLOW)) &&
162 (pkt_len <= tokenmt_data->peak_tokens)) {
163 /*
164 * Can't do this if yellow_action is not
165 * configured.
166 */
167 ASSERT(cfg_parms->yellow_action !=
168 TOKENMT_NO_ACTION);
169 tokenmt_data->peak_tokens -= pkt_len;
170 *next_action = cfg_parms->yellow_action;
171 } else {
172 *next_action = cfg_parms->red_action;
173 }
174 }
175 } else {
176 if (!cfg_parms->colour_aware) {
177 if (pkt_len > tokenmt_data->peak_tokens) {
178 *next_action = cfg_parms->red_action;
179 } else if (pkt_len > tokenmt_data->committed_tokens) {
180 /*
181 * Can't do this if yellow_action is not
182 * configured.
183 */
184 ASSERT(cfg_parms->yellow_action !=
185 TOKENMT_NO_ACTION);
186 tokenmt_data->peak_tokens -= pkt_len;
187 *next_action = cfg_parms->yellow_action;
188 } else {
189 tokenmt_data->committed_tokens -= pkt_len;
190 tokenmt_data->peak_tokens -= pkt_len;
191 *next_action = cfg_parms->green_action;
192 }
193 } else {
194 colour = cfg_parms->dscp_to_colour[dscp >> 2];
195 if ((colour == TOKENMT_RED) ||
196 (pkt_len > tokenmt_data->peak_tokens)) {
197 *next_action = cfg_parms->red_action;
198 } else if ((colour == TOKENMT_YELLOW) ||
199 (pkt_len > tokenmt_data->committed_tokens)) {
200 /*
201 * Can't do this if yellow_action is not
202 * configured.
203 */
204 ASSERT(cfg_parms->yellow_action !=
205 TOKENMT_NO_ACTION);
206 tokenmt_data->peak_tokens -= pkt_len;
207 *next_action = cfg_parms->yellow_action;
208 } else {
209 tokenmt_data->committed_tokens -= pkt_len;
210 tokenmt_data->peak_tokens -= pkt_len;
211 *next_action = cfg_parms->green_action;
212 }
213 }
214 }
215 mutex_exit(&tokenmt_data->tokenmt_lock);
216
217 /* Update Stats */
218 if (*next_action == cfg_parms->green_action) {
219 atomic_inc_64(&tokenmt_data->green_packets);
220 atomic_add_64(&tokenmt_data->green_bits, pkt_len);
221 } else if (*next_action == cfg_parms->yellow_action) {
222 atomic_inc_64(&tokenmt_data->yellow_packets);
223 atomic_add_64(&tokenmt_data->yellow_bits, pkt_len);
224 } else {
225 ASSERT(*next_action == cfg_parms->red_action);
226 atomic_inc_64(&tokenmt_data->red_packets);
227 atomic_add_64(&tokenmt_data->red_bits, pkt_len);
228 }
229
230 return (0);
231 }
232
233 void
234 tokenmt_update_tokens(tokenmt_data_t *tokenmt_data, hrtime_t now)
235 {
236 tokenmt_cfg_t *cfg_parms = (tokenmt_cfg_t *)tokenmt_data->cfg_parms;
237 hrtime_t diff = now - tokenmt_data->last_seen;
238 uint64_t tokens;
239
240 switch (cfg_parms->tokenmt_type) {
241 case SRTCL_TOKENMT:
242 tokens = (cfg_parms->committed_rate * diff) /
243 METER_SEC_TO_NSEC;
244
245 /*
246 * Add tokens at the committed rate to
247 * committed_tokens. If they are in excess of
248 * the committed burst, add the excess to
249 * peak_tokens, capped to peak_burst.
250 */
251 if ((tokenmt_data->committed_tokens + tokens) >
252 cfg_parms->committed_burst) {
253 tokens = tokenmt_data->committed_tokens
254 + tokens -
255 cfg_parms->committed_burst;
256 tokenmt_data->committed_tokens =
257 cfg_parms->committed_burst;
258 tokenmt_data->peak_tokens =
259 MIN(cfg_parms->peak_burst,
260 tokenmt_data->peak_tokens +
261 tokens);
262 } else {
263 tokenmt_data->committed_tokens +=
264 tokens;
265 }
266 break;
267 case TRTCL_TOKENMT:
268 /* Fill at the committed rate */
269 tokens = (diff * cfg_parms->committed_rate) /
270 METER_SEC_TO_NSEC;
271 tokenmt_data->committed_tokens =
272 MIN(cfg_parms->committed_burst,
273 tokenmt_data->committed_tokens + tokens);
274
275 /* Fill at the peak rate */
276 tokens = (diff * cfg_parms->peak_rate) /
277 METER_SEC_TO_NSEC;
278 tokenmt_data->peak_tokens =
279 MIN(cfg_parms->peak_burst,
280 tokenmt_data->peak_tokens + tokens);
281 break;
282 }
283 tokenmt_data->last_seen = now;
284 }