/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2002 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #include #include #include #include #include #include #include #include /* * Module : Single or Two Rate Metering module - tokenmt * Description * This module implements the metering part of RFC 2698 & 2697. It accepts the * committed rate, peak rate (optional), committed burst and peak burst for a * flow and determines if the flow is within the cfgd. rates and assigns * next action appropriately.. * If the peak rate is provided this acts as a two rate meter (RFC 2698), else * a single rate meter (RFC 2697). If this is a two rate meter, then * the outcome is either green, red or yellow. Else if this a single rate * meter and the peak burst size is not provided, the outcome is either * green or red. * Internally, it maintains 2 token buckets, Tc & Tp, each filled with * tokens equal to committed burst & peak burst respectively initially. * When a packet arrives, tokens in Tc or Tp are updated at the committed * or the peak rate up to a maximum of the committed or peak burst size. * If there are enough tokens in Tc, the packet is Green, else if there are * enough tokens in Tp, the packet is Yellow, else the packet is Red. In case * of Green and Yellow packets, Tc and/or Tp is updated accordingly. */ int tokenmt_debug = 0; /* Updating tokens */ static void tokenmt_update_tokens(tokenmt_data_t *, hrtime_t); /* * Given a packet and the tokenmt_data it belongs to, this routine meters the * ToS or DSCP for IPv4 and IPv6 resp. with the values configured for * the tokenmt_data. */ int tokenmt_process(mblk_t **mpp, tokenmt_data_t *tokenmt_data, ipp_action_id_t *next_action) { uint8_t dscp; ipha_t *ipha; ip6_t *ip6_hdr; uint32_t pkt_len; mblk_t *mp = *mpp; hrtime_t now; enum meter_colour colour; tokenmt_cfg_t *cfg_parms = tokenmt_data->cfg_parms; if (mp == NULL) { tokenmt0dbg(("tokenmt_process: null mp!\n")); atomic_inc_64(&tokenmt_data->epackets); return (EINVAL); } if (mp->b_datap->db_type != M_DATA) { if ((mp->b_cont != NULL) && (mp->b_cont->b_datap->db_type == M_DATA)) { mp = mp->b_cont; } else { tokenmt0dbg(("tokenmt_process: no data\n")); atomic_inc_64(&tokenmt_data->epackets); return (EINVAL); } } /* Figure out the ToS/Traffic Class and length from the message */ if ((mp->b_wptr - mp->b_rptr) < IP_SIMPLE_HDR_LENGTH) { if (!pullupmsg(mp, IP_SIMPLE_HDR_LENGTH)) { tokenmt0dbg(("tokenmt_process: pullup error\n")); atomic_inc_64(&tokenmt_data->epackets); return (EINVAL); } } ipha = (ipha_t *)mp->b_rptr; if (IPH_HDR_VERSION(ipha) == IPV4_VERSION) { /* discard last 2 unused bits */ dscp = ipha->ipha_type_of_service; pkt_len = ntohs(ipha->ipha_length); } else { ip6_hdr = (ip6_t *)mp->b_rptr; /* discard ECN bits */ dscp = __IPV6_TCLASS_FROM_FLOW(ip6_hdr->ip6_vcf); pkt_len = ntohs(ip6_hdr->ip6_plen) + ip_hdr_length_v6(mp, ip6_hdr); } /* Convert into bits */ pkt_len <<= 3; now = gethrtime(); mutex_enter(&tokenmt_data->tokenmt_lock); /* Update the token counts */ tokenmt_update_tokens(tokenmt_data, now); /* * Figure out the drop preced. for the pkt. Need to be careful here * because if the mode is set to COLOUR_AWARE, then the dscp value * is used regardless of whether it was explicitly set or not. * If the value is defaulted to 000 (drop precd.) then the pkt * will always be coloured RED. */ if (cfg_parms->tokenmt_type == SRTCL_TOKENMT) { if (!cfg_parms->colour_aware) { if (pkt_len <= tokenmt_data->committed_tokens) { tokenmt_data->committed_tokens -= pkt_len; *next_action = cfg_parms->green_action; } else if (pkt_len <= tokenmt_data->peak_tokens) { /* * Can't do this if yellow_action is not * configured. */ ASSERT(cfg_parms->yellow_action != TOKENMT_NO_ACTION); tokenmt_data->peak_tokens -= pkt_len; *next_action = cfg_parms->yellow_action; } else { *next_action = cfg_parms->red_action; } } else { colour = cfg_parms->dscp_to_colour[dscp >> 2]; if ((colour == TOKENMT_GREEN) && (pkt_len <= tokenmt_data->committed_tokens)) { tokenmt_data->committed_tokens -= pkt_len; *next_action = cfg_parms->green_action; } else if (((colour == TOKENMT_GREEN) || (colour == TOKENMT_YELLOW)) && (pkt_len <= tokenmt_data->peak_tokens)) { /* * Can't do this if yellow_action is not * configured. */ ASSERT(cfg_parms->yellow_action != TOKENMT_NO_ACTION); tokenmt_data->peak_tokens -= pkt_len; *next_action = cfg_parms->yellow_action; } else { *next_action = cfg_parms->red_action; } } } else { if (!cfg_parms->colour_aware) { if (pkt_len > tokenmt_data->peak_tokens) { *next_action = cfg_parms->red_action; } else if (pkt_len > tokenmt_data->committed_tokens) { /* * Can't do this if yellow_action is not * configured. */ ASSERT(cfg_parms->yellow_action != TOKENMT_NO_ACTION); tokenmt_data->peak_tokens -= pkt_len; *next_action = cfg_parms->yellow_action; } else { tokenmt_data->committed_tokens -= pkt_len; tokenmt_data->peak_tokens -= pkt_len; *next_action = cfg_parms->green_action; } } else { colour = cfg_parms->dscp_to_colour[dscp >> 2]; if ((colour == TOKENMT_RED) || (pkt_len > tokenmt_data->peak_tokens)) { *next_action = cfg_parms->red_action; } else if ((colour == TOKENMT_YELLOW) || (pkt_len > tokenmt_data->committed_tokens)) { /* * Can't do this if yellow_action is not * configured. */ ASSERT(cfg_parms->yellow_action != TOKENMT_NO_ACTION); tokenmt_data->peak_tokens -= pkt_len; *next_action = cfg_parms->yellow_action; } else { tokenmt_data->committed_tokens -= pkt_len; tokenmt_data->peak_tokens -= pkt_len; *next_action = cfg_parms->green_action; } } } mutex_exit(&tokenmt_data->tokenmt_lock); /* Update Stats */ if (*next_action == cfg_parms->green_action) { atomic_inc_64(&tokenmt_data->green_packets); atomic_add_64(&tokenmt_data->green_bits, pkt_len); } else if (*next_action == cfg_parms->yellow_action) { atomic_inc_64(&tokenmt_data->yellow_packets); atomic_add_64(&tokenmt_data->yellow_bits, pkt_len); } else { ASSERT(*next_action == cfg_parms->red_action); atomic_inc_64(&tokenmt_data->red_packets); atomic_add_64(&tokenmt_data->red_bits, pkt_len); } return (0); } void tokenmt_update_tokens(tokenmt_data_t *tokenmt_data, hrtime_t now) { tokenmt_cfg_t *cfg_parms = (tokenmt_cfg_t *)tokenmt_data->cfg_parms; hrtime_t diff = now - tokenmt_data->last_seen; uint64_t tokens; switch (cfg_parms->tokenmt_type) { case SRTCL_TOKENMT: tokens = (cfg_parms->committed_rate * diff) / METER_SEC_TO_NSEC; /* * Add tokens at the committed rate to * committed_tokens. If they are in excess of * the committed burst, add the excess to * peak_tokens, capped to peak_burst. */ if ((tokenmt_data->committed_tokens + tokens) > cfg_parms->committed_burst) { tokens = tokenmt_data->committed_tokens + tokens - cfg_parms->committed_burst; tokenmt_data->committed_tokens = cfg_parms->committed_burst; tokenmt_data->peak_tokens = MIN(cfg_parms->peak_burst, tokenmt_data->peak_tokens + tokens); } else { tokenmt_data->committed_tokens += tokens; } break; case TRTCL_TOKENMT: /* Fill at the committed rate */ tokens = (diff * cfg_parms->committed_rate) / METER_SEC_TO_NSEC; tokenmt_data->committed_tokens = MIN(cfg_parms->committed_burst, tokenmt_data->committed_tokens + tokens); /* Fill at the peak rate */ tokens = (diff * cfg_parms->peak_rate) / METER_SEC_TO_NSEC; tokenmt_data->peak_tokens = MIN(cfg_parms->peak_burst, tokenmt_data->peak_tokens + tokens); break; } tokenmt_data->last_seen = now; }